Developing physics-based games with Adobe Flash Professional

//Marks the right margin of code *******************************************************************
package
{
   
   //--------------------------------------
   //  Imports
   //--------------------------------------
   import com.actionsnippet.qbox.QuickBox2D;
   import com.actionsnippet.qbox.QuickObject;
   
   import flash.display.MovieClip;
   import flash.display.Sprite;

   /**
    * This metadata sets the size and framerate for the project.
    * 
    **/ 
    [SWF(width="600", height="300", backgroundColor="#cbcbcb", frameRate="30")]
   //--------------------------------------
   //  Class
   //--------------------------------------
   public class QuickBox2DDemo extends Sprite
   {      
      
      //--------------------------------------
      //  Properties
      //--------------------------------------
      //PUBLIC GETTER/SETTERS
      /**
       * Master Container for holding the physics bodies' visual parts
       * 
       **/ 
      private var _sim_movieclip : MovieClip;
      
      /**
       * Master Container for holding the physics bodies' data objects
       * 
       **/ 
      private var _sim_quickbox2D : QuickBox2D;
      
      /**
       * MovieClipSkins. A or B
       * 
       * A) Published From Flash Builder 4: This project utilizes the './libs/StackZGame_assets_v1.swc' for graphics skinning
       * B) Published From Flash CS4: This project utilizes library assets for graphics skinning
       * 
       * Below when BlockSkin class is used, know that it is from that swc.
       * 
       */
      
      /**
       * Constants
       * 
       **/
      public static const PHYSICS_SCALE       : Number = 1/30;
      public static const PHYSICS_TIME_STEP   : Number = 1/30;
      
      
      //--------------------------------------
      //  Constructor
      //--------------------------------------
      /**
       * Initialization of;
       * The display list for visual elements
       * The Physical world with properties to define how the world will behave
       * The Blocks are added to the world with their own properties
       * The world is 'started' so the interaction and 'fun' begins.
       * 
       * <span class="hide">Any hidden comments go here.</span>
       *
       */
      public function QuickBox2DDemo ()
      {
         //   SUPER
         super (); 
         
         //   CREATE A MOVIECLIP FOR THE PHYSICS WORLD
         _sim_movieclip  = new MovieClip ();
         addChild (_sim_movieclip);

         //   CREATE THE PHYSICS WORLD (Partial list of parameters (default + description) is shown
         _sim_quickbox2D = new QuickBox2D (_sim_movieclip, 
            {
               
               //   Rendering
               debug         :    false,              //false - Temporarily Render w/ Drawing API
               simpleRender  :    true,               //true - Toggles simple vs Custom Graphics
               renderJoints  :    true,               //true, - Toggles rendering of joints
               
               //   Physics
               gravityX      :    0,                  //0 - The x component of gravity
               gravityY      :    20,                 //20 - The y component of gravity
               timeStep      :    PHYSICS_TIME_STEP,  //1/60 - The Box2D time step.
               iterations    :    20,                 //20 - The Box2D iterations.
               frim          :    false,              //true, Toggles (Frame Rate 
                                                      //Independent Movement).
               
               //   Misc
               bounds      :    [-100, -100, 100, 100], //[-100, -100, 100, 100] - World Bounds
               customMouse :    false                   //false - For MouseEvents in 3D Worlds
               
            });
         
         //   CREATE RIGID WALLS AROUND STAGE (NOT NEEDED, BUT CAN BE USEFUL)
         _sim_quickbox2D.createStageWalls();
         
         //   SET DEFAULTS FOR MOVABLE OBJECTS   (density != 0)
         _sim_quickbox2D.setDefault   
            (   
               {
                  linearDamping   :    1,    //Friction applied from the 'air'
                  density         :    1,    //More Dense = Moves Slower
                  friction        :    1     //Friction applied from colliding with other rigid bodies
               }
            );
         
          //   START THE PHYSICS & ENABLE MOUSE
         _sim_quickbox2D.start();       //run an enterfame to power the engine
         _sim_quickbox2D.mouseDrag();   //allow mouse to move all objects (with density != 0)

         //   CREATE SOME BLOCKS TO PLAY WITH
             for (var blockIndex_uint : uint = 0; blockIndex_uint < 3; blockIndex_uint ++) {
            _doCreateNewBlock (blockIndex_uint);
         }
         
      }
      

      /**
       * Create a new physical block with visual skin
       * 
       * @param aBlockIndex_uint The index of the current block being created.
       * 
       * @return void
       */
      private function _doCreateNewBlock (aBlockIndex_uint : uint) : void
      {
         //CREATE MOVABLE OBJECT - A falling block at top, offscreen
         var lastBlock_quickobject : QuickObject = _sim_quickbox2D.addBox   
            (      
               {
                  x      : PHYSICS_SCALE     * (100 + Math.random()*400), //Remember to Convert Pixels to Meters
                  y      : PHYSICS_SCALE     * (100 + Math.random()*200), 
                  width   : PHYSICS_SCALE    * 100, 
                  height    : PHYSICS_SCALE  * 100, 
                  skin    : BlockSkin,        //Skin For Rigid Physics Body
                  
                  draggable: true             //User may manipulate the blocks with mouse
               }
            );
         
         //   THE SKIN IS INSTANTIATED, AND ACCESSIBLE AS 'userData'
         //   YOU CAN ALSO STORE ARBITRARY PROPERTIES ON 'userData' for whatever you need
         (lastBlock_quickobject.userData as BlockSkin).character_mc.head_mc.gotoAndStop (aBlockIndex_uint+1); //show 3 faces
      }
   
      
   }
}

var someDistanceInMeters_int  :  int = someDistanceInPixels_int  / 30;

var someDistanceInMeters_int  :  int =  someDistanceInPixels_int  / PHYSICS_SCALE;

//Marks the right margin of code *******************************************************************
package
{
   //--------------------------------------
   //  Imports
   //--------------------------------------
   import Box2D.Dynamics.b2Body;
   
   import com.actionsnippet.qbox.QuickBox2D;
   import com.actionsnippet.qbox.QuickObject;
   
   import flash.display.MovieClip;
   import flash.display.Sprite;
   import flash.events.Event;
   import flash.events.MouseEvent;
   import flash.events.TimerEvent;
   import flash.utils.Timer;
   
   /**
    * This metadata sets the size and framerate for the project.
    * 
    **/ 
   [SWF(width="600", height="600", backgroundColor="#00ff00", frameRate="30")]
   
   //--------------------------------------
   //  Class
   //--------------------------------------
   public class StackZGame extends Sprite
   {      
      
      //--------------------------------------
      //  Properties
      //--------------------------------------
      //PUBLIC GETTER/SETTERS
      /**
       * Master container for holding the physics bodies visual parts
       * 
       **/ 
      private var _sim_movieclip : MovieClip;
      
      /**
       * Physics world and graphics.  Arranged by depth.
       * Tabbed-in here, means its a child of line above.
       * 
       **/ 
      private var _background                 : Background;
      private var _world_sprite               : Sprite;
      private var _platform_quickobject       : QuickObject;
      private var _pedestal_quickobject       : QuickObject;
      private var _lastBlock_quickobject      : QuickObject; 
      private var _platformArrows             : PlatformArrows;
      private var _finishLine                 : FinishLine;
      private var _foreground                 : Foreground;
      private var _scoreTextMC                : ScoreTextMC;
      private var _instructionsTextMC         : InstructionsTextMC;
      private var _border                     : Border;
      private var _sim_quickbox2D             : QuickBox2D;
      
      /**
       * Setup sound 
       * 
       **/
      private var _blockCreation_timer        : Timer;
      private var _blockCreationSound         : BlockCreationSound;
      private var _blockFallenSound           : BlockFallenSound;
         
      /**
       * Block-specific data
       * 
       */
      private var _blocks_array : Array;
      private var _blocksFallenTotal_uint     : uint;
            
      /**
       * MovieClipSkins. A or B
       * 
       * A) Published From Flash Builder 4: This project utilizes the './libs/StackZGame_assets_v1.swc' for graphics skinning
       * B) Published From Flash CS4: This project utilizes library assets for graphics skinning
       * 
       * Below when BlockSkin class is used, know that it is from that swc.
       * 
       */   
      
      /**
       * Constants
       * 
       **/
      public    static const PHYSICS_SCALE                : Number = 1/30;
      public    static const PHYSICS_TIME_STEP            : Number = 1/30;
      public    static const BLOCKS_FALLEN_TOTAL_ALLOWED  : Number = 5;
      private static const BLOCK_FALLEN_Y_LIMIT           : Number = 590;
      
        
      //--------------------------------------
      //  Constructor
      //--------------------------------------
      /**
       * Setup the Layout. This is mostly visual, not physics setup yet.
       * 
       * <span class="hide">Any hidden comments go here.</span>
       *
       */
      public function StackZGame ()
      {
         //   SUPER
         super (); 
         
         //   CREATE WORLD
         _world_sprite = new Sprite ();
         addChild(_world_sprite);
         
         //   ----------------------------------------------------------
         //   POPULATE WORLD 
         //   (from lowest visual depth to highest)
         _background = new Background();
         _world_sprite.addChild (_background);
         //
         _finishLine = new FinishLine ();
         _world_sprite.addChild (_finishLine);
         _finishLine.y = 300;
         //
         _platformArrows = new PlatformArrows ();
         _world_sprite.addChild (_platformArrows);
         //
         var _foreground : MovieClip = new Foreground ();
         _world_sprite.addChild (_foreground);
         //
         _instructionsTextMC = new InstructionsTextMC ();
         _world_sprite.addChild (_instructionsTextMC);
         _instructionsTextMC.y = 5;
         _instructionsTextMC.textField.htmlText =   "Mouse-drag the black pedestal to play! " +
                                                    "Create a tall pile before dropping " +
                                                    BLOCKS_FALLEN_TOTAL_ALLOWED + " blocks";
         
         //
         _scoreTextMC   =  new ScoreTextMC ();
         _world_sprite.addChild (_scoreTextMC);
         _scoreTextMC.y = _instructionsTextMC.y +  _instructionsTextMC.height;
         //
         _border = new Border ();
         addChild (_border);
         
         
         //   ----------------------------------------------------------
         //   CREATE SOUND
         _blockCreationSound = new BlockCreationSound ();
         _blockFallenSound    = new BlockFallenSound ();
         
         //   LISTEN FOR THE RESTARTGAME MOUSE CLICK
         addEventListener (MouseEvent.MOUSE_DOWN, _onMouseClickAnywhere);
         
         //   DO THE INITIAL RESTART - (AKA... the 'start')
         _doRestartGame();
         
      }
      
      /**
       * This is called initially, then upon each game restart
       * 
       * Most of the visual are setup already, so this is primarily the physics setup
       * 
       * @return void
       */
      private function _doRestartGame () : void
      {
         
         //   DELETE SIM MOVIECLIP IF EXISTING
         if (_sim_movieclip != null) {
            _sim_quickbox2D.destroy();
            _world_sprite.removeChild(_sim_movieclip);
         } 
         
         //   CREATE SIM MOVIECLIP
         _sim_movieclip  = new MovieClip ();
         _world_sprite.addChildAt (_sim_movieclip ,_world_sprite.getChildIndex(_finishLine));
         
         //   RESET FALLEN BLOCK COUNT
         _blocksFallenTotal_uint = 0;
         
         //   CREATE AN ARRAY TO HOLD ALL BLOCKS
         _blocks_array = new Array ();
         
         //   ----------------------------------------------------------
         //   CREATE THE PHYSICS WORLD (Partial list of parameters (default + description) is shown
         _sim_quickbox2D = new QuickBox2D (_sim_movieclip, 
            {
               
               //   Rendering
               debug          :    false,                 //false - Temporarily Render w/ Drawing API
               simpleRender   :    true,                  //true  - Toggles simple vs Custom Graphics
               renderJoints   :    true,                  //true, - Toggles rendering of joints
               
               //   Physics
               gravityX       :    0,                     //0    - The x component of gravity
               gravityY       :    20,                    //20   - The y component of gravity
               timeStep       :    PHYSICS_TIME_STEP,     //1/60 - The Box2D time step.
               iterations     :    40,                    //20   - Calculation cycles per TimeStep
               frim           :    false,                 //true - Toggles (Frame Rate 
                                                          //Independent Movement).
               
               //   Misc
               bounds         :    [-100, -100, 700, 700], //[-100, -100, 100, 100] - World Bounds
               customMouse    :    false                   //false - For MouseEvents in 3D Worlds
               
            });
         
         
         //   SET DEFAULTS FOR IMMOVABLE OBJECTS   (density = 0) 
         _sim_quickbox2D.setDefault   
            (
               {
                  linearDamping   :    1,    //Friction applied from the 'air'
                  density         :    0,    //More Dense = Moves Slower, 0 means immovable
                  friction        :    1     //Friction applied from colliding with other rigid bodies
               }
            );
         
         
         //   CREATE IMMOVABLE OBJECT - The pedestal at the bottom of the screen.
         _pedestal_quickobject = _sim_quickbox2D.addBox   
            (      
               {
                  x      : PHYSICS_SCALE    * (_border.width/2), //Remember to Convert Pixels to Meters
                  y      : PHYSICS_SCALE    * (525), 
                  width  : PHYSICS_SCALE    * 10, 
                  height : PHYSICS_SCALE    * 10, 
                  skin   : PedestalSkin            //Skin For Rigid Physics Body
               }
            );
         
         //   SET DEFAULTS FOR MOVABLE OBJECTS   (density != 0)
         _sim_quickbox2D.setDefault   
            (   
               {
                  linearDamping   :    1,  //Friction applied from the 'air'
                  density         :    1,  //More Dense = Moves Slower
                  friction        :    1   //Friction applied from colliding with other rigid bodies
               }
            );
         
         //   CREATE MOVABLE OBJECT - The platform at the bottom of the screen, above the pedestal
         _platform_quickobject = _sim_quickbox2D.addBox   
            (      
               {
                  x      : PHYSICS_SCALE    * (_border.width/2), //Remember to Convert Pixels to Meters
                  y      : PHYSICS_SCALE    * (520), 
                  width  : PHYSICS_SCALE    * 300, 
                  height : PHYSICS_SCALE    * 40, 
                  skin   : PlatformSkin                     //Skin For Rigid Physics Body
               }
            );
         
         //   MATCH THE VISUAL-ONLY (NON-PHYSICS) ARROW GRAPHICS TO THE PLATFORM
         //   I didn't want the block to bounce off the arrows
         _platformArrows.x = _platform_quickobject.userData.x;
         _platformArrows.y = _platform_quickobject.userData.y;
         
         
         //   CREATE A JOINT - The platform balances on top of the pedestal
         _sim_quickbox2D.addJoint
            (
               {
                  type: QuickBox2D.REVOLUTE, 
                  a:_platform_quickobject.body, 
                  b:_pedestal_quickobject.body, 
                  collideConnected:false,
                  lowerAngle:-Math.PI/6,
                  upperAngle:Math.PI/6,
                  enableLimit:true
               }
            );
         addEventListener(Event.ENTER_FRAME, _onEnterFrame);

         //   START THE PHYSICS
         _sim_quickbox2D.start();       //run an enterfame to power the engine
         _sim_quickbox2D.mouseDrag();   //allow mouse to move all objects (with density != 0)
         
         //   SHOW TEXT
         _doUpdateScoreText ();
         
         //   SETUP AUTO-BLOCK-CREATION
         if (!_blockCreation_timer) {
            _blockCreation_timer = new Timer (4000);
            _blockCreation_timer.addEventListener(TimerEvent.TIMER, _onBlockCreationTimer);
         }
            _blockCreation_timer.start();
         
         //   CREATE ONE BLOCK IMMEDIATLY
         _doCreateNewBlock();
         
      }
      
      /**
       * Create a new block off the top of the screen.  It will fall with gravity.
       * 
       * @return void
       */
      private function _doCreateNewBlock () : void
      {
         //   PLAY SOUND
         _blockCreationSound.play();
         
         //   CREATE MOVABLE OBJECT - A falling block at top, off screen
         _lastBlock_quickobject = _sim_quickbox2D.addBox   (      
            {
               
               x      : PHYSICS_SCALE    * (_border.width/2 - Math.random()*50 + Math.random()*50), 
               y      : PHYSICS_SCALE    * (0), 
               width  : PHYSICS_SCALE    * 50,   //Remember to convert pixels to meters with PHYSICS_SCALE
               height : PHYSICS_SCALE    * 50, 
               skin   : BlockSkin,               //Skin For rigid physics body
               
               draggable: false                  //User may only manipulate the platform, not the blocks
            }
         );
         
         //   KEEP A LIST OF BOXES
         _blocks_array.push (_lastBlock_quickobject);
         
         //   THE SKIN IS INSTANTIATED, AND ACCESSIBLE AS 'userData'
         //   YOU CAN ALSO STORE ARBITRARY PROPERTIES ON 'userData' for whatever you need
         (_lastBlock_quickobject.userData as BlockSkin).character_mc.head_mc.gotoAndStop (1); //show a 'happy' face
      }
      
      /**
       * Count each time a block falls offscreen.  This will cause a game loss eventually.
       * 
       * @return void
       */
      private function _doUpdateBlockFallenTotal () : void
      {
         //   COUNT UP
         _blocksFallenTotal_uint++;
         _doUpdateScoreText ();
         
         //   CHECK FOR GAME OVER
         if (_blocksFallenTotal_uint >= BLOCKS_FALLEN_TOTAL_ALLOWED) {
            _doEndGameAsLoser();
            
         }
      }
      
      /**
       * Remove blocks that fall offscreen and increment counter
       * 
       * @param aEvent QuickObject which has fallen offscreen
       * 
       * @return void
       */
      private function _doHandleBlockOffScreen (aQuickObject : QuickObject) : void
      {
         
         //   PLAY A SOUND
         _blockFallenSound.play();
         
         //   DESTROY OBJECT
         aQuickObject.destroy();
         
         //   REMOVE FROM CUSTOM ARRAY
         _blocks_array.splice (_blocks_array.indexOf(aQuickObject),1);
         
         //   CHANGE DISPLAY TEXT
         _doUpdateBlockFallenTotal ();
         
      }
      
      /**
       * Show the 'You Won!' text and stop the game physics from running.
       * 
       * @return void
       */
      private function _doEndGameAsWinner () : void
      {
         _scoreTextMC.textField.htmlText =    "Blocks Dropped Offscreen: " + 
            _blocksFallenTotal_uint + " of " + 
            BLOCKS_FALLEN_TOTAL_ALLOWED + 
            " Allow<BR><BR><BR><P ALIGN='CENTER'><FONT SIZE = '40'>YOU WON!</FONT></P><FONT SIZE = '10'><BR>Mouse-click anywhere above the " +
			"'Finish Line' " + "to restart the game</FONT>ed";
         
         _doStopGamePermanently ();
      }
      
      /**
       * Show the 'You Lost!' text and stop the game physics from running.
       * 
       * @return void
       */
      private function _doEndGameAsLoser () : void
      {
         _scoreTextMC.textField.htmlText =    "Blocks Dropped Offscreen: " + 
            _blocksFallenTotal_uint + " of " + 
            BLOCKS_FALLEN_TOTAL_ALLOWED + 
            " Allow<BR><BR><BR><P ALIGN='CENTER'><FONT SIZE = '40'>YOU LOST!</FONT></P><FONT SIZE = '10'><BR>Mouse-click anywhere above the " +
			"'Finish Line' " + "to restart the game</FONT>ed";
         
         _doStopGamePermanently();
      }

      /**
       * Show the # of blocks which have fallen.  Too many fallen means game over.
       * 
       * @return void
       */
      private function _doUpdateScoreText () : void
      {
         _scoreTextMC.textField.htmlText = "Blocks Dropped Offscreen: " + _blocksFallenTotal_uint + " of " + BLOCKS_FALLEN_TOTAL_ALLOWED + " Allowed";
      }
      
      /**
       * Stop the game physics from running and other repeated tasks
       * 
       * @return void
       */
      private function _doStopGamePermanently () : void
      {
         _sim_quickbox2D.destroy();
         removeEventListener (Event.ENTER_FRAME, _onEnterFrame);
         _sim_quickbox2D.stop();
            _blockCreation_timer.reset();
         _blockCreation_timer.stop();
      }
      
      
      //--------------------------------------
      //  Events
      //--------------------------------------   
      /**
       * Capture Event: Event.ENTER_FRAME, 30 times per second, this code executes my custom code
       * 
       * @param aEvent Event
       * 
       * @return void
       */
      private function _onEnterFrame (aEvent : Event) : void
      {
         
         //   MATCH THE VISUAL-ONLY (NON-PHYSICS) ARROWS TO THE PLATFORM
         _platformArrows.rotation = _platform_quickobject.userData.rotation;
         
         //   LOOP THROUGH BLOCKS FOR THREE UNIQUE CHECKS (A,B,C)
         for each (var quickObject : QuickObject in _blocks_array) {
            
            
            //   A) DID BOX FALL INTO PLAY - Necessary for 'victory' detection
            if (!quickObject.userData.isInPlay_boolean &&
               Math.abs(quickObject.body.m_linearVelocity.y) > .1 ) {
               quickObject.userData.isInPlay_boolean = true;
            }
            
            
            //   B) DID BOX FALL OFFSCREEN? - A bad thing for user
            if (quickObject.y / PHYSICS_SCALE > BLOCK_FALLEN_Y_LIMIT) {
               _doHandleBlockOffScreen(quickObject);
            }
            
            
            //   ----------------------------------------------------------
            //  CONDITIONS FOR VICTORY  - Is there a 'stack' of contiguously touching boxes 
            //                          - with at least one above the finish line?
            //                          - **The solution below is simple, but not perfect**
            //   ----------------------------------------------------------
            //   C) Is there at least one box that meets ALL of the following criterion
            //      1. Is above the Finish Line
            //      2. Is 'in play'
            //      3. Is moving very slowly (approximatly non-moving)
            //      4. Touching at least one other block (this doesn't prove its in a 'stack' but it helps)
            //
            //   ----------------------------------------------------------
            if (   (quickObject.y / PHYSICS_SCALE) < _finishLine.y       && 
                  quickObject.userData.isInPlay_boolean               &&
                  Math.abs(quickObject.body.m_linearVelocity.y) < 0.4         ) {
                  
               //IS IT COLLIDING WITH ANOTHER BLOCK (NOT ITSELF)
               for each (var quickObject2 : QuickObject in _blocks_array) {
                  if (quickObject != quickObject2) {
                     if ((quickObject.userData as MovieClip).hitTestObject (quickObject2.userData) ) {
                        _doEndGameAsWinner ();
                     }
                  }
                  
               }
            }
            
         }
         
         
      }
      
      /**
       * Capture Event: TimerEvent.TIMER, Every X seconds, create a new block
       * 
       * @param aEvent TimerEvent
       * 
       * @return void
       */
      private function _onBlockCreationTimer (aEvent : TimerEvent) : void
      {
         _doCreateNewBlock ();
      }
      
      
      /**
       * Capture Event: MouseEvent.CLICK, When user clicks on the screen, restart the game.
       * 
       * @param aEvent MouseEvent
       * 
       * @return void
       */
      private function _onMouseClickAnywhere (aEvent : MouseEvent) : void
      {
         if (aEvent.stageY < _finishLine.y) {
            _doRestartGame();
         }
         
      }
      
      
   }
}