var ba:ByteArray = new ByteArray();
 ba.writeByte(0x0a);
 ba.writeByte(0x0a);
 ba.writeByte(0x0a);
 ba.writeUTFBytes("Testdump")
 for (var i:int = 0; i < 80; i++)
 {
   ba.writeByte(int(Math.random()*0x50));
 }
 trace(HexDump.dump(ba));

Offset 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
00000000 0A 0A 0A 54 65 73 74 64 75 6D 70 06 0B 27 3D 3B ...Testdump..'=;
00000010 4C 2D 39 22 46 43 1E 20 03 0E 33 1F 07 10 30 17 L-9"FC. ..3...0.
00000020 15 10 3A 19 43 1D 16 3B 02 4F 26 08 25 0C 3E 0B ..:.C..;.O&.%.>.
00000030 37 2A 3E 33 42 2A 2F 04 35 0F 0E 29 06 2E 40 36 7*>3B*/.5..)..@6
00000040 3F 13 14 1C 33 4D 46 40 41 2B 1C 03 3E 3F 1D 3B ?...3MF@A+..>?.;
00000050 2E 3D 21 15 17 42 2E 48 12 37 49                .=!..B.H.7I

package
{
    import flash.utils.ByteArray;
 
    /**
    * @author Björn Acker | www.bjoernacker.de
    */
    public class HexDump
    {
 
        public static function dump(buffer:ByteArray):String
        {
            var out:String = fillUp("Offset", 8, " ") + "  00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n";
            var offset:int = 0;
            var l:int = buffer.length;
            var row:String = "";
            buffer.position = 0;
            for (var i:int = 0; i < l; i += 15)
            {
                row += fillUp(offset.toString(16).toUpperCase(), 8, "0") + "  ";
                var n:int = Math.min(16, buffer.length - buffer.position);
                var string:String = "";
                for (var j:int = 0; j < 16; ++j)
                {
                    if (j < n)                     
                    {
                        var value:int = buffer.readUnsignedByte();
                        string += value >= 32 ? String.fromCharCode(value) : ".";
                        row += fillUp(value.toString(16).toUpperCase(), 2, "0") + " ";
                        offset++;
                    }
                    else
                    {
                        row += "   ";
                        string += " ";
                    }
                }
                row += " " + string + "\n";
            }
            out += row;
            return out;
        }
 
        private static function fillUp(value:String, count:int, fillWith:String):String
        {
            var l:int = count - value.length;
            var ret:String = "";
            while (--l > -1)
            ret += fillWith;
            return ret + value;
        }
    }
}

private function startLoading():void
    //Create the asset loader and add the assets to the load queue
    _assetsLoader = new AssetsLoader();
    _assetsLoader.addAsset("agent", "assets/agent.swf", AssetType.DISPLAY_OBJECT);
    _assetsLoader.addAsset("xml", "assets/text.xml", AssetType.TEXT);
    _assetsLoader.addAsset("machine", "assets/machine.jpg", AssetType.DISPLAY_OBJECT);
    _assetsLoader.addAsset("assets", "assets/assets.png", AssetType.DISPLAY_OBJECT);
    _assetsLoader.addEventListener(Event.COMPLETE, onComplete);
    _assetsLoader.addEventListener(AssetProgressEvent.EVENT, onProgress);
    _assetsLoader.addEventListener(AssetLoadedEvent.EVENT, onAssetLoaded);
    _assetsLoader.load();
}
 
/**
 * Will be called if a asset has been loaded and is ready to use
 */
private function onAssetLoaded(e:AssetLoadedEvent):void
{
    //The "agent" asset has the logo movieclip exported for AS
    if (e.currentAssetKey == "agent")
    {
        _logo = Sprite( AssetsLoader.getAssetClassInstance("agent", "asset_logo") );
        _container.addChild(_logo);
        onResize(null);
    }
}
 
/**
 * Will be triggered while an asset is loading
 */
private function onProgress(e:AssetProgressEvent):void
{
    trace(e.currentAssetKey, e.assetsLoaded, e.assetsTotal, e.percent, e.bytesLoaded, e.bytesTotal);
}
 
/**
 * Will be called if all assets are loaded
 */
private function onComplete(e:Event):void
{
    //do something very important
}

"pivot_muzzle_left": [
     {"x": -56,"y": -55},

index = (currentDirection - 1) * numberOfAnimationFrames + currentFrame

_layer1 = new ParallaxLayer(0); //cloud layer
_layer2 = new ParallaxLayer(70); //ship layer
_layer3 = new ParallaxLayer(120); // tiles layer
_layer4 = new ParallaxLayer(250); // cloud layer
_layer5 = new ParallaxLayer(600); // tiles layer
_layer6 = new ParallaxLayer(1000); // tiles layer
_layer7 = new ParallaxLayer(2000); // planet layer

addChild(_layer7);
addChild(_layer6);
addChild(_layer5);
addChild(_layer4);
addChild(_layer3);
addChild(_layer2);
addChild(_layer1);

_cam = new AdvancedCamera2D(camera);
_cam.addLayer(_layer1);
_cam.addLayer(_layer2);
_cam.addLayer(_layer3);
_cam.addLayer(_layer4);
_cam.addLayer(_layer5);
_cam.addLayer(_layer6);
_cam.addLayer(_layer7);

_cam.setTarget(aTarget);

_cam.bounds = new Rectangle( -2048, -2048, 2048, 2048 );

_cam.movementZoomFactor = 40;

"tex ft0, v0, fs0 <2d,repeat,linear,mipnearest>\n" 
"add oc, ft0, fc0 \n"

package
{
 import flash.events.Event;
 import flash.events.EventDispatcher;
 import flash.events.SecurityErrorEvent;
 import flash.utils.clearInterval;
 import flash.utils.getTimer;
 import flash.utils.setInterval;
 
 /**
 * @author Björn Acker | www.bjoernacker.de
 */
 public class SpeedWatchDog extends EventDispatcher
 {
 protected var _tolerance:Number;
 protected var _prevDate:Number;
 protected var _prevTimer:int;
 protected var _interval:uint;
 
 [Event(name="securityError",type="flash.events.SecurityErrorEvent")]
 
 public function init(interval:int = 1000, tolerance:Number = 0.35):void
 {
 _tolerance = tolerance;
 _prevTimer = getTimer();
 _prevDate = new Date().time;
 this.interval = interval;
 }
 
 public function stop():void
 {
 clearInterval(_interval);
 }
 
 public function get tolerance():Number
 {
 return _tolerance;
 }
 
 public function set tolerance(value:Number):void
 {
 _tolerance = value;
 }
 
 public function get interval():uint
 {
 return _interval;
 }
 
 public function set interval(value:uint):void
 {
 clearInterval(_interval);
 _interval = setInterval(check, value);
 }
 
 protected function check():void
 {
 var date:Number = new Date().time - _prevDate;
 var timer:Number = getTimer() - _prevTimer;
 var t:Number = date * _tolerance;
 if (timer > date + t || timer < date - t)
 {
 dispatchEvent(new SecurityErrorEvent(SecurityErrorEvent.SECURITY_ERROR));
 }
 _prevTimer = getTimer();
 _prevDate = new Date().time;
 }
 }
}

var wd:SpeedWatchDog = new SpeedWatchDog();
//Check every 2 seconds with a tolerance of 40%
wd.init(2000, 0.4);
wd.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSpeedHack;
 
function onSpeedHack(e:Event):void
{
   trace("speedhack detected");
}

package
{
    import flash.utils.clearInterval;
    import flash.utils.Dictionary;
    import flash.utils.setInterval;
 
    /**
     * @author Björn Acker | www.bjoernacker.de
     */
    public class NumberVault
    {
 
        private static var _list:Dictionary = new Dictionary();
        private static var _interval:int = -1;
 
        public static function setNumber(key:*, value:Number):void
        {
            value = Math.round(value * 1000000) / 1000000;
            var s:String = String(value);
            var index:int = s.indexOf(".");
            var d:Number = index == -1 ? 1 : Math.pow(10, int(s.length - index - 1));
            value *= d;
            var x:int = int(Math.random() * (2 * int.MAX_VALUE) - int.MAX_VALUE);
            value ^= x;
            _list[key] = {v: value, x: x, d: d};
        }
 
        public static function getNumber(key:*):Number
        {
            var obj:Object = _list[key];
            if (obj == null)
                throw new Error("Key doesn't exist");
            return Math.round(Number((obj.v ^ int(obj.x)) / obj.d) * 1000000) / 1000000;
        }
 
        public static function clearNumber(key:*):void
        {
            _list[key] = null;
            delete _list[key];
        }
 
        public static function clearAll(key:*):void
        {
            _list = new Dictionary();
        }
 
        public static function shakeNumber(key:*):void
        {
            var obj:Object = _list[key];
            if (obj == null)
                throw new Error("Key doesn't exist");
            var x:int = int(Math.random() * (2 * int.MAX_VALUE) - int.MAX_VALUE);
            obj.v = Math.round(Number((obj.v ^ int(obj.x)) ^ x) * 1000000) / 1000000;
            obj.x = x;
        }
 
        public static function shakeAll():void
        {
            for (var i:String in _list)
                shakeNumber(i);
        }
 
        public static function autoShake(interval:int=100):void
        {
            _interval = setInterval(shakeAll, interval);
        }
 
        public static function stopAutoShake():void
        {
            if (_interval != -1)
            {
                clearInterval(_interval);
                _interval = -1;
            }
        }
    }
}

NumberVault.setNumber("score", 100);

NumberVault.getNumber("score");

NumberVault.setNumber("score", NumberVault.getNumber("score")+100);