nape example: platformer

package example
{
    import example.baseExample;
    import example.kinematicplatform.kinematicBodyInfo;
    import example.platformer.physPlayer;
    import flash.display.DisplayObjectContainer;
    import flash.events.KeyboardEvent;
    import nape.callbacks.CbEvent;
    import nape.callbacks.CbType;
    import nape.callbacks.InteractionListener;
    import nape.callbacks.InteractionType;
    import nape.callbacks.PreCallback;
    import nape.callbacks.PreFlag;
    import nape.callbacks.PreListener;
    import nape.geom.Vec2;
    import nape.phys.Body;
    import nape.phys.BodyType;
    import nape.phys.Compound;
    import nape.shape.Polygon;

    /**
     * ...
     * @author Liu Wong
     *
     */

    public class platformerExample extends baseExample
    {
        private var player:physPlayer;

        private var playerCb:CbType;
        private var playerExCb:CbType;
        private var oneWayPlatformCb:CbType;

        private var keys:Array = [false, false, false];

        private var kinemticBodies:Array/*kinematicBodyInfo*/;

        public function platformerExample(prnt:DisplayObjectContainer):void
        {
            super(prnt);
        }

        override protected function init():void
        {
            super.init();

            space.gravity.setxy(0, 980);

            addHand();

            addWalls();

            playerCb = new CbType();
            playerExCb = new CbType();
            oneWayPlatformCb = new CbType();

            player = new physPlayer(space, new Vec2(100, 50), playerCb, playerExCb);

            addBlock(200, 380, 200, 200);
            addBlock(320, 430, 100, 100);
            addBlock(400, 450, 50, 50);

            kinemticBodies = new Array();

            var k:int = 8;
            var i:int;

            const platformSize:Number = 64;

            for (i = 0; i < k; i++)
            {
                var v1:Vec2 = new Vec2(100 + i * platformSize, 100);
                var v2:Vec2 = new Vec2(100 + i * platformSize, 450);
                var speed:Number = 100 + Math.random() * 50;
                var tmp:kinematicBodyInfo = addPlatform(v1, v2, speed);
                var b:Body = tmp.body;

                b.userData.trigger = true;
                b.userData.speed = speed;
                b.userData.v1 = v1;
                b.userData.v2 = v2;

                b.userData.normal = Vec2.fromPolar(1, Math.PI * 0.25);
                b.userData.normal2 = Vec2.fromPolar(1, Math.PI * 0.75);

                b.shapes.add(new Polygon(Polygon.box(platformSize, platformSize)));

                b.cbTypes.add(oneWayPlatformCb);

                kinemticBodies.push(tmp);
            }

            space.listeners.add(new InteractionListener(CbEvent.ONGOING, InteractionType.COLLISION, CbType.ANY_BODY, playerExCb, player.onCollision));
            space.listeners.add(new PreListener(InteractionType.COLLISION, oneWayPlatformCb, playerCb, onPlatform, 0, true));

            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
            stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp);
        }

        private function addBlock(xx:Number, yy:Number, ww:Number, hh:Number):void
        {
            var b:Body = addRectangle(xx, yy, ww, hh);
            b.userData.normal = Vec2.fromPolar(1, Math.PI * 0.25);
            b.userData.normal2 = Vec2.fromPolar(1, Math.PI * 0.75);
            b.cbTypes.add(oneWayPlatformCb);
        }

        private function addPlatform(pos:Vec2, finish:Vec2, time:Number):kinematicBodyInfo
        {
            var tmp:Body = new Body(BodyType.KINEMATIC, pos);

            var bi:kinematicBodyInfo = new kinematicBodyInfo(tmp);
            bi.onFinish = onFinish;
            bi.updateFinish(finish);
            bi.updateSpeed(time);

            tmp.space = space;

            return bi;
        }

        private function onFinish(src:kinematicBodyInfo):void
        {
            var b:Boolean = src.body.userData.trigger;
            src.body.userData.trigger = !b;

            var v:Vec2;

            if (b)
                v = src.body.userData.v1.copy()
            else
                v = src.body.userData.v2.copy();

            src.updateFinish(v);
            src.updateSpeed(src.body.userData.speed);
        }

        private function onPlatform(cb:PreCallback):PreFlag
        {
            var v1:Vec2 = cb.arbiter.collisionArbiter.normal.copy();
            if (!cb.swapped)
                v1.muleq( -1);

            var body:Body = cb.int1.castBody;

            if (body.userData.normal.dot(v1) > 0)
                if (body.userData.normal2.dot(v1) > 0)
                    return PreFlag.ACCEPT;

            return PreFlag.IGNORE;
        }

        protected function onKeyDown(event:KeyboardEvent):void
        {
            switch (event.keyCode)
            {
                case 37://left
                    keys[0] = true;
                    return;

                case 39://right
                    keys[1] = true;
                    return;

                case 38://jump
                    keys[2] = true;
                    return;
            }

            return;
        }

        protected function onKeyUp(event:KeyboardEvent):void
        {
            switch (event.keyCode)
            {
                case 37://left
                    keys[0] = false;
                    return;

                case 39://right
                    keys[1] = false;
                    return;

                case 38://jump
                    keys[2] = false;
                    player.resetJump();
                    return;
            }
        }

        private function updatePlayerControl():void
        {
            var b:Boolean = false;

            if (keys[0])
            {
                player.left();

                b = true;
            }

            if (keys[1])
            {
                player.right();

                b = true;
            }

            if (keys[2])
            {
                player.jump();
            }

            if (b == false)
                player.applyDamping();
        }

        override protected function miniUpdate(delta:Number):void
        {
            player.resetCounter();

            super.miniUpdate(delta);
        }

        override protected function miniPostUpdate(delta:Number):void
        {
            super.miniPostUpdate(delta);

            player.update();

            updatePlayerControl();
        }

        override public function update():void
        {
            super.update();

            var k:int = kinemticBodies.length;
            var i:int;

            if (k > 0)
            {
                for (i = 0; i < k; i++)
                {
                    kinemticBodies[i].update();
                }
            }
        }

        override public function free():void
        {
            player.free();
            player = null;

            kinemticBodies.length = 0;
            kinemticBodies = null;

            super.free();

            stage.removeEventListener(KeyboardEvent.KEY_UP, onKeyUp);
            stage.removeEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
        }
    }

}