404 Jogos/CLJG.iso/Diversos/Beez.swf/scripts/core/objects/Platform.as

Text File | 2008-09-03 | 7.3 KB | 225 lines

package core.objects
{
   import Box2D.Collision.Shapes.b2CircleDef;
   import Box2D.Collision.Shapes.b2PolygonDef;
   import Box2D.Collision.Shapes.b2Shape;
   import Box2D.Collision.Shapes.b2ShapeDef;
   import Box2D.Collision.b2ContactPoint;
   import Box2D.Common.Math.b2Math;
   import Box2D.Common.Math.b2Vec2;
   import Box2D.Dynamics.Joints.b2RevoluteJointDef;
   import Box2D.Dynamics.b2Body;
   import Box2D.Dynamics.b2BodyDef;
   import core.BContactListener;
   import core.Input;
   import core.events.CoreEvent;
   import flash.display.Sprite;
   import flash.geom.Point;
   import flash.media.Sound;
   import flash.media.SoundTransform;

   public class Platform extends BaseObject
   {

      public static const NORMAL_TORQUE:Number = 1000;

      public static const POWERUP_TORQUE:Number = NORMAL_TORQUE * 3;


      private var minImpulse:Number = 10;

      private var torque:Number;

      private var input:Input;

      public var platformDef:PlatformDef;

      protected var sndCollide:Sound;

      private var inputEnabled:Boolean;

      public var torqueMult:int;

      private var maxImpulse:Number = 100;

      public function Platform(def:PlatformDef)
      {
         platformDef = def;
         super(def);
      }

      override protected function createShapeDef() : b2ShapeDef
      {
         var shapeDef:b2PolygonDef = new b2PolygonDef();
         shapeDef.SetAsBox(platformDef.width / 2 / engine.m_physScale,platformDef.height / 2 / engine.m_physScale);
         shapeDef.density = 3;
         shapeDef.friction = 0.5;
         shapeDef.restitution = 0.2;
         return shapeDef;
      }

      private function updateHandler(e:CoreEvent) : void
      {
         updateSkin();
      }

      public function disableInput() : void
      {
         inputEnabled = false;
      }

      private function collideAddHandler(e:CoreEvent) : void
      {
         var otherBody:b2Body = null;
         var v1:b2Vec2 = null;
         var dot:Number = NaN;
         var impulse:Number = NaN;
         var pos:Point = null;
         var playerShape:b2Shape = null;
         var point:b2ContactPoint = e.data as b2ContactPoint;
         var body1:b2Body = point.shape1.m_body;
         var body2:b2Body = point.shape2.m_body;
         if(body1.m_userData == this || body2.m_userData == this)
         {
            otherBody = body1.m_userData == this ? body2 : body1;
            if(otherBody.m_userData is PlayerBall)
            {
               playerShape = otherBody == body1 ? point.shape1 : point.shape2;
               if(playerShape != engine.playerBall.mainShape)
               {
                  return;
               }
            }
            v1 = otherBody.m_linearVelocity;
            dot = Math.abs(b2Math.b2Dot(v1,point.normal));
            impulse = dot * otherBody.m_mass;
            if(impulse < minImpulse)
            {
               return;
            }
            if(impulse > maxImpulse)
            {
               impulse = maxImpulse;
            }
            pos = new Point(point.position.x * engine.m_physScale,point.position.y * engine.m_physScale);
            ballCollide(impulse / maxImpulse,pos);
         }
      }

      public function setTorque(value:Number) : void
      {
         torque = value;
      }

      public function enableInput() : void
      {
         inputEnabled = true;
      }

      override protected function init() : void
      {
         input = Input.getInstance();
         torque = NORMAL_TORQUE;
         torqueMult = 1;
         inputEnabled = true;
         super.init();
         fix();
         updateSkin();
         initSounds();
         engine.dispatcher.addEventListener(CoreEvent.PRE_UPDATE,preUpdateHandler);
         engine.dispatcher.addEventListener(CoreEvent.UPDATE,updateHandler);
         engine.contactListener.dispatcher.addEventListener(BContactListener.COLLIDE_ADD,collideAddHandler);
      }

      override protected function createSkin() : Sprite
      {
         var SkinClass:Class = engine.assets.getAssetClass("PlatformAsset");
         var skin:Sprite = new SkinClass();
         engine.canvas.playerContainer.addChild(skin);
         return skin;
      }

      private function fix() : void
      {
         var pos:b2Vec2 = body.GetPosition().Copy();
         var shapeDef:b2CircleDef = new b2CircleDef();
         shapeDef.radius = 10 / engine.m_physScale;
         shapeDef.density = 0;
         shapeDef.isSensor = true;
         var bodyDef:b2BodyDef = new b2BodyDef();
         bodyDef.position.Set(pos.x,pos.y);
         var fixBody:b2Body = engine.m_world.CreateBody(bodyDef);
         fixBody.CreateShape(shapeDef);
         fixBody.SetMassFromShapes();
         var rjd:b2RevoluteJointDef = new b2RevoluteJointDef();
         rjd.Initialize(body,fixBody,body.GetWorldCenter());
         engine.m_world.CreateJoint(rjd);
      }

      private function preUpdateHandler(e:CoreEvent) : void
      {
         if(!inputEnabled)
         {
            return;
         }
         if(input.isKeyPressed(Input.KEY_LEFT))
         {
            body.ApplyTorque(-torqueMult * torque);
         }
         else if(input.isKeyPressed(Input.KEY_RIGHT))
         {
            body.ApplyTorque(torqueMult * torque);
         }
      }

      override protected function createBodyDef() : b2BodyDef
      {
         var bodyDef:b2BodyDef = new b2BodyDef();
         bodyDef.position.Set(platformDef.x / engine.m_physScale,platformDef.y / engine.m_physScale);
         bodyDef.userData = this;
         bodyDef.angularDamping = 5;
         return bodyDef;
      }

      private function particleCompleteHandler(particle:Sprite) : void
      {
         particle.parent.removeChild(particle);
      }

      override public function destroy(e:CoreEvent = null) : void
      {
         super.destroy(e);
         engine.dispatcher.removeEventListener(CoreEvent.PRE_UPDATE,preUpdateHandler);
         engine.dispatcher.removeEventListener(CoreEvent.UPDATE,updateHandler);
      }

      protected function initSounds() : void
      {
         var CollideClass:Class = engine.assets.getAssetClass("SndBallCollide");
         sndCollide = new CollideClass();
      }

      override protected function createBody(bodyDef:b2BodyDef, shapeDef:b2ShapeDef) : b2Body
      {
         var body:b2Body = engine.m_world.CreateBody(bodyDef);
         body.CreateShape(shapeDef);
         body.SetMassFromShapes();
         return body;
      }

      private function ballCollide(strength:Number, pos:Point) : void
      {
         var particle:BounceParticle = null;
         var sndTransform:SoundTransform = new SoundTransform(engine.sndTransform.volume);
         sndTransform.volume *= strength;
         engine.sndChannel = sndCollide.play(0,0,sndTransform);
         var ParticleClass:Class = engine.assets.getAssetClass("CollideParticleAsset");
         var particlesNum:Number = Math.round(strength * 5);
         for(var i:uint = 0; i < particlesNum; i++)
         {
            particle = new BounceParticle(pos.x,pos.y);
         }
      }
   }
}