home *** CD-ROM | disk | FTP | other *** search
/ Ice Age Fan CD 1 / CD1_Scrat.iso / flash / data / game.swf / scripts / asCode / playerManager.as < prev    next >
Encoding:
Text File  |  2012-07-04  |  11.4 KB  |  360 lines
  1. package asCode
  2. {
  3.    import flash.display.BitmapData;
  4.    import flash.display.MovieClip;
  5.    import flash.geom.Point;
  6.    
  7.    internal class playerManager
  8.    {
  9.       private static var BUBBLE_TYPE_PLAYER:int = 0;
  10.       
  11.       private static var BUBBLE_TYPE_ACORN:int = 5;
  12.       
  13.       private static var BUBBLE_TYPE_HEALTH_POWERUP:int = 10;
  14.       
  15.       private static var BUBBLE_TYPE_INVINCIBLE:int = 15;
  16.       
  17.       private static var BUBBLE_TYPE_SHRINK:int = 20;
  18.       
  19.       private static var BUBBLE_TYPE_REVERSE:int = 25;
  20.       
  21.       private static var PARTICLE_EFFECT_ENEMY_DEATH:int = 0;
  22.       
  23.       private static var PARTICLE_HIT_OBJECT:int = 1;
  24.       
  25.       private static var PARTICLE_COLLECT_ITEM:int = 2;
  26.       
  27.       private static var PARTICLE_EFFECT_CHIP_PLACED:int = 3;
  28.       
  29.       private static var PARTICLE_EFFECT_ELECTRICAL_CHARGE:int = 4;
  30.       
  31.       private static var PARTICLE_EFFECT_METEOR:int = 5;
  32.       
  33.       private static var PARTICLE_EFFECT_FLICKER:int = 6;
  34.       
  35.       private var bubbleRenderPoint:Point;
  36.       
  37.       private var playerScale:Number;
  38.       
  39.       private var movingDown:Boolean;
  40.       
  41.       private var flipPlayer:Boolean;
  42.       
  43.       private var powerUpActive:int;
  44.       
  45.       private var hitPointRadius:Number = 50;
  46.       
  47.       private var testPointAmount:Number = 12;
  48.       
  49.       private var testPointStepping:Number;
  50.       
  51.       private var pixelColour:Number;
  52.       
  53.       private var _testPixelNum:Number;
  54.       
  55.       private var hitCollisionBitmapData:BitmapData;
  56.       
  57.       private var screenBitmapData:BitmapData;
  58.       
  59.       public var spacePressed:Boolean;
  60.       
  61.       public var movingRight:Boolean;
  62.       
  63.       private var movingLeft:Boolean;
  64.       
  65.       private var spacePressCountdown:int;
  66.       
  67.       private var rightPressCountdown:int;
  68.       
  69.       private var spacePressCoolDown:int;
  70.       
  71.       private var rightPressCoolDown:int;
  72.       
  73.       private var leftPressCountdown:int;
  74.       
  75.       private var totalDistanceTraveled:Number;
  76.       
  77.       private var leftPressCoolDown:int;
  78.       
  79.       private var playerInvincibleAfterHurtCounter:int;
  80.       
  81.       private var playerXVelocity:Number;
  82.       
  83.       private var playerYVelocity:Number;
  84.       
  85.       private var scrollYDist:Number;
  86.       
  87.       private var repelX:Number;
  88.       
  89.       private var repelY:Number;
  90.       
  91.       private var radian:Number;
  92.       
  93.       private var screenWidth:Number;
  94.       
  95.       private var screenHeight:Number;
  96.       
  97.       private var _bubbleCodeClass:playerBubbleCodeClass;
  98.       
  99.       private var playerAlpha:Number;
  100.       
  101.       private var bubble:MovieClip;
  102.       
  103.       private var playerScreenLoc:Point;
  104.       
  105.       private var _gameClipClassRef:gameClipClass;
  106.       
  107.       public function playerManager(param1:gameClipClass)
  108.       {
  109.          bubbleRenderPoint = new Point();
  110.          testPointStepping = 360 / testPointAmount;
  111.          super();
  112.          _gameClipClassRef = param1;
  113.          _bubbleCodeClass = _gameClipClassRef._playerBubbleCodeClass;
  114.          bubble = _gameClipClassRef.bubble;
  115.          screenWidth = _gameClipClassRef.screenWidth;
  116.          screenHeight = _gameClipClassRef.screenHeight;
  117.          hitCollisionBitmapData = _gameClipClassRef.hitCollisionBitmapData;
  118.          screenBitmapData = _gameClipClassRef.screenBitmapData;
  119.       }
  120.       
  121.       public function managePlayer(param1:Boolean = false) : void
  122.       {
  123.          var _loc2_:int = 0;
  124.          var _loc3_:Number = NaN;
  125.          var _loc4_:Number = NaN;
  126.          movingDown = _gameClipClassRef.movingDown;
  127.          movingRight = _gameClipClassRef.movingRight;
  128.          movingLeft = _gameClipClassRef.movingLeft;
  129.          spacePressed = _gameClipClassRef.spacePressed;
  130.          spacePressCountdown = _gameClipClassRef.spacePressCountdown;
  131.          spacePressCoolDown = _gameClipClassRef.spacePressCoolDown;
  132.          playerScale = _gameClipClassRef.playerScale;
  133.          flipPlayer = _gameClipClassRef.flipPlayer;
  134.          totalDistanceTraveled = _gameClipClassRef.totalDistanceTraveled;
  135.          playerScreenLoc = _gameClipClassRef.playerScreenLoc;
  136.          rightPressCountdown = _gameClipClassRef.rightPressCountdown;
  137.          rightPressCoolDown = _gameClipClassRef.rightPressCoolDown;
  138.          leftPressCountdown = _gameClipClassRef.leftPressCountdown;
  139.          leftPressCoolDown = _gameClipClassRef.leftPressCoolDown;
  140.          playerInvincibleAfterHurtCounter = _gameClipClassRef.playerInvincibleAfterHurtCounter;
  141.          playerXVelocity = _gameClipClassRef.playerXVelocity;
  142.          playerYVelocity = _gameClipClassRef.playerYVelocity;
  143.          scrollYDist = _gameClipClassRef.scrollYDist;
  144.          playerAlpha = _gameClipClassRef.playerAlpha;
  145.          powerUpActive = _gameClipClassRef.powerUpActive;
  146.          if(movingRight)
  147.          {
  148.             if(rightPressCountdown > 0)
  149.             {
  150.                --rightPressCountdown;
  151.             }
  152.             else
  153.             {
  154.                movingRight = false;
  155.                rightPressCoolDown = 10;
  156.             }
  157.          }
  158.          if(spacePressed)
  159.          {
  160.             if(spacePressCountdown > 0)
  161.             {
  162.                --spacePressCountdown;
  163.             }
  164.             else
  165.             {
  166.                spacePressed = false;
  167.                spacePressCoolDown = 10;
  168.             }
  169.          }
  170.          if(spacePressCoolDown > 0)
  171.          {
  172.             --spacePressCoolDown;
  173.          }
  174.          if(rightPressCoolDown > 0)
  175.          {
  176.             --rightPressCoolDown;
  177.          }
  178.          if(movingLeft)
  179.          {
  180.             if(leftPressCountdown > 0)
  181.             {
  182.                --leftPressCountdown;
  183.             }
  184.             else
  185.             {
  186.                movingLeft = false;
  187.                leftPressCoolDown = 10;
  188.             }
  189.          }
  190.          if(leftPressCoolDown > 0)
  191.          {
  192.             --leftPressCoolDown;
  193.          }
  194.          if(playerInvincibleAfterHurtCounter > 0)
  195.          {
  196.             --playerInvincibleAfterHurtCounter;
  197.          }
  198.          if(playerInvincibleAfterHurtCounter < 1)
  199.          {
  200.             playerAlpha = 1;
  201.          }
  202.          if(!param1)
  203.          {
  204.             if(movingDown)
  205.             {
  206.                --scrollYDist;
  207.             }
  208.             if(scrollYDist > -3)
  209.             {
  210.                scrollYDist -= 0.25;
  211.             }
  212.             if(scrollYDist < -10)
  213.             {
  214.                scrollYDist = -10;
  215.             }
  216.             if(movingRight)
  217.             {
  218.                if(flipPlayer)
  219.                {
  220.                   playerXVelocity -= 1.3;
  221.                }
  222.                else
  223.                {
  224.                   playerXVelocity += 1.3;
  225.                }
  226.             }
  227.             if(movingLeft)
  228.             {
  229.                if(flipPlayer)
  230.                {
  231.                   playerXVelocity += 1.3;
  232.                }
  233.                else
  234.                {
  235.                   playerXVelocity -= 1.3;
  236.                }
  237.             }
  238.             if(spacePressed)
  239.             {
  240.                scrollYDist += 2.7;
  241.             }
  242.             if(scrollYDist > 13)
  243.             {
  244.                scrollYDist = 13;
  245.             }
  246.             if(Math.abs(playerXVelocity) > 0)
  247.             {
  248.                playerScreenLoc.x += playerXVelocity;
  249.             }
  250.             if(Math.abs(playerYVelocity) > 0)
  251.             {
  252.                playerScreenLoc.y += playerYVelocity;
  253.             }
  254.          }
  255.          bubble.x = playerScreenLoc.x;
  256.          bubble.y = playerScreenLoc.y;
  257.          bubbleRenderPoint.x = playerScreenLoc.x;
  258.          bubbleRenderPoint.y = playerScreenLoc.y + scrollYDist;
  259.          _bubbleCodeClass.drawBubble(bubbleRenderPoint);
  260.          if(Math.abs(playerYVelocity) > 0.15)
  261.          {
  262.             playerYVelocity *= 0.9;
  263.          }
  264.          if(Math.abs(playerXVelocity) > 0.15)
  265.          {
  266.             playerXVelocity *= 0.96;
  267.          }
  268.          if(Math.abs(playerXVelocity) < 0.15)
  269.          {
  270.             playerXVelocity = 0;
  271.          }
  272.          if(Math.abs(playerYVelocity) < 0.15)
  273.          {
  274.             playerYVelocity = 0;
  275.          }
  276.          if(playerScreenLoc.x < 30)
  277.          {
  278.             playerScreenLoc.x = 30;
  279.             if(playerXVelocity < 0)
  280.             {
  281.                playerXVelocity = 0;
  282.             }
  283.          }
  284.          if(playerScreenLoc.x > screenWidth - 30 * playerScale)
  285.          {
  286.             playerScreenLoc.x = screenWidth - 30 * playerScale;
  287.             if(playerXVelocity > 0)
  288.             {
  289.                playerXVelocity = 0;
  290.             }
  291.          }
  292.          if(playerScreenLoc.y < 30 * playerScale)
  293.          {
  294.             playerScreenLoc.y = 30 * playerScale;
  295.             if(playerYVelocity < 0)
  296.             {
  297.                playerXVelocity = 0;
  298.             }
  299.          }
  300.          if(playerScreenLoc.y > screenHeight + 30 * playerScale)
  301.          {
  302.             playerScreenLoc.y = screenHeight + 30 * playerScale;
  303.             if(playerYVelocity > 0)
  304.             {
  305.                playerYVelocity = 0;
  306.             }
  307.          }
  308.          if(totalDistanceTraveled < 0)
  309.          {
  310.             if(scrollYDist < 0)
  311.             {
  312.                scrollYDist = 0;
  313.             }
  314.          }
  315.          if(totalDistanceTraveled < _gameClipClassRef.levelTotalHeight - 320 && totalDistanceTraveled > 120)
  316.          {
  317.             hitCollisionBitmapData.fillRect(hitCollisionBitmapData.rect,16777215);
  318.             _loc2_ = 0;
  319.             while(_loc2_ < testPointAmount)
  320.             {
  321.                radian = _loc2_ * testPointStepping / 180 * Math.PI;
  322.                _loc3_ = playerScreenLoc.x + Math.cos(radian) * hitPointRadius * playerScale;
  323.                _loc4_ = playerScreenLoc.y + Math.sin(radian) * hitPointRadius * playerScale;
  324.                _testPixelNum = screenBitmapData.getPixel32(_loc3_,_loc4_);
  325.                if(_testPixelNum > 0)
  326.                {
  327.                   repelX = Math.cos(radian) * 3;
  328.                   repelY = Math.sin(radian) * 3;
  329.                   playerXVelocity -= repelX;
  330.                   scrollYDist += repelY;
  331.                   if(powerUpActive != BUBBLE_TYPE_INVINCIBLE)
  332.                   {
  333.                      _gameClipClassRef.playerHitsWall(1);
  334.                      _gameClipClassRef.particleEffect(PARTICLE_HIT_OBJECT,_loc3_,_loc4_);
  335.                   }
  336.                }
  337.                _loc2_++;
  338.             }
  339.          }
  340.          _gameClipClassRef.movingRight = movingRight;
  341.          _gameClipClassRef.movingLeft = movingLeft;
  342.          _gameClipClassRef.totalDistanceTraveled = totalDistanceTraveled;
  343.          _gameClipClassRef.playerScreenLoc = playerScreenLoc;
  344.          _gameClipClassRef.rightPressCountdown = rightPressCountdown;
  345.          _gameClipClassRef.rightPressCoolDown = rightPressCoolDown;
  346.          _gameClipClassRef.leftPressCountdown = leftPressCountdown;
  347.          _gameClipClassRef.leftPressCoolDown = leftPressCoolDown;
  348.          _gameClipClassRef.playerInvincibleAfterHurtCounter = playerInvincibleAfterHurtCounter;
  349.          _gameClipClassRef.playerXVelocity = playerXVelocity;
  350.          _gameClipClassRef.playerYVelocity = playerYVelocity;
  351.          _gameClipClassRef.scrollYDist = scrollYDist;
  352.          _gameClipClassRef.playerAlpha = playerAlpha;
  353.          _gameClipClassRef.spacePressed = spacePressed;
  354.          _gameClipClassRef.spacePressCountdown = spacePressCountdown;
  355.          _gameClipClassRef.spacePressCoolDown = spacePressCoolDown;
  356.       }
  357.    }
  358. }
  359.  
  360.