home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / sinta.swf / scripts / Hero.as < prev    next >
Encoding:
Text File  |  2008-08-08  |  26.0 KB  |  924 lines
  1. package
  2. {
  3.    import flash.display.*;
  4.    import flash.events.*;
  5.    import flash.text.*;
  6.    import flash.utils.*;
  7.    
  8.    public class Hero extends Sprite
  9.    {
  10.       
  11.       internal static const startArrows:* = 50;
  12.       
  13.       internal static const startHealth:* = 100;
  14.        
  15.       
  16.       public var isHit:Boolean;
  17.       
  18.       public var maxArrows:* = 100;
  19.       
  20.       public var moveDown:Boolean;
  21.       
  22.       public var jump:Boolean;
  23.       
  24.       public var charwidth:Number;
  25.       
  26.       public var hitWallRight:Boolean;
  27.       
  28.       public var isSkidding:Boolean;
  29.       
  30.       public var moveUp:Boolean;
  31.       
  32.       public var isClimbing:Boolean;
  33.       
  34.       public var animstep:Number;
  35.       
  36.       public var starty:Number;
  37.       
  38.       public var isJumping:Boolean;
  39.       
  40.       public var startx:Number;
  41.       
  42.       public var gravity:*;
  43.       
  44.       public var immune:Boolean;
  45.       
  46.       public var walkSpeedMax:Number;
  47.       
  48.       public var timeDiff:int;
  49.       
  50.       public var dx:Number;
  51.       
  52.       public var dy:Number;
  53.       
  54.       public var isShooting:Boolean;
  55.       
  56.       public var numArrows:*;
  57.       
  58.       public var jumpSpeed:Number;
  59.       
  60.       public var curHealth:*;
  61.       
  62.       public var hasFlame:Boolean;
  63.       
  64.       public var moveRight:Boolean;
  65.       
  66.       public var alive:Boolean;
  67.       
  68.       public var isOpening:Boolean;
  69.       
  70.       public var angle:Number;
  71.       
  72.       public var isTouchingDoor:Boolean;
  73.       
  74.       public var maxHealth:*;
  75.       
  76.       public var damType:int;
  77.       
  78.       public var hasAmulet:Boolean;
  79.       
  80.       public var isRising:Boolean;
  81.       
  82.       public var animstate:String;
  83.       
  84.       public var hasPulledLever:Boolean;
  85.       
  86.       public var moveLeft:Boolean;
  87.       
  88.       public var direction:int;
  89.       
  90.       public var mc:MovieClip;
  91.       
  92.       public var hasRuby:Boolean;
  93.       
  94.       public var hitWallLeft:Boolean;
  95.       
  96.       public var onPlat:Boolean;
  97.       
  98.       public var walkAnimation:Array;
  99.       
  100.       public var moveCount:int;
  101.       
  102.       public var isPunched:Boolean;
  103.       
  104.       public var isCrouching:Boolean;
  105.       
  106.       public var inAir:Boolean;
  107.       
  108.       public var game:PlatformGame;
  109.       
  110.       public var charheight:Number;
  111.       
  112.       public var walkSpeed:Number;
  113.       
  114.       public function Hero(param1:PlatformGame)
  115.       {
  116.          maxArrows = 100;
  117.          super();
  118.          game = param1;
  119.          mc = game.gamelevel.hero;
  120.          mc.hero = this;
  121.          gravity = 0.0015;
  122.          timeDiff = 0;
  123.          walkAnimation = new Array(2,3,4,5,6,7,8,9);
  124.          damType = 0;
  125.          jumpSpeed = 0.4;
  126.          walkSpeed = 0.00147;
  127.          walkSpeedMax = 0.2;
  128.          charwidth = 20;
  129.          charheight = 41;
  130.          hasFlame = hasAmulet = hasRuby = hasPulledLever = false;
  131.          numArrows = startArrows;
  132.          startx = mc.x;
  133.          starty = mc.y;
  134.          mc.hero = this;
  135.          mc.stop();
  136.          init();
  137.       }
  138.       
  139.       public function getPunched() : *
  140.       {
  141.          if(!isPunched && alive)
  142.          {
  143.             checkDead();
  144.             isPunched = true;
  145.             dy = -10;
  146.          }
  147.       }
  148.       
  149.       public function getHasFlame() : *
  150.       {
  151.          return hasFlame;
  152.       }
  153.       
  154.       public function shoot() : *
  155.       {
  156.          --numArrows;
  157.          mc.rhand.gotoAndPlay(2);
  158.          setShooting(true);
  159.          if(hasFlame)
  160.          {
  161.             game.sounds.sintashootfire.play();
  162.          }
  163.          else
  164.          {
  165.             game.sounds.sintashootnormal.play();
  166.          }
  167.       }
  168.       
  169.       public function addHealth(param1:int) : *
  170.       {
  171.          curHealth += param1;
  172.          if(curHealth > maxHealth)
  173.          {
  174.             curHealth = maxHealth;
  175.          }
  176.       }
  177.       
  178.       public function die(param1:int) : *
  179.       {
  180.          var _loc2_:String = null;
  181.          if(alive)
  182.          {
  183.             isPunched = false;
  184.             --game.playerLives;
  185.             alive = false;
  186.             _loc2_ = "die" + param1;
  187.             mc.gotoAndPlay(_loc2_);
  188.             if(param1 == 1)
  189.             {
  190.                game.sounds.sintadienormal.play();
  191.             }
  192.             if(param1 == 3)
  193.             {
  194.                game.sounds.sintaburn.play();
  195.             }
  196.             if(param1 == 4)
  197.             {
  198.                game.sounds.sintaelectricute.play();
  199.             }
  200.          }
  201.       }
  202.       
  203.       public function doAim() : *
  204.       {
  205.          var _loc1_:* = undefined;
  206.          var _loc2_:* = undefined;
  207.          var _loc3_:* = undefined;
  208.          var _loc4_:* = undefined;
  209.          var _loc5_:Number = NaN;
  210.          var _loc6_:Number = NaN;
  211.          var _loc7_:Number = NaN;
  212.          var _loc8_:Number = NaN;
  213.          var _loc9_:Number = NaN;
  214.          if(inAir || isShooting || isOpening || isHit || !alive || mc.lhand == null)
  215.          {
  216.             return;
  217.          }
  218.          _loc1_ = mouseX;
  219.          _loc2_ = mouseY;
  220.          _loc3_ = mc.x + mc.lhand.x;
  221.          _loc4_ = mc.y + mc.lhand.y;
  222.          if(direction == 1)
  223.          {
  224.             if(_loc1_ < _loc3_)
  225.             {
  226.                direction = -1;
  227.             }
  228.          }
  229.          if(direction == -1)
  230.          {
  231.             if(_loc1_ > _loc3_)
  232.             {
  233.                direction = 1;
  234.             }
  235.          }
  236.          mc.scaleX = direction;
  237.          _loc5_ = Math.sqrt(game.GetDistSq(_loc1_,_loc2_,_loc3_,_loc4_));
  238.          _loc6_ = _loc4_ - _loc2_;
  239.          _loc7_ = _loc3_ - _loc1_;
  240.          angle = Math.acos(_loc6_ / _loc5_);
  241.          angle *= 180 / Math.PI;
  242.          if(angle > 170)
  243.          {
  244.             angle = 170;
  245.          }
  246.          if(angle < 10)
  247.          {
  248.             angle = 10;
  249.          }
  250.          if(_loc7_ > 0)
  251.          {
  252.          }
  253.          if(animstate == "stand")
  254.          {
  255.             if(mc.lhand != null)
  256.             {
  257.                mc.lhand.rotation = angle - 150;
  258.                mc.rhand.rotation = angle - 90;
  259.                if(hasFlame)
  260.                {
  261.                   mc.lhand.arrowinner.gotoAndStop(2);
  262.                }
  263.             }
  264.             _loc9_ = ((_loc8_ = angle - 106) + mc.head.rotation) / 4;
  265.             mc.head.rotation = _loc9_ - 8;
  266.          }
  267.       }
  268.       
  269.       public function takeDamage(param1:int, param2:int, param3:Number, param4:int) : *
  270.       {
  271.          var _loc5_:int = 0;
  272.          var _loc6_:Timer = null;
  273.          if(!alive || immune)
  274.          {
  275.             return;
  276.          }
  277.          isOpening = false;
  278.          damType = param2;
  279.          if((damType == 3 || damType == 4) && hasAmulet)
  280.          {
  281.             param1 *= 0.2;
  282.          }
  283.          if(param1 >= curHealth)
  284.          {
  285.             curHealth = 0;
  286.             die(param2);
  287.          }
  288.          else
  289.          {
  290.             game.sounds.sintahit.play();
  291.             mc.gotoAndPlay("hit");
  292.          }
  293.          isClimbing = false;
  294.          moveUp = moveDown = moveLeft = moveRight = false;
  295.          _loc5_ = 1;
  296.          if(param4 > mc.x)
  297.          {
  298.             _loc5_ = -1;
  299.          }
  300.          dx += param3 * _loc5_;
  301.          isHit = true;
  302.          immune = true;
  303.          (_loc6_ = new Timer(500,1)).start();
  304.          _loc6_.addEventListener(TimerEvent.TIMER_COMPLETE,endImmune);
  305.          if(curHealth > 0)
  306.          {
  307.             curHealth -= param1;
  308.             if(curHealth < 0)
  309.             {
  310.                curHealth = 0;
  311.             }
  312.          }
  313.       }
  314.       
  315.       public function setStartPos(param1:Number, param2:Number) : *
  316.       {
  317.          mc.x = startx = param1 + 20;
  318.          mc.y = starty = param2 + 40;
  319.          mc.visible = true;
  320.       }
  321.       
  322.       public function init() : *
  323.       {
  324.          mc.gotoAndStop(1);
  325.          immune = false;
  326.          moveCount = 0;
  327.          isShooting = false;
  328.          onPlat = false;
  329.          alive = true;
  330.          dx = 0;
  331.          dy = 0;
  332.          inAir = false;
  333.          direction = 1;
  334.          mc.scaleX = 1;
  335.          animstate = "stand";
  336.          isHit = false;
  337.          timeDiff = 0;
  338.          curHealth = maxHealth = startHealth;
  339.          damType = 0;
  340.          animstep = 0;
  341.          jump = false;
  342.          isJumping = false;
  343.          isSkidding = false;
  344.          isCrouching = false;
  345.          isRising = false;
  346.          isShooting = false;
  347.          isClimbing = false;
  348.          isOpening = false;
  349.          isTouchingDoor = false;
  350.          isPunched = false;
  351.          moveLeft = false;
  352.          moveRight = false;
  353.          moveDown = false;
  354.       }
  355.       
  356.       public function endPunch() : *
  357.       {
  358.          isPunched = false;
  359.          dy = 0;
  360.          if(alive)
  361.          {
  362.             game.loadLevel(4,0);
  363.          }
  364.          else
  365.          {
  366.             checkDead();
  367.          }
  368.       }
  369.       
  370.       public function continueGame() : *
  371.       {
  372.          numArrows = startArrows;
  373.          init();
  374.       }
  375.       
  376.       public function endImmune(param1:Event) : *
  377.       {
  378.          immune = false;
  379.          checkDead();
  380.       }
  381.       
  382.       public function updateStats() : *
  383.       {
  384.          game.healthbar.bar.width = 82 * (curHealth / maxHealth);
  385.          game.arrows_txt.text = String(numArrows);
  386.          game.lives_txt.text = String(game.playerLives);
  387.       }
  388.       
  389.       public function moveHero(param1:Number) : *
  390.       {
  391.          var _loc2_:* = undefined;
  392.          var _loc3_:Number = NaN;
  393.          var _loc4_:* = undefined;
  394.          var _loc5_:String = null;
  395.          var _loc6_:int = 0;
  396.          var _loc7_:Number = NaN;
  397.          var _loc8_:Number = NaN;
  398.          var _loc9_:int = 0;
  399.          var _loc10_:* = undefined;
  400.          var _loc11_:* = undefined;
  401.          var _loc12_:* = undefined;
  402.          var _loc13_:* = undefined;
  403.          var _loc14_:Boolean = false;
  404.          var _loc15_:int = 0;
  405.          var _loc16_:int = 0;
  406.          if(param1 < 1 || !game.isLoaded)
  407.          {
  408.             return;
  409.          }
  410.          if(numArrows == 0 && (mc.currentFrame == 105 || mc.currentFrame == 106))
  411.          {
  412.             mc.lhand.arrowinner.visible = false;
  413.          }
  414.          else if(!isShooting && (mc.currentFrame == 105 || mc.currentFrame == 106))
  415.          {
  416.             mc.lhand.arrowinner.visible = true;
  417.          }
  418.          if(isPunched)
  419.          {
  420.             mc.gotoAndPlay("hit");
  421.             if(mc.x < -50 || mc.x > 660 || mc.y > 500)
  422.             {
  423.                endPunch();
  424.             }
  425.             dy += 0.2;
  426.             mc.x += dx;
  427.             mc.y += dy;
  428.             checkDead();
  429.             return;
  430.          }
  431.          timeDiff = param1;
  432.          updateStats();
  433.          if(isOpening)
  434.          {
  435.             return;
  436.          }
  437.          _loc2_ = game.getTypeAt(game.getColFromX(mc.x),game.getRowFromY(mc.y - 50));
  438.          if(!game.pressDown && (moveDown || isCrouching))
  439.          {
  440.             if(_loc2_ < 5 && _loc2_ != 0)
  441.             {
  442.                moveDown = true;
  443.                isCrouching = true;
  444.                jump = false;
  445.             }
  446.             else
  447.             {
  448.                moveDown = false;
  449.                isCrouching = false;
  450.             }
  451.          }
  452.          _loc3_ = dy * timeDiff + timeDiff * gravity;
  453.          if(_loc3_ > 8 * (timeDiff / 17))
  454.          {
  455.             _loc3_ = 8 * (timeDiff / 17);
  456.          }
  457.          dy += timeDiff * gravity;
  458.          _loc4_ = 0;
  459.          _loc5_ = "stand";
  460.          _loc6_ = direction;
  461.          if(isHit)
  462.          {
  463.             moveLeft = moveRight = moveUp = moveDown = false;
  464.          }
  465.          if(isClimbing)
  466.          {
  467.             inAir = false;
  468.             _loc3_ -= timeDiff * gravity;
  469.             dy = 0;
  470.             _loc5_ = "climb";
  471.             if(moveUp)
  472.             {
  473.                dy = -0.085;
  474.                if(game.getTypeAt(game.getColFromX(mc.x),game.getRowFromY(mc.y - charheight / 2)) == 0 || game.getTypeAt(game.getColFromX(mc.x),game.getRowFromY(mc.y - charheight / 2)) > 22)
  475.                {
  476.                   isClimbing = false;
  477.                   _loc3_ -= 2;
  478.                }
  479.             }
  480.             if(moveDown)
  481.             {
  482.                dy = 0.085;
  483.             }
  484.          }
  485.          if(moveLeft || moveRight && !isHit)
  486.          {
  487.             ++moveCount;
  488.             isSkidding = false;
  489.             isClimbing = false;
  490.             _loc5_ = "walk";
  491.             if(moveLeft)
  492.             {
  493.                _loc6_ = -1;
  494.             }
  495.             if(moveRight)
  496.             {
  497.                _loc6_ = 1;
  498.             }
  499.             if(!inAir)
  500.             {
  501.                dx += _loc6_ * walkSpeed * timeDiff;
  502.             }
  503.             else
  504.             {
  505.                dx += _loc6_ * walkSpeed * 0.2 * timeDiff;
  506.             }
  507.          }
  508.          else
  509.          {
  510.             if(!inAir && Math.abs(dy) < 0.025)
  511.             {
  512.                dy = 0;
  513.             }
  514.             if(Math.abs(dx) > 0.1 && dy == 0 && moveCount > 10)
  515.             {
  516.             }
  517.             if(Math.abs(dx) < 0.05)
  518.             {
  519.                dx = 0;
  520.                moveCount = 0;
  521.             }
  522.          }
  523.          if(Math.abs(dx) > walkSpeedMax)
  524.          {
  525.             if(dx < 0)
  526.             {
  527.                dx = -walkSpeedMax;
  528.             }
  529.             else
  530.             {
  531.                dx = walkSpeedMax;
  532.             }
  533.          }
  534.          _loc4_ = dx * timeDiff;
  535.          if(!inAir)
  536.          {
  537.             dx *= 1 - 0.00882 * timeDiff;
  538.          }
  539.          else
  540.          {
  541.             isSkidding = false;
  542.          }
  543.          if(moveDown && !inAir && !isClimbing)
  544.          {
  545.             dx *= 0.5;
  546.             _loc5_ = "crouch";
  547.          }
  548.          if(jump && !isTouchingDoor)
  549.          {
  550.             jump = false;
  551.             if(!isClimbing)
  552.             {
  553.                dy = -jumpSpeed;
  554.                _loc3_ = -jumpSpeed;
  555.                _loc5_ = "jump";
  556.             }
  557.          }
  558.          hitWallRight = false;
  559.          hitWallLeft = false;
  560.          inAir = true;
  561.          _loc7_ = mc.y + _loc3_;
  562.          _loc8_ = mc.x + _loc4_;
  563.          _loc9_ = 0;
  564.          while(_loc9_ < game.fixedObjects.length)
  565.          {
  566.             if((_loc11_ = game.fixedObjects[_loc9_]).blocktype > 10 && _loc11_.blocktype < 19)
  567.             {
  568.                _loc12_ = _loc11_["block" + _loc11_.blocktype].inner;
  569.                if(mc.x + charwidth / 2 > _loc11_.leftside + _loc12_.x && mc.x - charwidth / 2 < _loc11_.rightside + _loc12_.x)
  570.                {
  571.                   if(mc.y <= _loc11_.topside + _loc12_.y + 5 && _loc7_ > _loc11_.topside + _loc12_.y)
  572.                   {
  573.                      _loc7_ = _loc11_.topside + _loc12_.y;
  574.                      if(_loc12_.x == undefined)
  575.                      {
  576.                      }
  577.                      _loc13_ = _loc12_.x - _loc11_.prevX;
  578.                      if(Math.abs(_loc13_) > 10)
  579.                      {
  580.                         _loc13_ = 0;
  581.                      }
  582.                      _loc8_ += _loc13_;
  583.                      _loc7_ += _loc12_.y - _loc11_.prevY;
  584.                      inAir = false;
  585.                   }
  586.                }
  587.                _loc11_.prevX = _loc12_.x;
  588.                _loc11_.prevY = _loc12_.y;
  589.             }
  590.             if(_loc11_.blocktype < 11 || (_loc11_.blocktype > 61 && _loc11_.blocktype < 66 || _loc11_.blocktype == 52 || _loc11_.blocktype == 54) && !_loc11_.open)
  591.             {
  592.                if(mc.x + charwidth / 2 > _loc11_.leftside && mc.x - charwidth / 2 < _loc11_.rightside)
  593.                {
  594.                   if(mc.y - charheight > _loc11_.bottomside && _loc7_ - charheight <= _loc11_.bottomside)
  595.                   {
  596.                      _loc7_ = _loc11_.bottomside + charheight;
  597.                      dy = 0;
  598.                      break;
  599.                   }
  600.                   if(mc.y <= _loc11_.topside && _loc7_ > _loc11_.topside)
  601.                   {
  602.                      _loc7_ = Number(_loc11_.topside);
  603.                      if(dy > 0.05 && (mc.currentLabel == "jumping" || mc.currentLabel == "fall"))
  604.                      {
  605.                         _loc5_ = "skid";
  606.                      }
  607.                      dy = 0;
  608.                      if((_loc11_.blocktype == 6 || _loc11_.blocktype == 7 || _loc11_.blocktype == 8 || _loc11_.blocktype == 9 || _loc11_.blocktype == 10) && moveDown)
  609.                      {
  610.                         _loc7_ = _loc11_.topside + 10;
  611.                         inAir = false;
  612.                         if(moveDown)
  613.                         {
  614.                            _loc10_ = true;
  615.                            isClimbing = true;
  616.                            _loc5_ = "climb";
  617.                            _loc8_ = _loc11_.leftside + charwidth - 2;
  618.                         }
  619.                      }
  620.                      else
  621.                      {
  622.                         isClimbing = false;
  623.                         dy = 0;
  624.                         inAir = false;
  625.                      }
  626.                      break;
  627.                   }
  628.                }
  629.             }
  630.             else if(mc.hitbit.hitTestObject(_loc11_))
  631.             {
  632.                if(_loc11_.blocktype == 51 && !isHit)
  633.                {
  634.                   if(mc.hitbit.hitTestObject(_loc11_.block51.spikebit))
  635.                   {
  636.                      takeDamage(1000,1,0,_loc11_.x + _loc11_.width / 2);
  637.                   }
  638.                   else
  639.                   {
  640.                      takeDamage(30,1,0.35,_loc11_.x + _loc11_.width / 2);
  641.                   }
  642.                }
  643.                if(_loc11_.blocktype == 53 && !isHit)
  644.                {
  645.                   if(mc.hitbit.hitTestObject(_loc11_.block53))
  646.                   {
  647.                      takeDamage(250,3,0,_loc11_.x + _loc11_.width / 2);
  648.                   }
  649.                }
  650.             }
  651.             _loc9_++;
  652.          }
  653.          if(_loc7_ > 440)
  654.          {
  655.             _loc7_ = 440;
  656.             if(dy > 0.05 && (mc.currentLabel == "jumping" || mc.currentLabel == "fall"))
  657.             {
  658.                _loc5_ = "skid";
  659.             }
  660.             dy = 0;
  661.             inAir = false;
  662.          }
  663.          _loc10_ = false;
  664.          isTouchingDoor = false;
  665.          _loc9_ = 0;
  666.          while(_loc9_ < game.fixedObjects.length)
  667.          {
  668.             if((_loc11_ = game.fixedObjects[_loc9_]).blocktype < 6 || (_loc11_.blocktype > 61 && _loc11_.blocktype < 66 || _loc11_.blocktype == 52 || _loc11_.blocktype == 54) && !_loc11_.open)
  669.             {
  670.                if(_loc7_ > _loc11_.topside && _loc7_ - charheight < _loc11_.bottomside)
  671.                {
  672.                   if(mc.x - charwidth / 2 >= _loc11_.rightside && _loc8_ - charwidth / 2 <= _loc11_.rightside)
  673.                   {
  674.                      _loc8_ = _loc11_.rightside + charwidth / 2;
  675.                      hitWallLeft = true;
  676.                      dx = 0;
  677.                      break;
  678.                   }
  679.                   if(mc.x + charwidth / 2 <= _loc11_.leftside && _loc8_ + charwidth / 2 >= _loc11_.leftside)
  680.                   {
  681.                      _loc8_ = _loc11_.leftside - charwidth / 2;
  682.                      hitWallRight = true;
  683.                      dx = 0;
  684.                      break;
  685.                   }
  686.                }
  687.             }
  688.             else if(_loc11_.isHitting(mc.hitbit))
  689.             {
  690.                if(_loc11_.blocktype == 19 || _loc11_.blocktype == 20 || _loc11_.blocktype == 6 || _loc11_.blocktype == 7 || _loc11_.blocktype == 8 || _loc11_.blocktype == 9 || _loc11_.blocktype == 10)
  691.                {
  692.                   _loc10_ = true;
  693.                   inAir = false;
  694.                   _loc14_ = false;
  695.                   _loc15_ = game.getColFromX(mc.x);
  696.                   _loc16_ = game.getRowFromY(mc.y);
  697.                   if(game.getTypeAt(_loc15_,_loc16_ + 1) < 6)
  698.                   {
  699.                      _loc14_ = true;
  700.                   }
  701.                   if(moveUp || moveDown && !_loc14_)
  702.                   {
  703.                      isClimbing = true;
  704.                      _loc5_ = "climb";
  705.                      _loc8_ = _loc11_.leftside + charwidth - 2;
  706.                   }
  707.                }
  708.                if(_loc11_.blocktype > 40 && _loc11_.blocktype < 51)
  709.                {
  710.                   if(_loc11_.blocktype == 41)
  711.                   {
  712.                      game.gotStars[game.curLevel][_loc11_.id] = 1;
  713.                   }
  714.                   if(_loc11_.blocktype == 42)
  715.                   {
  716.                      game.gotLives[game.curLevel][_loc11_.id] = 1;
  717.                   }
  718.                   game.getPowerup(_loc11_);
  719.                }
  720.                if(_loc11_.blocktype > 50 && _loc11_.blocktype < 56)
  721.                {
  722.                   game.hitTrap(_loc11_);
  723.                }
  724.                if(_loc11_.blocktype > 32 && _loc11_.blocktype < 41)
  725.                {
  726.                   if(mc.x > _loc11_.leftside + 8 && mc.x < _loc11_.rightside - 8)
  727.                   {
  728.                      isTouchingDoor = true;
  729.                      jump = false;
  730.                      if(moveUp && !isOpening && !inAir)
  731.                      {
  732.                         if(_loc11_.blocktype == 36)
  733.                         {
  734.                            if(!hasRuby)
  735.                            {
  736.                               break;
  737.                            }
  738.                            if(!game.placedRuby)
  739.                            {
  740.                               game.placedRuby = true;
  741.                            }
  742.                            _loc8_ = _loc11_.leftside + 34;
  743.                         }
  744.                         else
  745.                         {
  746.                            _loc8_ = _loc11_.leftside + 20;
  747.                         }
  748.                         _loc11_["block" + _loc11_.blocktype].play();
  749.                         mc.gotoAndPlay("open");
  750.                         _loc5_ = "open";
  751.                         isOpening = true;
  752.                         if(_loc11_.blocktype == 38 && game.curLevel == 17)
  753.                         {
  754.                            hasPulledLever = true;
  755.                         }
  756.                         break;
  757.                      }
  758.                   }
  759.                }
  760.             }
  761.             _loc9_++;
  762.          }
  763.          if(!_loc10_)
  764.          {
  765.             isClimbing = false;
  766.          }
  767.          if(_loc8_ > 630)
  768.          {
  769.             _loc8_ = 630;
  770.             hitWallRight = true;
  771.             dx = 0;
  772.          }
  773.          if(_loc8_ < 10)
  774.          {
  775.             _loc8_ = 10;
  776.             hitWallLeft = true;
  777.             dx = 0;
  778.          }
  779.          mc.x = _loc8_;
  780.          mc.y = _loc7_;
  781.          if(inAir)
  782.          {
  783.             _loc5_ = "jump";
  784.          }
  785.          else
  786.          {
  787.             isJumping = false;
  788.          }
  789.          animstate = _loc5_;
  790.          if(isHit)
  791.          {
  792.             animstate = "hit";
  793.          }
  794.          if(animstate == "walk" || animstate == "crouch" || animstate == "climb" && (moveLeft || moveRight || moveUp || moveDown) && !isHit)
  795.          {
  796.             animstep += timeDiff / 60;
  797.             if(animstep > walkAnimation.length)
  798.             {
  799.                animstep = 0;
  800.             }
  801.             if(isClimbing && (moveUp || moveDown))
  802.             {
  803.                mc.gotoAndStop(walkAnimation[Math.floor(animstep)] + 25);
  804.             }
  805.             else if(moveDown && !isClimbing)
  806.             {
  807.                if(moveLeft || moveRight)
  808.                {
  809.                   mc.gotoAndStop(walkAnimation[Math.floor(animstep)] + 12);
  810.                }
  811.             }
  812.             else
  813.             {
  814.                mc.gotoAndStop(walkAnimation[Math.floor(animstep)]);
  815.             }
  816.          }
  817.          else if(animstate == "jump" && !isJumping && !isClimbing && !isHit)
  818.          {
  819.             isJumping = true;
  820.             mc.gotoAndPlay("jump");
  821.          }
  822.          if(animstate == "skid" && !isSkidding && !isHit)
  823.          {
  824.             isSkidding = true;
  825.             game.sounds.sintaland.play();
  826.             mc.gotoAndPlay(animstate);
  827.          }
  828.          if(animstate == "stand" && !isSkidding && !isHit)
  829.          {
  830.             if(mc.currentLabel != "stand")
  831.             {
  832.                mc.gotoAndPlay("stand");
  833.             }
  834.          }
  835.          if(moveDown && !isCrouching && !inAir && !isHit)
  836.          {
  837.             isCrouching = true;
  838.             charheight = 30;
  839.             mc.gotoAndPlay(animstate);
  840.          }
  841.          if(!isCrouching)
  842.          {
  843.             charheight = 41;
  844.          }
  845.          if(!moveDown && animstate == "crouch" && !isRising && !isHit)
  846.          {
  847.             isRising = true;
  848.             animstate = "rise";
  849.             mc.gotoAndPlay(animstate);
  850.          }
  851.          if(_loc6_ != direction)
  852.          {
  853.             direction = _loc6_;
  854.             mc.scaleX = direction;
  855.          }
  856.       }
  857.       
  858.       public function resetLevel(param1:Event) : *
  859.       {
  860.          if(game.playerLives <= 0)
  861.          {
  862.             game.gameOver();
  863.          }
  864.          else
  865.          {
  866.             init();
  867.             game.resetLevel();
  868.          }
  869.       }
  870.       
  871.       public function addArrows(param1:int) : *
  872.       {
  873.          numArrows += param1;
  874.          if(numArrows > maxArrows)
  875.          {
  876.             numArrows = maxArrows;
  877.          }
  878.       }
  879.       
  880.       public function endDie() : *
  881.       {
  882.          var _loc1_:Timer = null;
  883.          _loc1_ = new Timer(1500,1);
  884.          _loc1_.start();
  885.          _loc1_.addEventListener(TimerEvent.TIMER_COMPLETE,resetLevel);
  886.       }
  887.       
  888.       public function checkDead() : *
  889.       {
  890.          if(curHealth <= 0)
  891.          {
  892.             isPunched = false;
  893.             die(damType);
  894.          }
  895.          else
  896.          {
  897.             isHit = false;
  898.             if(game.pressDown)
  899.             {
  900.                moveDown = true;
  901.             }
  902.             if(game.pressUp)
  903.             {
  904.                moveUp = true;
  905.             }
  906.             if(game.pressLeft)
  907.             {
  908.                moveLeft = true;
  909.             }
  910.             if(game.pressRight)
  911.             {
  912.                moveRight = true;
  913.             }
  914.          }
  915.       }
  916.       
  917.       public function setShooting(param1:Boolean) : *
  918.       {
  919.          isShooting = param1;
  920.          mc.lhand.arrowinner.visible = param1;
  921.       }
  922.    }
  923. }
  924.