home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / sleepless-knight.swf / scripts / DefineSprite_348 / frame_1 / DoAction.as
Encoding:
Text File  |  2008-09-11  |  40.6 KB  |  1,365 lines
  1. function pythag(x1, y1, x2, y2)
  2. {
  3.    return Math.sqrt(Math.pow(y1 - y2,2) + Math.pow(x1 - x2,2));
  4. }
  5. function angle(x1, y1, x2, y2)
  6. {
  7.    return Math.round(Math.atan2(y2 - y1,x2 - x1) / 3.141593 * 180) + 90;
  8. }
  9. function calcSpeed(angle, speed)
  10. {
  11.    var _loc2_ = angle * 0.01745329;
  12.    var _loc1_ = new Object();
  13.    _loc1_.x = speed * Math.cos(_loc2_);
  14.    _loc1_.y = speed * Math.sin(_loc2_);
  15.    return _loc1_;
  16. }
  17. function rotatedXY(xPos, yPos, rotate)
  18. {
  19.    var _loc1_ = new Object();
  20.    var _loc2_ = 0.017444444444444446 * rotate;
  21.    var _loc4_ = Math.sin(_loc2_);
  22.    var _loc3_ = Math.cos(_loc2_);
  23.    _loc1_.x = xPos * _loc3_ - yPos * _loc4_;
  24.    _loc1_.y = xPos * _loc4_ + yPos * _loc3_;
  25.    return _loc1_;
  26. }
  27. function shakeControl()
  28. {
  29. }
  30. function newNoise(xPos, yPos, size)
  31. {
  32.    var _loc1_ = 0;
  33.    while(_loc1_ < enemyArray.length)
  34.    {
  35.       if(pythag(enemyArray[_loc1_]._x,enemyArray[_loc1_]._y,xPos,yPos) < size * 8)
  36.       {
  37.          if(enemyArray[_loc1_].S_State == 0)
  38.          {
  39.             enemyArray[_loc1_].S_State = 1;
  40.          }
  41.       }
  42.       _loc1_ = _loc1_ + 1;
  43.    }
  44.    var _loc2_ = NOISE.attachMovie("noise","N",NOISE.getNextHighestDepth());
  45.    _loc2_._x = xPos;
  46.    _loc2_._y = yPos;
  47.    _loc2_._xscale = size + random(10) - 5;
  48.    _loc2_._yscale = _loc2_._xscale;
  49.    noiseArray.push(_loc2_);
  50. }
  51. function noiseManagement()
  52. {
  53.    var _loc1_ = 0;
  54.    while(_loc1_ < noiseArray.length)
  55.    {
  56.       if(noiseArray[_loc1_]._alpha > 10)
  57.       {
  58.          noiseArray[_loc1_]._alpha -= 10;
  59.          noiseArray[_loc1_]._xscale *= 1.2;
  60.          noiseArray[_loc1_]._yscale = noiseArray[_loc1_]._xscale;
  61.       }
  62.       else
  63.       {
  64.          noiseArray[_loc1_].removeMovieClip();
  65.          noiseArray.splice(_loc1_,1);
  66.          _loc1_ = _loc1_ - 1;
  67.       }
  68.       _loc1_ = _loc1_ + 1;
  69.    }
  70. }
  71. function onEnterFrame()
  72. {
  73.    if(Key.isDown(80) && gamePauseSwitch == false)
  74.    {
  75.       gamePauseSwitch = true;
  76.       if(gamePaused == false)
  77.       {
  78.          gamePaused = true;
  79.          _parent.HUD.gotoAndStop(2);
  80.       }
  81.       else
  82.       {
  83.          _parent.HUD.gotoAndStop(1);
  84.          gamePaused = false;
  85.       }
  86.    }
  87.    else if(Key.isDown(80) == false)
  88.    {
  89.       gamePauseSwitch = false;
  90.    }
  91.    if(gamePaused == false)
  92.    {
  93.       if(EOLFreeze == false)
  94.       {
  95.          _root.saveObject.timer = _root.saveObject.timer + 1;
  96.          _root.timer = Math.round(_root.saveObject.timer / 30);
  97.          updateCoins();
  98.          updateBlood();
  99.          updateEnemy();
  100.          noiseManagement();
  101.          camPos.x = MAN._x;
  102.          camPos.y = MAN._y;
  103.          MAN.ySpeed /= 1.05;
  104.          if(MAN.dead == true)
  105.          {
  106.             if(MAN.deadTimer < 150)
  107.             {
  108.                MAN.deadTimer = MAN.deadTimer + 1;
  109.             }
  110.             else if(MAN.deadTimer == 150)
  111.             {
  112.                MAN.deadTimer = MAN.deadTimer + 1;
  113.                _root.saveObject.coins = coinStore;
  114.                _root.deaths = _root.deaths + 1;
  115.                _root.saveObject.deaths = _root.deaths;
  116.                _root.saveObject.kill = killStore;
  117.                _root.saveData();
  118.                _root.gotoFrame("blank",2);
  119.             }
  120.             _parent.focusBG._alpha /= 2;
  121.             if(targScale < 100)
  122.             {
  123.                targScale++;
  124.             }
  125.             newBlood(MAN._x,MAN._y);
  126.             MAN.gotoAndStop("RAGDOLL");
  127.             MAN._y += MAN.ySpeed;
  128.             MAN.ySpeed += 2;
  129.             while(collision(MAN._x,MAN._y,GROUND))
  130.             {
  131.                MAN._y--;
  132.                MAN.ySpeed = 0;
  133.             }
  134.             MAN.sprite._rotation /= 1.05;
  135.             MAN.xSpeed = 0;
  136.          }
  137.          else
  138.          {
  139.             MAN_Control();
  140.             manCollision();
  141.             objectJump(MAN);
  142.             MAN_BowControl();
  143.          }
  144.          updateArrows();
  145.          if(MAN.jumpBuffer >= jumpBufferStore && MAN.climbActive == false)
  146.          {
  147.             unlockSprite(MAN,"SWING");
  148.             setSprite(MAN,"JUMP");
  149.             MAN.spriteLock = "JUMP";
  150.          }
  151.          if(Math.round(_xscale) != targScale)
  152.          {
  153.             camElastic = 1;
  154.          }
  155.          else
  156.          {
  157.             camElastic = 5;
  158.          }
  159.          if(camPos.y > 600)
  160.          {
  161.             camPos.y = 600;
  162.          }
  163.          point = {x:camPos.x,y:camPos.y};
  164.          localToGlobal(point);
  165.          if(MAN.climbActive == true && MAN.keyPressUp == true)
  166.          {
  167.             if(camYOffset < 250)
  168.             {
  169.                camYOffset += 10;
  170.             }
  171.          }
  172.          else if(MAN.climbActive == true && MAN.keyPressDown == true)
  173.          {
  174.             if(camYOffset > 115)
  175.             {
  176.                camYOffset -= 10;
  177.             }
  178.          }
  179.          else if(camYOffset < 184)
  180.          {
  181.             camYOffset += 5;
  182.          }
  183.          else if(camYOffset > 192)
  184.          {
  185.             camYOffset -= 5;
  186.          }
  187.          var _loc3_ = Math.floor((256 - point.x) / camElastic);
  188.          var _loc4_ = Math.floor((camYOffset - point.y) / camElastic);
  189.          _X = _X + _loc3_;
  190.          _Y = _Y + _loc4_;
  191.          _parent.BG._x += _loc3_ / 6 - 0.5;
  192.          if(_parent.BG._x < 0)
  193.          {
  194.             _parent.BG._x += _parent.BG._width / 2;
  195.          }
  196.          else if(_parent.BG._x > 512)
  197.          {
  198.             _parent.BG._x -= _parent.BG._width / 2;
  199.          }
  200.          _parent.BG_1._x += _loc3_ / 2;
  201.          _parent.BG_1._y += _loc4_ / 6;
  202.          if(_parent.BG_1._x < - _parent.BG_1._width / 3)
  203.          {
  204.             _parent.BG_1._x += _parent.BG_1._width / 3;
  205.          }
  206.          else if(_parent.BG_1._x > _parent.BG_1._width / 3)
  207.          {
  208.             _parent.BG_1._x -= _parent.BG_1._width / 3;
  209.          }
  210.          _xscale = _xscale - (_xscale - (targScale + zoomShake)) / 10;
  211.          _yscale = _yscale - (_yscale - (targScale + zoomShake)) / 10;
  212.          if(MAN.ySpeed < 0 && MAN.swingActive == false)
  213.          {
  214.             MAN.jumpBuffer = jumpBufferStore;
  215.          }
  216.          GROUND_G.swapDepths(getNextHighestDepth());
  217.          spikeDamage();
  218.          HUDControl();
  219.       }
  220.       setFPS();
  221.    }
  222. }
  223. function MAN_BowControl()
  224. {
  225.    if(MAN.bowActive == true)
  226.    {
  227.       if(_parent.focusBG._alpha < 100)
  228.       {
  229.          _parent.focusBG._alpha += 20;
  230.       }
  231.    }
  232.    else if(_parent.focusBG._alpha > 0)
  233.    {
  234.       _parent.focusBG._alpha -= 10;
  235.    }
  236.    if(MAN.spriteLock == "BOW")
  237.    {
  238.       targScale = 40;
  239.       MAN.bowActive = true;
  240.    }
  241.    else if(Key.isDown(16) == false && MAN.duckActive == false && MAN.climbActive == false && MAN.swingActive == false)
  242.    {
  243.       targScale = 100;
  244.    }
  245.    if(MAN.mousePressed == true)
  246.    {
  247.       shakeControl();
  248.       MAN.spriteLock = "BOW";
  249.       EFFECTS.clear();
  250.       EFFECTS.lineStyle(2,0,100);
  251.       EFFECTS.moveTo(xDragStart,yDragStart);
  252.       EFFECTS.lineTo(_xmouse,_ymouse);
  253.       MAN.powerVar = Math.round(pythag(_xmouse,_ymouse,xDragStart,yDragStart) / 2);
  254.       MAN.anglerVar = angle(_xmouse,_ymouse,xDragStart,yDragStart);
  255.       if(MAN.powerVar > bow_Range_Array[bow_Range])
  256.       {
  257.          MAN.powerVar = bow_Range_Array[bow_Range];
  258.       }
  259.       if(MAN.anglerVar < 0)
  260.       {
  261.          MAN.anglerVar += 360;
  262.       }
  263.       speed = calcSpeed(MAN.anglerVar - 90,MAN.powerVar * 2);
  264.       arrowPreview(MAN.anglerVar,MAN.powerVar);
  265.       Bow_DataText._visible = true;
  266.       Bow_DataText._x = xDragStart;
  267.       Bow_DataText._y = yDragStart;
  268.       Bow_DataText.textBox.text = "Angle: " + MAN.anglerVar + "\nPower: " + MAN.powerVar + " / " + bow_Range_Array[bow_Range] + " [Level " + bow_Range + "]";
  269.    }
  270.    else
  271.    {
  272.       Bow_DataText._visible = false;
  273.    }
  274. }
  275. function onMouseDown()
  276. {
  277.    if(MAN.climbActive == false && MAN.swingActive == false && gamePaused == false)
  278.    {
  279.       if(MAN.mousePressed == false)
  280.       {
  281.          _root.playSound("CRANK",50);
  282.       }
  283.       MAN.moveActive = false;
  284.       MAN.mousePressed = true;
  285.       xDragStart = _xmouse;
  286.       yDragStart = _ymouse;
  287.    }
  288. }
  289. function onMouseUp()
  290. {
  291.    if(MAN.mousePressed == true)
  292.    {
  293.       EFFECTS.clear();
  294.       MAN.mousePressed = false;
  295.       if(MAN.powerVar > 10)
  296.       {
  297.          newNoise(MAN._x,MAN._y - 40,15);
  298.          _root.playSound("SHOOTSOUND",50);
  299.          newArrow(arrowPosX,arrowPosY,MAN);
  300.          arrowArray[arrowArray.length - 1].killSoldier = true;
  301.       }
  302.       if(bow_Accuracy < 10)
  303.       {
  304.          bow_Accuracy++;
  305.       }
  306.    }
  307. }
  308. function createArrow(xPos, yPos, caller)
  309. {
  310.    var _loc1_ = attachMovie("Arrow",clone,getNextHighestDepth());
  311.    _loc1_._rotation = caller.anglerVar;
  312.    _loc1_.xSpeed = speed.x / 10;
  313.    _loc1_.ySpeed = speed.y / 10;
  314.    _loc1_.timer = 0;
  315.    _loc1_._x = xPos + _loc1_.xSpeed;
  316.    _loc1_._y = yPos + _loc1_.ySpeed;
  317.    _loc1_.xPos = _loc1_._x;
  318.    _loc1_.yPos = _loc1_._y;
  319.    _loc1_.alive = true;
  320.    return _loc1_;
  321. }
  322. function newArrow(xPos, yPos, caller)
  323. {
  324.    arrowArray.push(createArrow(xPos,yPos,caller));
  325. }
  326. function arrowPreview(anglerVar, powerVar)
  327. {
  328.    newNoise(MAN._x,MAN._y - 40,10);
  329.    preview = createArrow(arrowPosX,arrowPosY);
  330.    preview.noiseActive = false;
  331.    preview._x -= preview.xSpeed;
  332.    preview._y -= preview.ySpeed;
  333.    preview.timer = bow_Accuracy_Array[bow_Accuracy];
  334.    EFFECTS.moveTo(preview.xPos,preview.yPos);
  335.    var _loc1_ = -5;
  336.    while(preview.timer > 0)
  337.    {
  338.       EFFECTS.lineStyle(0.1,16711680,_loc1_);
  339.       _loc1_ += 5;
  340.       preview.timer--;
  341.       updateTrajectory(preview);
  342.       EFFECTS.lineTo(preview._x,preview._y);
  343.    }
  344.    preview.removeMovieClip();
  345. }
  346. function updateArrows()
  347. {
  348.    var _loc4_ = 0;
  349.    while(_loc4_ < arrowArray.length)
  350.    {
  351.       var _loc3_ = arrowArray[_loc4_];
  352.       updateTrajectory(_loc3_);
  353.       if(_loc3_.alive == true)
  354.       {
  355.          if(_loc3_.killSoldier != true)
  356.          {
  357.             if(pythag(_loc3_._x,_loc3_._y,MAN._x,MAN._y - 40) < 40)
  358.             {
  359.                if(MAN.dead != true)
  360.                {
  361.                   hurtMan(10);
  362.                   MAN.ySpeed = -10;
  363.                }
  364.             }
  365.          }
  366.          if(_loc3_.killSoldier == true)
  367.          {
  368.             var _loc2_ = 0;
  369.             while(_loc2_ < enemyArray.length)
  370.             {
  371.                if(enemyArray[_loc2_].dead != true && pythag(_loc3_._x,_loc3_._y,enemyArray[_loc2_]._x,enemyArray[_loc2_]._y - 40) < 30)
  372.                {
  373.                   _root.playSound("guardDieSound",50);
  374.                   _loc3_.alive = false;
  375.                   _loc3_._visible = false;
  376.                   enemyArray[_loc2_].dead = true;
  377.                   enemyArray[_loc2_].ySpeed = -10;
  378.                   newBlood(enemyArray[_loc2_]._x,enemyArray[_loc2_]._y - 40);
  379.                }
  380.                _loc2_ = _loc2_ + 1;
  381.             }
  382.          }
  383.       }
  384.       if(_loc3_.timer < 300)
  385.       {
  386.          _loc3_.timer = _loc3_.timer + 1;
  387.       }
  388.       else if(_loc3_._yscale > 0)
  389.       {
  390.          _loc3_._yscale -= 10;
  391.       }
  392.       else
  393.       {
  394.          _loc3_.removeMovieClip();
  395.          arrowArray.splice(_loc4_,1);
  396.       }
  397.       _loc4_ = _loc4_ + 1;
  398.    }
  399. }
  400. function updateTrajectory(object)
  401. {
  402.    if(object.alive == true)
  403.    {
  404.       object.xPos = object._x;
  405.       object.yPos = object._y;
  406.       object._x += object.xSpeed;
  407.       object._y += object.ySpeed;
  408.       object.xSpeed += windSpeed;
  409.       object.ySpeed += 1;
  410.       object._rotation = angle(object.xPos,object.yPos,object._x,object._y);
  411.       if(collision(object._x,object._y,GROUND))
  412.       {
  413.          object._x += object.xSpeed / 10;
  414.          object._y += object.ySpeed / 10;
  415.          object.alive = false;
  416.          if(object.noiseActive != false)
  417.          {
  418.             newNoise(object._x,object._y,50);
  419.          }
  420.       }
  421.    }
  422. }
  423. function MAN_Control()
  424. {
  425.    MAN.sneakActive = false;
  426.    if(MAN.dead == false)
  427.    {
  428.       if(Key.isDown(38))
  429.       {
  430.          MAN.keyPressUp = true;
  431.       }
  432.       else
  433.       {
  434.          MAN.keyPressUp = false;
  435.          MAN.keyPressUpSwitch = false;
  436.       }
  437.       if(Key.isDown(40))
  438.       {
  439.          MAN.keyPressDown = true;
  440.       }
  441.       else
  442.       {
  443.          MAN.keyPressDown = false;
  444.          MAN.keyPressDownSwitch = false;
  445.          MAN.duckActive = false;
  446.          MAN.rollCount = 10;
  447.       }
  448.       if(Key.isDown(37))
  449.       {
  450.          MAN.keyPressLeft = true;
  451.       }
  452.       else
  453.       {
  454.          MAN.keyPressLeft = false;
  455.          MAN.keyPressLeftSwitch = false;
  456.       }
  457.       if(Key.isDown(39))
  458.       {
  459.          MAN.keyPressRight = true;
  460.       }
  461.       else
  462.       {
  463.          MAN.keyPressRight = false;
  464.          MAN.keyPressRightSwitch = false;
  465.       }
  466.    }
  467.    else
  468.    {
  469.       MAN.keyPressUp = false;
  470.       MAN.keyPressRight = false;
  471.       MAN.keyPressDown = false;
  472.       MAN.keyPressLeft = false;
  473.    }
  474.    if(MAN.mousePressed == false)
  475.    {
  476.       MAN.moveActive = false;
  477.       if(MAN.keyPressRight == true)
  478.       {
  479.          MAN.moveActive = true;
  480.          MAN.bowActive = false;
  481.          MAN.xSpeed += 8;
  482.          unlockSprite(MAN,"BOW");
  483.          if(MAN.keyPressDown == true && MAN.swingActive == false && MAN.climbActive == false && MAN.jumpBuffer < 5)
  484.          {
  485.             if(MAN.rollCount == 0)
  486.             {
  487.                setSprite(MAN,"SNEAK");
  488.                MAN.xSpeed -= 4;
  489.                MAN.sneakActive = true;
  490.             }
  491.             else
  492.             {
  493.                MAN.rollCount--;
  494.                setSprite(MAN,"ROLL");
  495.             }
  496.          }
  497.          else
  498.          {
  499.             setSprite(MAN,"RUN");
  500.             MAN.rollCount = 10;
  501.          }
  502.          MAN._xscale = manXScale;
  503.       }
  504.       else if(MAN.keyPressLeft == true)
  505.       {
  506.          MAN.moveActive = true;
  507.          MAN.bowActive = false;
  508.          MAN.xSpeed -= 8;
  509.          unlockSprite(MAN,"BOW");
  510.          if(MAN.keyPressDown == true && MAN.swingActive == false && MAN.climbActive == false && MAN.jumpBuffer < 5)
  511.          {
  512.             if(MAN.rollCount == 0)
  513.             {
  514.                setSprite(MAN,"SNEAK");
  515.                MAN.xSpeed += 4;
  516.                MAN.sneakActive = true;
  517.             }
  518.             else
  519.             {
  520.                MAN.rollCount--;
  521.                setSprite(MAN,"ROLL");
  522.             }
  523.          }
  524.          else
  525.          {
  526.             setSprite(MAN,"RUN");
  527.             MAN.rollCount = 10;
  528.          }
  529.          MAN._xscale = - manXScale;
  530.       }
  531.       else if(MAN.keyPressDown == true)
  532.       {
  533.          MAN.sneakActive = true;
  534.          setSprite(MAN,"DUCK");
  535.          if(MAN.climbActive == false && MAN.swingActive == false && MAN.jumpBuffer < 5)
  536.          {
  537.             MAN.duckActive = true;
  538.             targScale = 100;
  539.          }
  540.       }
  541.       else
  542.       {
  543.          setSprite(MAN,"STAND");
  544.       }
  545.       MAN.sprite.bowAim.bow.gotoAndStop(10);
  546.       MAN.sprite.bowAim.arms.gotoAndStop(10);
  547.    }
  548.    else
  549.    {
  550.       MAN.gotoAndStop("SHOOT");
  551.       if(MAN.powerVar > 10)
  552.       {
  553.          if(MAN.anglerVar < 180)
  554.          {
  555.             MAN.sprite.bowAim._rotation = MAN.anglerVar - 90;
  556.             MAN.sprite.bowAim.arms._rotation = MAN.anglerVar - 90 - MAN.sprite.bowAim._rotation / 3;
  557.             MAN._xscale = manXScale;
  558.          }
  559.          else
  560.          {
  561.             MAN.sprite.bowAim._rotation = - (MAN.anglerVar + 90);
  562.             MAN.sprite.bowAim.arms._rotation = - (MAN.anglerVar + 90) - MAN.sprite.bowAim._rotation / 3;
  563.             MAN._xscale = - manXScale;
  564.          }
  565.       }
  566.       var _loc1_ = Math.ceil(bow_Range_Array[bow_Range] / 100 * MAN.powerVar / 30);
  567.       MAN.sprite.bowAim.bow.gotoAndStop(_loc1_);
  568.       MAN.sprite.bowAim.arms.gotoAndStop(_loc1_);
  569.       MAN.sprite.bowAim.bow._rotation = MAN.sprite.bowAim.arms._rotation;
  570.       MAN.sprite.bowAim._rotation /= 3;
  571.       var _loc2_ = {x:MAN.sprite.bowAim.arms.arrowPoint._x,y:MAN.sprite.bowAim.arms.arrowPoint._y};
  572.       MAN.sprite.bowAim.arms.localToGlobal(_loc2_);
  573.       arrowPosX = MAN._x;
  574.       arrowPosY = MAN._y - 40;
  575.       arrowTrack._x = arrowPosX;
  576.       arrowTrack._y = arrowPosY;
  577.    }
  578.    MAN.xSpeed /= 2;
  579.    if(MAN.swingActive == true)
  580.    {
  581.       MAN.xSpeed /= 2;
  582.    }
  583.    if(MAN.xSpeed < 0.1 && MAN.xSpeed > -0.1)
  584.    {
  585.       MAN.xSpeed = 0;
  586.    }
  587.    MAN._x += MAN.xSpeed;
  588. }
  589. function manCollision()
  590. {
  591.    var _loc2_ = MAN.ySpeed;
  592.    MAN._y += MAN.ySpeed;
  593.    if(MAN.keyPressDown == true || MAN.swingActive == false && MAN.climbActive == false)
  594.    {
  595.       MAN.ySpeed += 2;
  596.    }
  597.    if(MAN.keyPressDown == false)
  598.    {
  599.       MAN.swingKeySwitch = false;
  600.    }
  601.    if(groundCollision(MAN) == true && (MAN.moveActive == true || _loc2_ > 10) && MAN.climbActive == false)
  602.    {
  603.       if(MAN.sneakActive == false)
  604.       {
  605.          newNoise(MAN._x,MAN._y,50);
  606.       }
  607.       else
  608.       {
  609.          newNoise(MAN._x,MAN._y,10);
  610.       }
  611.    }
  612.    if(roofCollision(MAN) != true)
  613.    {
  614.       if(MAN.swingActive == true)
  615.       {
  616.          MAN.swingActive = false;
  617.          if(MAN.keyPressDown == false || MAN.swingKeySwitch == true)
  618.          {
  619.             MAN.ySpeed = (- MAN.jumpHeight) * 1.2;
  620.          }
  621.          else
  622.          {
  623.             MAN.jumpBuffer = jumpBufferStore;
  624.             MAN.ySpeed = 0;
  625.          }
  626.          if(MAN.keyPressDown == false)
  627.          {
  628.             MAN.xSpeed = MAN._xscale / 5;
  629.          }
  630.       }
  631.    }
  632.    if(wallCollision(MAN,1) != true && wallCollision(MAN,-1) != true)
  633.    {
  634.       if(unlockSprite(MAN,"CLIMB") == true && collision(MAN._x,MAN._y,GROUND) != true)
  635.       {
  636.          if(MAN.keyPressDown == false)
  637.          {
  638.             MAN.xSpeed = (- MAN._xscale) / 10;
  639.             MAN.ySpeed = (- MAN.jumpHeight) / 1;
  640.             _root.playSound("JUMP",50);
  641.             newNoise(MAN._x,MAN._y - 80,50);
  642.          }
  643.          else
  644.          {
  645.             MAN.xSpeed = MAN._xscale / 2;
  646.             MAN.ySpeed = 0;
  647.             MAN.swingKeySwitch = true;
  648.          }
  649.       }
  650.    }
  651. }
  652. function wallCollision(object, dir)
  653. {
  654.    var _loc3_ = false;
  655.    if(dir > 0)
  656.    {
  657.       if(object._xscale > dir)
  658.       {
  659.          _loc3_ = true;
  660.       }
  661.    }
  662.    else if(object._xscale < dir)
  663.    {
  664.       _loc3_ = true;
  665.    }
  666.    if(collision(object._x + wallCSize * dir,object._y - 75,GROUND) && _loc3_ == true)
  667.    {
  668.       object.climbActive = true;
  669.       object.doubleJump = false;
  670.       object.ySpeed = 0;
  671.       while(collision(object._x + wallCSize * dir,object._y - 75,GROUND))
  672.       {
  673.          object._x -= 1 * dir;
  674.       }
  675.       object._x += 2 * dir;
  676.       if(object.keyPressUp == true)
  677.       {
  678.          unlockSprite(MAN,"JUMP");
  679.          setSprite(object,"CLIMB");
  680.          object.spriteLock = "CLIMB";
  681.          object.gotoAndStop("CLIMB");
  682.          object.ySpeed = -5;
  683.          newNoise(object._x,object._y - 40,25);
  684.       }
  685.       else if(object.keyPressDown == false)
  686.       {
  687.          unlockSprite(object,"JUMP");
  688.          setSprite(object,"SLIDE");
  689.          object.spriteLock = "CLIMB";
  690.          object.gotoAndStop("GRIP");
  691.          object.ySpeed = 0;
  692.       }
  693.       else
  694.       {
  695.          unlockSprite(object,"JUMP");
  696.          setSprite(object,"SLIDE");
  697.          object.spriteLock = "CLIMB";
  698.          object.gotoAndStop("SLIDE");
  699.          object.ySpeed = 10;
  700.          newNoise(object._x,object._y - 40,25);
  701.       }
  702.       return true;
  703.    }
  704.    object.climbActive = false;
  705.    if(collision(object._x + wallCSize * dir,object._y - 30,GROUND) && _loc3_ == true)
  706.    {
  707.       while(collision(object._x + wallCSize * dir,object._y - 30,GROUND))
  708.       {
  709.          object._x -= 1 * dir;
  710.       }
  711.    }
  712. }
  713. function roofCollision(object)
  714. {
  715.    if(collision(object._x,object._y - wallRSize,GROUND))
  716.    {
  717.       MAN.jumpKeySwitch = true;
  718.       object.doubleJump = false;
  719.       object.jumpBuffer = 0;
  720.       object.swingActive = true;
  721.       while(collision(object._x,object._y - wallRSize,GROUND))
  722.       {
  723.          object._y = object._y + 1;
  724.       }
  725.       if(object.keyPressDown == false)
  726.       {
  727.          object._y -= 2;
  728.          object.ySpeed = -2;
  729.       }
  730.       if(object.climbActive == false)
  731.       {
  732.          object.setSprite(MAN,"SWING");
  733.          object.spriteLock = "SWING";
  734.          if(object.keyPressRight == true || object.keyPressLeft == true)
  735.          {
  736.             object.gotoAndStop("SWING");
  737.             newNoise(object._x,object._y - 80,20);
  738.          }
  739.          else
  740.          {
  741.             object.gotoAndStop("SWINGSTOP");
  742.          }
  743.       }
  744.       return true;
  745.    }
  746. }
  747. function setSprite(object, frame)
  748. {
  749.    if(object.dead != true)
  750.    {
  751.       if(object.spriteLock == false)
  752.       {
  753.          object.gotoAndStop(frame);
  754.       }
  755.    }
  756.    else
  757.    {
  758.       object.gotoAndStop("RAGDOLL");
  759.    }
  760. }
  761. function unlockSprite(object, lock)
  762. {
  763.    if(object.spriteLock == lock)
  764.    {
  765.       object.spriteLock = false;
  766.       return true;
  767.    }
  768. }
  769. function groundCollision(object)
  770. {
  771.    object.jumpBuffer = object.jumpBuffer + 1;
  772.    if(collision(object._x,object._y,GROUND) == true)
  773.    {
  774.       while(collision(object._x,object._y,GROUND) == true)
  775.       {
  776.          object._y -= 1;
  777.       }
  778.       object._y += 2;
  779.       object.ySpeed = 0;
  780.       object.jumpBuffer = 0;
  781.       if(object.keyPressUp == false)
  782.       {
  783.          object.doubleJump = true;
  784.       }
  785.       unlockSprite(object,"JUMP");
  786.       return true;
  787.    }
  788. }
  789. function collision(xPos, yPos, Targ)
  790. {
  791.    if(Targ.hitTest(xPos / (100 / _xscale) + _X,yPos / (100 / _yscale) + _Y,true))
  792.    {
  793.       return true;
  794.    }
  795. }
  796. function objectJump(object)
  797. {
  798.    if(object.keyPressUp == true && object.climbActive == false && object.swingActive == false)
  799.    {
  800.       jump(object);
  801.    }
  802.    else if(object.jumpBuffer < jumpBufferStore)
  803.    {
  804.       object.jumpSwitch = false;
  805.    }
  806.    if(object.keyPressUp == false)
  807.    {
  808.       object.jumpKeySwitch = false;
  809.    }
  810. }
  811. function jump(object)
  812. {
  813.    if(object.swingActive == false && object.bowActive == false)
  814.    {
  815.       if(object.jumpBuffer < jumpBufferStore && object.jumpSwitch == false || object.climbActive == true)
  816.       {
  817.          object.ySpeed = - object.jumpHeight;
  818.          _root.playSound("JUMP",50);
  819.          object.jumpSwitch = true;
  820.          object.jumpKeySwitch = true;
  821.          if(object.ySpeed < - object.jumpHeight)
  822.          {
  823.             object.ySpeed = object.jumpHeight;
  824.          }
  825.       }
  826.       else if(object.doubleJump == true && object.ySpeed > 1 && object.jumpKeySwitch == false && object.jumpBuffer > 10)
  827.       {
  828.          object.jumpSwitch = true;
  829.          _root.playSound("JUMP",50);
  830.          object.ySpeed = - object.jumpHeight;
  831.          object.doubleJump = false;
  832.       }
  833.    }
  834. }
  835. function addSoldier(xPos, yPos)
  836. {
  837.    var _loc1_ = attachMovie("SK","SK_Sol",getNextHighestDepth());
  838.    _loc1_._x = xPos;
  839.    _loc1_._y = yPos;
  840.    _loc1_.visualStyle = 2;
  841.    _loc1_.bowActive = false;
  842.    _loc1_.xSpeed = 0;
  843.    _loc1_.ySpeed = 0;
  844.    _loc1_.spriteLock = 0;
  845.    _loc1_.swingActive = false;
  846.    _loc1_.S_State = 0;
  847.    _loc1_.moveDir = 1;
  848.    _loc1_.VA._yscale = 30;
  849.    _loc1_.VA._xscale = 60;
  850.    _loc1_.shockTime = 0;
  851.    _loc1_.deadTimer = 0;
  852.    _loc1_.arrowTimer = 10;
  853.    _loc1_.anglerAdjust = random(10);
  854.    _loc1_.suspectTime = 0;
  855.    _loc1_.power = random(10) / 10;
  856.    _loc1_.scaler = _loc1_._xscale;
  857.    _loc1_.spotPosX = 0;
  858.    _loc1_.spotPosY = 0;
  859.    _loc1_.jumpBuffer = 0;
  860.    if(random(2) == 1)
  861.    {
  862.       _loc1_._xscale = - _loc1_.scaler;
  863.       _loc1_.moveDir = -1;
  864.    }
  865.    enemyArray.push(_loc1_);
  866. }
  867. function updateEnemy()
  868. {
  869.    var _loc2_ = 0;
  870.    while(_loc2_ < enemyArray.length)
  871.    {
  872.       if(enemyArray[_loc2_]._visible == true)
  873.       {
  874.          if(enemyArray[_loc2_].dead == true)
  875.          {
  876.             newBlood(enemyArray[_loc2_]._x,enemyArray[_loc2_]._y);
  877.             enemyArray[_loc2_].gotoAndStop("RAGDOLL");
  878.             enemyArray[_loc2_]._y += enemyArray[_loc2_].ySpeed;
  879.             enemyArray[_loc2_].ySpeed += 2;
  880.             if(enemyArray[_loc2_].deadTimer < 200)
  881.             {
  882.                if(enemyArray[_loc2_].deadTimer == 1)
  883.                {
  884.                   _root.kills = _root.kills + 1;
  885.                   trace(_root.kills);
  886.                }
  887.                enemyArray[_loc2_].deadTimer = enemyArray[_loc2_].deadTimer + 1;
  888.             }
  889.             else if(enemyArray[_loc2_]._alpha > 0)
  890.             {
  891.                enemyArray[_loc2_]._alpha -= 5;
  892.             }
  893.             else if(enemyArray[_loc2_]._visible == true)
  894.             {
  895.                enemyArray[_loc2_]._visible = false;
  896.             }
  897.             while(collision(enemyArray[_loc2_]._x,enemyArray[_loc2_]._y,GROUND))
  898.             {
  899.                enemyArray[_loc2_]._y--;
  900.                enemyArray[_loc2_].ySpeed = 0;
  901.             }
  902.             enemyArray[_loc2_].sprite._rotation /= 1.05;
  903.             enemyArray[_loc2_].xSpeed = 0;
  904.          }
  905.          else
  906.          {
  907.             if(MAN.dead == true)
  908.             {
  909.                enemyArray[_loc2_].S_State = 0;
  910.                unlockSprite(enemyArray[_loc2_],"SHOOT");
  911.                setSprite(enemyArray[_loc2_],"SNEAK");
  912.                enemyArray.spriteLock = "SNEAK";
  913.             }
  914.             var _loc3_ = pythag(enemyArray[_loc2_]._x,enemyArray[_loc2_]._y,MAN._x,MAN._y);
  915.             if(_loc3_ > 100 && _loc3_ < 350 && enemyArray[_loc2_].S_State > 1 && MAN._y < enemyArray[_loc2_]._y + 40)
  916.             {
  917.                enemyArray[_loc2_].S_State = 3;
  918.             }
  919.             else if(enemyArray[_loc2_].S_State == 3)
  920.             {
  921.                unlockSprite(enemyArray[_loc2_],"SHOOT");
  922.                enemyArray[_loc2_].S_State = 2;
  923.             }
  924.             if(_loc3_ < 150 || _loc3_ < 250 && enemyArray[_loc2_].S_State > 0 && MAN._y < enemyArray[_loc2_]._y + 20)
  925.             {
  926.                enemyArray[_loc2_].curDist = _loc3_;
  927.                if(MAN._x < enemyArray[_loc2_]._x && enemyArray[_loc2_].moveDir == -1 || MAN._x > enemyArray[_loc2_]._x && enemyArray[_loc2_].moveDir == 1)
  928.                {
  929.                   if(enemyArray[_loc2_].S_State != 3)
  930.                   {
  931.                      enemyArray[_loc2_].S_State = 2;
  932.                      enemyArray[_loc2_].spotPosX = MAN._x;
  933.                      enemyArray[_loc2_].spotPosY = enemyArray[_loc2_]._x - MAN._x;
  934.                      if(enemyArray[_loc2_].S_State == 2)
  935.                      {
  936.                         enemyArray[_loc2_].shockTime = 0;
  937.                      }
  938.                   }
  939.                }
  940.             }
  941.             else
  942.             {
  943.                enemyArray[_loc2_].spotPosX = enemyArray[_loc2_]._x - enemyArray[_loc2_].spotPosY;
  944.             }
  945.             enemyArray[_loc2_]._y += enemyArray[_loc2_].ySpeed;
  946.             enemyArray[_loc2_].ySpeed += 2;
  947.             enemyArray[_loc2_].jumpBuffer = enemyArray[_loc2_].jumpBuffer + 1;
  948.             if(groundCollision(enemyArray[_loc2_]) == true)
  949.             {
  950.                if(collision(enemyArray[_loc2_]._x - 25,enemyArray[_loc2_]._y + 30,GROUND) != true)
  951.                {
  952.                   if(enemyArray[_loc2_].S_State < 1)
  953.                   {
  954.                      enemyArray[_loc2_]._x += 5;
  955.                      enemyArray[_loc2_].xSpeed *= -1.1;
  956.                      enemyArray[_loc2_].moveDir *= -1;
  957.                      enemyArray[_loc2_]._xscale *= -1;
  958.                   }
  959.                   else
  960.                   {
  961.                      enemyArray[_loc2_].xSpeed *= -1.1;
  962.                      if(_loc3_ < 400)
  963.                      {
  964.                         enemyArray[_loc2_].S_State = 3;
  965.                      }
  966.                   }
  967.                }
  968.                if(collision(enemyArray[_loc2_]._x + 25,enemyArray[_loc2_]._y + 30,GROUND) != true)
  969.                {
  970.                   if(enemyArray[_loc2_].S_State < 1)
  971.                   {
  972.                      enemyArray[_loc2_]._x -= 5;
  973.                      enemyArray[_loc2_].xSpeed *= -1.1;
  974.                      enemyArray[_loc2_].moveDir *= -1;
  975.                      enemyArray[_loc2_]._xscale *= -1;
  976.                   }
  977.                   else
  978.                   {
  979.                      enemyArray[_loc2_].xSpeed *= -1.1;
  980.                      if(_loc3_ < 400)
  981.                      {
  982.                         enemyArray[_loc2_].S_State = 3;
  983.                      }
  984.                   }
  985.                }
  986.                unlockSprite(enemyArray[_loc2_],"JUMP");
  987.             }
  988.             if(enemyArray[_loc2_].jumpBuffer > 10)
  989.             {
  990.                setSprite(enemyArray[_loc2_],"JUMP");
  991.                enemyArray[_loc2_].spriteLock = "JUMP";
  992.             }
  993.             else
  994.             {
  995.                unlockSprite(enemyArray[_loc2_],"JUMP");
  996.             }
  997.             if(collision(enemyArray[_loc2_]._x - 20,enemyArray[_loc2_]._y - 50,GROUND) || collision(enemyArray[_loc2_]._x + 20,enemyArray[_loc2_]._y - 50,GROUND))
  998.             {
  999.                if(collision(enemyArray[_loc2_]._x - 20,enemyArray[_loc2_]._y - 100,GROUND) != true)
  1000.                {
  1001.                   enemyArray[_loc2_].ySpeed = -15;
  1002.                   enemyArray[_loc2_].xSpeed = 5;
  1003.                }
  1004.                while(collision(enemyArray[_loc2_]._x - 20,enemyArray[_loc2_]._y - 50,GROUND))
  1005.                {
  1006.                   enemyArray[_loc2_]._x += 2;
  1007.                }
  1008.                while(collision(enemyArray[_loc2_]._x + 20,enemyArray[_loc2_]._y - 50,GROUND))
  1009.                {
  1010.                   enemyArray[_loc2_]._x -= 2;
  1011.                }
  1012.                enemyArray[_loc2_].xSpeed *= -1.1;
  1013.                enemyArray[_loc2_].moveDir *= -1;
  1014.                enemyArray[_loc2_]._xscale *= -1;
  1015.             }
  1016.             enemyArray[_loc2_].xSpeed /= 1.1 + enemyArray[_loc2_].power / 10;
  1017.             if(enemyArray[_loc2_].S_State != 3)
  1018.             {
  1019.                enemyArray[_loc2_]._x += enemyArray[_loc2_].xSpeed;
  1020.             }
  1021.             enemyArray[_loc2_]._xscale = enemyArray[_loc2_].scaler * enemyArray[_loc2_].moveDir;
  1022.             if(enemyArray[_loc2_].S_State == 0)
  1023.             {
  1024.                enemyArray[_loc2_].shockTime = 0;
  1025.                setSprite(enemyArray[_loc2_],"SNEAK");
  1026.                enemyArray[_loc2_].xSpeed += enemyArray[_loc2_].moveDir / 4;
  1027.             }
  1028.             else if(enemyArray[_loc2_].S_State == 1)
  1029.             {
  1030.                enemyArray[_loc2_].VA._xscale = 70;
  1031.                enemyArray[_loc2_].VA._yscale = 70;
  1032.                setSprite(enemyArray[_loc2_],"STAND");
  1033.                if(enemyArray[_loc2_].shockTime >= 30)
  1034.                {
  1035.                   if(enemyArray[_loc2_].shockTime == 30)
  1036.                   {
  1037.                      enemyArray[_loc2_]._xscale *= -1;
  1038.                      enemyArray[_loc2_].moveDir *= -1;
  1039.                   }
  1040.                   else if(enemyArray[_loc2_].shockTime == 40)
  1041.                   {
  1042.                      enemyArray[_loc2_]._xscale *= -1;
  1043.                      enemyArray[_loc2_].moveDir *= -1;
  1044.                   }
  1045.                }
  1046.                enemyArray[_loc2_].shockTime = enemyArray[_loc2_].shockTime + 1;
  1047.                if(enemyArray[_loc2_].shockTime > 50)
  1048.                {
  1049.                   enemyArray[_loc2_].S_State = 0;
  1050.                   enemyArray[_loc2_].shockTime = 0;
  1051.                }
  1052.             }
  1053.             else if(enemyArray[_loc2_].S_State == 2)
  1054.             {
  1055.                if(_loc3_ < 30)
  1056.                {
  1057.                   if(MAN.dead != true)
  1058.                   {
  1059.                      enemyArray[_loc2_].gotoAndStop("SLASH");
  1060.                      if(MAN._x > enemyArray[_loc2_]._x && enemyArray[_loc2_]._xscale > 0)
  1061.                      {
  1062.                         hurtMan(2);
  1063.                         MAN.xSpeed += 5;
  1064.                      }
  1065.                      else if(MAN._x < enemyArray[_loc2_]._x && enemyArray[_loc2_]._xscale < 0)
  1066.                      {
  1067.                         hurtMan(2);
  1068.                         MAN.xSpeed -= 5;
  1069.                      }
  1070.                   }
  1071.                }
  1072.                else if(enemyArray[_loc2_].shockTime < 200)
  1073.                {
  1074.                   enemyArray[_loc2_].shockTime = enemyArray[_loc2_].shockTime + 1;
  1075.                   enemyArray[_loc2_].suspectTime = enemyArray[_loc2_].suspectTime + 1;
  1076.                   if(enemyArray[_loc2_].suspectTime > 20)
  1077.                   {
  1078.                      if(enemyArray[_loc2_].hitTest(MAN))
  1079.                      {
  1080.                         enemyArray[_loc2_].shockTime = 0;
  1081.                      }
  1082.                      enemyArray[_loc2_].VA._xscale = 100;
  1083.                      enemyArray[_loc2_].VA._yscale = 100;
  1084.                      if(MAN.dead != true)
  1085.                      {
  1086.                         setSprite(enemyArray[_loc2_],"RUN");
  1087.                      }
  1088.                      enemyArray[_loc2_].xSpeed += enemyArray[_loc2_].moveDir / 1.5;
  1089.                      if(enemyArray[_loc2_]._x > enemyArray[_loc2_].spotPosX + 50)
  1090.                      {
  1091.                         enemyArray[_loc2_].moveDir = -1;
  1092.                      }
  1093.                      else if(enemyArray[_loc2_]._x < enemyArray[_loc2_].spotPosX - 50)
  1094.                      {
  1095.                         enemyArray[_loc2_].moveDir = 1;
  1096.                      }
  1097.                   }
  1098.                   else if(MAN.dead != true)
  1099.                   {
  1100.                      setSprite(enemyArray[_loc2_],"SHOCK");
  1101.                   }
  1102.                }
  1103.                else
  1104.                {
  1105.                   enemyArray[_loc2_].shockTime = 0;
  1106.                   enemyArray[_loc2_].suspectTime = 0;
  1107.                   enemyArray[_loc2_].S_State = 1;
  1108.                }
  1109.             }
  1110.             else if(enemyArray[_loc2_].S_State == 3)
  1111.             {
  1112.                enemyArray[_loc2_].xSpeed = 0;
  1113.                unlockSprite(enemyArray[_loc2_],"JUMP");
  1114.                setSprite(enemyArray[_loc2_],"SHOOT");
  1115.                enemyArray[_loc2_].spriteLock = "SHOOT";
  1116.                enemyArray[_loc2_].anglerVar = angle(enemyArray[_loc2_]._x,enemyArray[_loc2_]._y,MAN._x,MAN._y);
  1117.                if(enemyArray[_loc2_]._x > MAN._x)
  1118.                {
  1119.                   enemyArray[_loc2_].anglerVar += 10 + enemyArray[_loc2_].anglerAdjust;
  1120.                }
  1121.                else
  1122.                {
  1123.                   enemyArray[_loc2_].anglerVar -= 10 + enemyArray[_loc2_].anglerAdjust;
  1124.                }
  1125.                if(enemyArray[_loc2_]._x < MAN._x)
  1126.                {
  1127.                   enemyArray[_loc2_].sprite.bowAim._rotation = enemyArray[_loc2_].anglerVar - 90;
  1128.                   enemyArray[_loc2_].sprite.bowAim.arms._rotation = enemyArray[_loc2_].anglerVar - 90 - enemyArray[_loc2_].sprite.bowAim._rotation / 1;
  1129.                   enemyArray[_loc2_]._xscale = enemyArray[_loc2_].scaler;
  1130.                }
  1131.                else
  1132.                {
  1133.                   enemyArray[_loc2_].sprite.bowAim._rotation = - (enemyArray[_loc2_].anglerVar + 90);
  1134.                   enemyArray[_loc2_].sprite.bowAim.arms._rotation = - (enemyArray[_loc2_].anglerVar + 90) - enemyArray[_loc2_].sprite.bowAim._rotation / 1;
  1135.                   enemyArray[_loc2_]._xscale = - enemyArray[_loc2_].scaler;
  1136.                }
  1137.                if(enemyArray[_loc2_].sprite.bowAim.bow._currentframe < 5)
  1138.                {
  1139.                   enemyArray[_loc2_].sprite.bowAim.bow.nextFrame();
  1140.                   enemyArray[_loc2_].sprite.bowAim.arms.nextFrame();
  1141.                }
  1142.                if(enemyArray[_loc2_].arrowTimer == 1)
  1143.                {
  1144.                   enemyArray[_loc2_].arrowTimer = 30 + random(30);
  1145.                   speed = calcSpeed(enemyArray[_loc2_].anglerVar - 90,random(100) + 200);
  1146.                   enemyArray[_loc2_].sprite.bowAim.bow.gotoAndStop(1);
  1147.                   enemyArray[_loc2_].sprite.bowAim.arms.gotoAndStop(1);
  1148.                   newArrow(enemyArray[_loc2_]._x,enemyArray[_loc2_]._y - 30,enemyArray[_loc2_]);
  1149.                   enemyArray[_loc2_].anglerAdjust = random(10);
  1150.                }
  1151.                else
  1152.                {
  1153.                   enemyArray[_loc2_].arrowTimer--;
  1154.                }
  1155.             }
  1156.          }
  1157.       }
  1158.       _loc2_ = _loc2_ + 1;
  1159.    }
  1160. }
  1161. function setFPS()
  1162. {
  1163.    var _loc1_ = new Date();
  1164.    var _loc2_ = 0;
  1165.    while(_loc1_.getTime() < FPSTimer)
  1166.    {
  1167.       _loc1_ = new Date();
  1168.       _loc2_ = _loc2_ + 1;
  1169.    }
  1170.    if(Key.isDown(16))
  1171.    {
  1172.       FPSTimer = _loc1_.getTime() + 100;
  1173.    }
  1174.    else
  1175.    {
  1176.       FPSTimer = _loc1_.getTime() + 25;
  1177.    }
  1178. }
  1179. function newBlood(xPos, yPos)
  1180. {
  1181.    if(random(4) == 1)
  1182.    {
  1183.       var _loc1_ = EFFECTS.attachMovie("Blood","B",EFFECTS.getNextHighestDepth());
  1184.       _loc1_._x = xPos;
  1185.       _loc1_._y = yPos;
  1186.       _loc1_.xSpeed = random(6) - 3;
  1187.       _loc1_.ySpeed = - (random(15) + 5);
  1188.       _loc1_._xscale = random(50);
  1189.       _loc1_._yscale = _loc1_._xscale;
  1190.       _loc1_._alpha = 200;
  1191.       _loc1_._rotation = random(360);
  1192.       bloodArray.push(_loc1_);
  1193.    }
  1194. }
  1195. function updateBlood()
  1196. {
  1197.    var _loc1_ = 0;
  1198.    while(_loc1_ < bloodArray.length)
  1199.    {
  1200.       if(bloodArray[_loc1_]._alpha > 0)
  1201.       {
  1202.          bloodArray[_loc1_]._x += bloodArray[_loc1_].xSpeed;
  1203.          bloodArray[_loc1_]._y += bloodArray[_loc1_].ySpeed;
  1204.          bloodArray[_loc1_].ySpeed += 2;
  1205.          bloodArray[_loc1_]._alpha -= 10;
  1206.          bloodArray[_loc1_]._xscale += 5;
  1207.          bloodArray[_loc1_]._yscale += 5;
  1208.       }
  1209.       else
  1210.       {
  1211.          bloodArray[_loc1_].removeMovieClip();
  1212.          bloodArray.splice(_loc1_,1);
  1213.       }
  1214.       _loc1_ = _loc1_ + 1;
  1215.    }
  1216. }
  1217. function HUDControl()
  1218. {
  1219.    if(MAN.dead == false)
  1220.    {
  1221.       _parent.HUD.HBar._width = 150 / (100 * _root.difficulty) * MAN.health;
  1222.       _parent.HUD.HBar2._width = 0.75 * MAN.healthTimer;
  1223.    }
  1224.    else
  1225.    {
  1226.       _parent.HUD.HBar._width = 0;
  1227.    }
  1228.    if(MAN.health < 100 * _root.difficulty)
  1229.    {
  1230.       if(MAN.healthTimer > 0)
  1231.       {
  1232.          MAN.healthTimer--;
  1233.       }
  1234.       else
  1235.       {
  1236.          MAN.health = MAN.health + 1;
  1237.       }
  1238.    }
  1239. }
  1240. function hurtMan(ammount)
  1241. {
  1242.    ammount = Math.round(ammount / 1.5);
  1243.    if(MAN.dead == false)
  1244.    {
  1245.       _root.playSound("HURT",100);
  1246.       _root.FADER._alpha = 50;
  1247.       _root.FADER.gotoAndStop(3);
  1248.       newBlood(MAN._x,MAN._y - 40);
  1249.       MAN.bowActive = false;
  1250.       MAN.keyPressRight = true;
  1251.       MAN.health -= ammount;
  1252.       MAN.healthTimer = 200;
  1253.       if(MAN.health <= 0)
  1254.       {
  1255.          _root.playSound("DEAD",100);
  1256.          MAN.dead = true;
  1257.          MAN._x -= MAN.xSpeed * 5;
  1258.       }
  1259.    }
  1260. }
  1261. function spikeDamage()
  1262. {
  1263.    if(_root.coins >= _root.coinArray[level] && PROPS.EOL._currentframe < 10)
  1264.    {
  1265.       PROPS.EOL.nextFrame();
  1266.    }
  1267.    if(MAN._y > 3000 || pythag(MAN._x,MAN._y,PROPS.EOL._x,PROPS.EOL._y) < 10 && _root.coins >= _root.coinArray[level])
  1268.    {
  1269.       _root.saveObject.level = _root.saveObject.level + 1;
  1270.       _root.saveObject.coins = _root.coins;
  1271.       _root.saveObject.deaths = _root.deaths;
  1272.       _root.saveObject.kills = _root.kills;
  1273.       _root.saveData();
  1274.       EOLFreeze = true;
  1275.       MAN.gotoAndStop("STAND");
  1276.       _root.gotoFrame("blank",1);
  1277.    }
  1278.    if(MAN.dead == false)
  1279.    {
  1280.       if(collision(MAN._x,MAN._y - 10,SPIKES) == true || collision(MAN._x,MAN._y - 55,SPIKES) == true)
  1281.       {
  1282.          spikeTimer++;
  1283.          if(spikeTimer == 3)
  1284.          {
  1285.             MAN.ySpeed = -20;
  1286.             hurtMan(1000);
  1287.          }
  1288.       }
  1289.       else
  1290.       {
  1291.          spikeTimer = 0;
  1292.       }
  1293.    }
  1294. }
  1295. level = _root.saveObject.level;
  1296. GROUND.gotoAndStop(level);
  1297. GROUND_G.gotoAndStop(level);
  1298. SPIKES.gotoAndStop(level);
  1299. PROPS.gotoAndStop(level);
  1300. createEmptyMovieClip("EFFECTS",0);
  1301. createEmptyMovieClip("NOISE",1);
  1302. NOISE._visible = 0;
  1303. this.setMask(_parent.lightSource);
  1304. _parent.focusBG._alpha = 0;
  1305. coinStore = _root.saveObject.coins;
  1306. deathStore = _root.saveObject.deaths;
  1307. killStore = _root.saveObject.kills;
  1308. _root.coins = _root.saveObject.coins;
  1309. _root.deaths = _root.saveObject.deaths;
  1310. _root.kills = _root.saveObject.kills;
  1311. _root.difficulty = 1;
  1312. var xDragStart = 0;
  1313. var yDragStart = 0;
  1314. var jumpBufferStore = 10;
  1315. var arrowPosX = 0;
  1316. var arrowPosY = 0;
  1317. MAN.powerVar;
  1318. MAN.anglerVar;
  1319. var speed;
  1320. var previewVar = false;
  1321. var windSpeed = 0;
  1322. MAN.health = 100 * _root.difficulty;
  1323. MAN.healthTimer = 0;
  1324. MAN.bowActive = false;
  1325. MAN.xSpeed = 0;
  1326. MAN.ySpeed = 0;
  1327. MAN.spriteLock = 0;
  1328. MAN.jumpBuffer = 0;
  1329. MAN.jumpHeight = 25;
  1330. MAN.jumpSwitch = false;
  1331. MAN.swingActive = false;
  1332. MAN.doubleJump = true;
  1333. MAN.sneakActive = false;
  1334. MAN.visualStyle = 1;
  1335. MAN.deadTimer = 0;
  1336. MAN.mousePressed = false;
  1337. MAN.dead = false;
  1338. MAN.rollCount = 20;
  1339. MAN.VA._xscale = 0;
  1340. MAN.VA._yscale = 0;
  1341. var zoomShake = 0;
  1342. var bow_Range = 10;
  1343. var bow_Range_Array = new Array(null,80,90,100,110,120,130,140,150,150,150);
  1344. var bow_Accuracy = 10;
  1345. var bow_Accuracy_Array = new Array(null,5,10,15,20,25,30,35,40,45,100);
  1346. var bow_Power = 10;
  1347. var magic_Speed = 1;
  1348. var manXScale = MAN._xscale;
  1349. var camElasticTimer = 10;
  1350. var point;
  1351. var camPos = {x:MAN._x,y:MAN._y};
  1352. var noiseArray = new Array();
  1353. camYOffset = 188;
  1354. gamePaused = false;
  1355. gamePauseSwitch = false;
  1356. var arrowArray = new Array();
  1357. var wallCSize = 15;
  1358. var wallRSize = 90;
  1359. var oldY = object._y;
  1360. var enemyArray = new Array();
  1361. var bloodArray = new Array();
  1362. var EOLFreeze = false;
  1363. var spikeTimer = 0;
  1364. PROPS.EOL.coinText = _root.coinArray[level];
  1365.