home *** CD-ROM | disk | FTP | other *** search
/ Champak 48 / cdrom_image.iso / Games / alex_trax.swf / scripts / __Packages / com / neodelight / r2d / R2d.as next >
Encoding:
Text File  |  2007-10-01  |  38.8 KB  |  1,067 lines
  1. class com.neodelight.r2d.R2d
  2. {
  3.    var lvl;
  4.    var worldTileX;
  5.    var worldTileY;
  6.    var worldX;
  7.    var worldY;
  8.    var mc;
  9.    var fx;
  10.    var springs;
  11.    var timeStart;
  12.    var xtras;
  13.    var player;
  14.    var map;
  15.    var lines;
  16.    var linesLen;
  17.    var cameraX;
  18.    var cameraY;
  19.    var freeze;
  20.    var hopSustain;
  21.    var hopLock;
  22.    var hopSoundLock;
  23.    var accTilt;
  24.    var idleTimer;
  25.    var matrix;
  26.    var texture;
  27.    var sndDrive;
  28.    var engine;
  29.    var pushCount;
  30.    var timeSpeed = 400;
  31.    function R2d()
  32.    {
  33.       _root.engine = this;
  34.       var _loc0_ = null;
  35.       var _loc12_ = this.lvl = _global.lib.lvls[_global.game.actLevel];
  36.       this.worldTileX = -Infinity;
  37.       this.worldTileY = -Infinity;
  38.       this.worldX = this.lvl.startX - 275;
  39.       this.worldY = this.lvl.startY - 250;
  40.       _root.createEmptyMovieClip("gameMc",0);
  41.       this.mc = _root.gameMc;
  42.       this.fx = new com.neodelight.std.ColorFader(this.mc);
  43.       this.mc.attachMovie("background","backgroundMc",0);
  44.       this.mc.createEmptyMovieClip("bg",2);
  45.       this.mc.attachMovie("wheel","wheel1",12,{_x:179,_y:230,_rotation:random(360)});
  46.       this.mc.attachMovie("wheel","wheel2",13,{_x:371,_y:230,_rotation:random(360)});
  47.       this.mc.attachMovie("body","body",14,{_x:275,_y:250});
  48.       this.mc.createEmptyMovieClip("driver",15);
  49.       this.mc.driver._visible = false;
  50.       this.mc.createEmptyMovieClip("xtrasMc",1);
  51.       this.mc.attachMovie("leg1","leg1b",8);
  52.       this.mc.leg1b.col = new Color(this.mc.leg1b);
  53.       this.mc.leg1b.col.setTransform({ra:80,rb:0,ga:80,gb:0,ba:80,bb:0,aa:100,ab:0});
  54.       this.mc.attachMovie("leg2","leg2b",9);
  55.       this.mc.leg2b.col = new Color(this.mc.leg2b);
  56.       this.mc.leg2b.col.setTransform({ra:80,rb:0,ga:80,gb:0,ba:80,bb:0,aa:100,ab:0});
  57.       this.mc.driver.attachMovie("torso","torso",10);
  58.       this.mc.driver.attachMovie("leg1","leg1",11);
  59.       this.mc.driver.attachMovie("leg2","leg2",12);
  60.       this.mc.driver.attachMovie("arm1","arm1",14);
  61.       this.mc.driver.attachMovie("arm2","arm2",15);
  62.       this.newForce(this.mc.wheel1,235,230);
  63.       this.newForce(this.mc.wheel2,315,230);
  64.       var _loc6_ = undefined;
  65.       this.mc.anchor0 = {};
  66.       _loc6_ = {x:this.mc.body.a0._x,y:this.mc.body.a0._y};
  67.       this.mc.body.localToGlobal(_loc6_);
  68.       this.newForce(this.mc.anchor0,_loc6_.x,_loc6_.y,true);
  69.       this.mc.anchor1 = {};
  70.       _loc6_ = {x:this.mc.body.a1._x,y:this.mc.body.a1._y};
  71.       this.mc.body.localToGlobal(_loc6_);
  72.       this.newForce(this.mc.anchor1,_loc6_.x,_loc6_.y);
  73.       this.mc.anchor2 = {};
  74.       _loc6_ = {x:this.mc.body.a2._x,y:this.mc.body.a2._y};
  75.       this.mc.body.localToGlobal(_loc6_);
  76.       this.newForce(this.mc.anchor2,_loc6_.x,_loc6_.y,true);
  77.       this.mc.anchor2b = {};
  78.       _loc6_ = {x:this.mc.body.a2b._x,y:this.mc.body.a2b._y};
  79.       this.mc.body.localToGlobal(_loc6_);
  80.       this.newForce(this.mc.anchor2b,_loc6_.x,_loc6_.y,true);
  81.       this.mc.driver0 = {};
  82.       _loc6_ = {x:this.mc.body.r0._x,y:this.mc.body.r0._y};
  83.       this.mc.body.localToGlobal(_loc6_);
  84.       this.newForce(this.mc.driver0,_loc6_.x,_loc6_.y);
  85.       this.mc.driver1 = {};
  86.       _loc6_ = {x:this.mc.body.r1._x,y:this.mc.body.r1._y};
  87.       this.mc.body.localToGlobal(_loc6_);
  88.       this.newForce(this.mc.driver1,_loc6_.x,_loc6_.y);
  89.       this.mc.driver2 = {};
  90.       _loc6_ = {x:this.mc.body.r2._x,y:this.mc.body.r2._y};
  91.       this.mc.body.localToGlobal(_loc6_);
  92.       this.newForce(this.mc.driver2,_loc6_.x,_loc6_.y);
  93.       this.mc.driver2b = {};
  94.       _loc6_ = {x:this.mc.body.r2b._x,y:this.mc.body.r2b._y};
  95.       this.mc.body.localToGlobal(_loc6_);
  96.       this.newForce(this.mc.driver2b,_loc6_.x,_loc6_.y);
  97.       this.mc.driver2b;
  98.       this.springs = [[this.mc.wheel1,this.mc.wheel2],[this.mc.driver0,this.mc.anchor0],[this.mc.driver1,this.mc.anchor0],[this.mc.driver0,this.mc.driver1],[this.mc.anchor1,this.mc.driver1],[this.mc.driver0,this.mc.anchor1],[this.mc.anchor1,this.mc.driver2],[this.mc.anchor1,this.mc.driver2b],[this.mc.driver2,this.mc.anchor2][this.mc.anchor2b]];
  99.       for(var _loc7_ in this.springs)
  100.       {
  101.          var _loc4_ = this.springs[_loc7_];
  102.          var _loc9_ = _loc4_[0].x - _loc4_[1].x;
  103.          var _loc8_ = _loc4_[0].y - _loc4_[1].y;
  104.          _loc4_[2] = int(Math.sqrt(_loc9_ * _loc9_ + _loc8_ * _loc8_) * 100) / 100;
  105.       }
  106.       this.mc.attachMovie("hud","hud",18);
  107.       this.mc.hud._x = 0;
  108.       this.mc.hud._y = 0;
  109.       this.timeStart = getTimer();
  110.       _global.tagCount = 0;
  111.       _global.numberOfTags = 0;
  112.       this.xtras = new Array(this.lvl.xtras.length);
  113.       _loc7_ = this.lvl.xtras.length;
  114.       while(true)
  115.       {
  116.          _loc7_;
  117.          if(!_loc7_--)
  118.          {
  119.             break;
  120.          }
  121.          var _loc5_ = this.lvl.xtras[_loc7_];
  122.          if(_loc5_[2] == 2)
  123.          {
  124.             _global.numberOfTags = _global.numberOfTags + 1;
  125.          }
  126.          this.xtras[_loc7_] = [_loc5_[0],_loc5_[1],_loc5_[2],null,false,false];
  127.       }
  128.       var _loc0_ = null;
  129.       var _loc11_ = this.player = {};
  130.       _loc11_.vel = 0;
  131.       _loc11_.dir = 1;
  132.       _loc11_.pedalPos = 0;
  133.       _loc11_.tilt = 0;
  134.       _loc11_.dead = 0;
  135.       _loc11_.ducking = 0;
  136.       var _loc10_ = _root.shared;
  137.       this.mc.driver.torso.head.gotoAndStop(_loc10_.data.bikeProperties[0]);
  138.       this.mc.driver.torso.gotoAndStop(_loc10_.data.bikeProperties[1]);
  139.       this.mc.driver.arm1.gotoAndStop(_loc10_.data.bikeProperties[1]);
  140.       this.mc.driver.arm2.gotoAndStop(_loc10_.data.bikeProperties[1]);
  141.       this.mc.driver.torso.pants.gotoAndStop(_loc10_.data.bikeProperties[2]);
  142.       this.mc.driver.leg1.gotoAndStop(_loc10_.data.bikeProperties[2]);
  143.       this.mc.driver.leg2.gotoAndStop(_loc10_.data.bikeProperties[2]);
  144.       this.mc.leg1b.gotoAndStop(_loc10_.data.bikeProperties[2]);
  145.       this.mc.leg2b.gotoAndStop(_loc10_.data.bikeProperties[2]);
  146.       this.mc.wheel1.gotoAndStop(_loc10_.data.bikeProperties[3]);
  147.       this.mc.wheel2.gotoAndStop(_loc10_.data.bikeProperties[3]);
  148.       this.mc.body.gotoAndStop(_loc10_.data.bikeProperties[4]);
  149.       if(_loc10_.data.bikeProperties[4] === 1)
  150.       {
  151.          _loc11_.maxVel = (1 - _loc12_.ice) * 10 + _loc12_.ice * 5;
  152.          _loc11_.acc1 = (1 - _loc12_.ice) * 1.6 + _loc12_.ice * 0.8;
  153.          _loc11_.acc2 = 0.4;
  154.          _loc11_.minVel = (1 - _loc12_.ice) * -8 + _loc12_.ice * -4;
  155.       }
  156.       this.map = [];
  157.       this.lines = new Array(200);
  158.       _loc7_ = 0;
  159.       while(_loc7_ < 200)
  160.       {
  161.          this.lines[_loc7_] = [0,0,0,0];
  162.          _loc7_ = _loc7_ + 1;
  163.       }
  164.       this.linesLen = 0;
  165.       this.cameraX = 0;
  166.       this.cameraY = 0;
  167.       this.freeze = 0;
  168.       this.hopSustain = 0;
  169.       this.hopLock = 0;
  170.       this.hopSoundLock = 0;
  171.       this.accTilt = 0.023;
  172.       _root.keySpace = true;
  173.       this.mc.backgroundMc.gotoAndStop(this.lvl.skin + 1);
  174.       this.idleTimer = -1;
  175.       _root.inGame = true;
  176.       this.matrix = new flash.geom.Matrix();
  177.       this.texture = flash.display.BitmapData.loadBitmap("texture" + this.lvl.skin);
  178.       this.sndDrive = _global.snd.channelsById.drive;
  179.       _global.snd.playEvent("sndLevelStart",1);
  180.       this.mc.engine = this;
  181.       this.mc.i = 0;
  182.       this.mc.onEnterFrame = function()
  183.       {
  184.          _root.a.startCount();
  185.          this.engine.move();
  186.          _root.a.stopCount();
  187.       };
  188.       this.fx.fadeTo(com.neodelight.std.ColorFader.FX_BLACK,0);
  189.       this.fx.fadeTo(com.neodelight.std.ColorFader.FX_NONE,10);
  190.       _root.attachMovie("go","goMc",_root.getNextHighestDepth());
  191.    }
  192.    function debug()
  193.    {
  194.       this.mc.attachMovie("light","light",50,{_x:0,_y:20});
  195.    }
  196.    function verlet(v)
  197.    {
  198.       var _loc3_ = v.ox;
  199.       var _loc2_ = v.oy;
  200.       v.ox = v.x;
  201.       v.oy = v.y;
  202.       if(v.f > 0)
  203.       {
  204.          v.fx /= v.f;
  205.       }
  206.       if(v.f > 0)
  207.       {
  208.          v.fy /= v.f;
  209.       }
  210.       v.x += 0.99 * (v.x - _loc3_) + v.fx;
  211.       v.y += 0.99 * (v.y - _loc2_) + v.fy + 1.5;
  212.       v.fx = v.fy = v.f = 0;
  213.    }
  214.    function zero(n)
  215.    {
  216.       if(n < 10)
  217.       {
  218.          return "0" + n;
  219.       }
  220.       return n.toString();
  221.    }
  222.    function newForce(o, x, y, isAnchor)
  223.    {
  224.       o.x = o.ox = x;
  225.       o.y = o.oy = y;
  226.       o.fx = o.fy = o.f = 0;
  227.       if(isAnchor)
  228.       {
  229.          o.a = true;
  230.       }
  231.    }
  232.    function drawMap()
  233.    {
  234.       var _loc9_ = this.mc;
  235.       var _loc14_ = _loc9_.bg;
  236.       var _loc17_ = this.lvl;
  237.       var _loc18_ = _loc17_.colFill;
  238.       var _loc16_ = this.map;
  239.       var _loc11_ = this.worldX;
  240.       var _loc10_ = this.worldY;
  241.       _loc14_.clear();
  242.       _loc14_.lineStyle(0,0,0);
  243.       var _loc12_ = this.lines;
  244.       var _loc3_ = null;
  245.       var _loc7_ = 0;
  246.       var _loc6_ = 0;
  247.       var _loc5_ = 0;
  248.       var _loc13_ = 0;
  249.       var _loc8_ = 0;
  250.       var _loc4_ = undefined;
  251.       var _loc15_ = _loc16_.length;
  252.       while(true)
  253.       {
  254.          _loc15_;
  255.          if(!_loc15_--)
  256.          {
  257.             break;
  258.          }
  259.          _loc3_ = _loc16_[_loc15_];
  260.          if(!(_loc3_[0][0] > _loc11_ + 550 || _loc3_[0][2] < _loc11_ || _loc3_[0][1] > _loc10_ + 400 || _loc3_[0][3] < _loc10_))
  261.          {
  262.             _loc7_ = _loc3_[0][4] - _loc11_;
  263.             _loc6_ = _loc3_[0][5] - _loc10_;
  264.             this.matrix.tx = - _loc11_;
  265.             this.matrix.ty = - _loc10_;
  266.             _loc14_.beginBitmapFill(this.texture,this.matrix);
  267.             _loc14_.moveTo(_loc3_[1][0] + _loc7_,_loc3_[1][1] + _loc6_);
  268.             _loc5_ = 2;
  269.             _loc13_ = _loc3_.length;
  270.             _root.a1.startCount();
  271.             while(_loc5_ < _loc13_)
  272.             {
  273.                _loc4_ = _loc12_[_loc8_];
  274.                _loc4_[0] = _loc3_[_loc5_ - 1][0] + _loc7_;
  275.                _loc4_[1] = _loc3_[_loc5_ - 1][1] + _loc6_;
  276.                _loc4_[2] = _loc3_[_loc5_][0] + _loc7_;
  277.                _loc4_[3] = _loc3_[_loc5_][1] + _loc6_;
  278.                _loc8_ = _loc8_ + 1;
  279.                _loc9_.bg.lineTo(_loc4_[2],_loc4_[3]);
  280.                _loc5_ = _loc5_ + 1;
  281.             }
  282.             _loc4_ = _loc12_[_loc8_];
  283.             _loc4_[0] = _loc3_[_loc5_ - 1][0] + _loc7_;
  284.             _loc4_[1] = _loc3_[_loc5_ - 1][1] + _loc6_;
  285.             _loc4_[2] = _loc3_[1][0] + _loc7_;
  286.             _loc4_[3] = _loc3_[1][1] + _loc6_;
  287.             _loc8_ = _loc8_ + 1;
  288.             _loc9_.bg.lineTo(_loc4_[2],_loc4_[3]);
  289.             _loc9_.bg.endFill();
  290.             _root.a1.stopCount();
  291.          }
  292.       }
  293.       this.linesLen = _loc8_;
  294.    }
  295.    function refreshMap()
  296.    {
  297.       var _loc8_ = int(this.worldX / 550);
  298.       var _loc7_ = int(this.worldY / 400);
  299.       if(_loc8_ != this.worldTileX || _loc7_ != this.worldTileY)
  300.       {
  301.          var _loc4_ = this.lvl.map;
  302.          this.worldTileX = _loc8_;
  303.          this.worldTileY = _loc7_;
  304.          delete this.map;
  305.          this.map = new Array();
  306.          var _loc6_ = _loc8_ * 550;
  307.          var _loc5_ = _loc7_ * 400;
  308.          var _loc2_ = null;
  309.          var _loc3_ = _loc4_.length;
  310.          while(true)
  311.          {
  312.             _loc3_;
  313.             if(!_loc3_--)
  314.             {
  315.                break;
  316.             }
  317.             _loc2_ = _loc4_[_loc3_][0];
  318.             if(!(_loc2_[0] > _loc6_ + 1100 || _loc2_[1] > _loc5_ + 800 || _loc2_[2] < _loc6_ || _loc2_[3] < _loc5_))
  319.             {
  320.                this.map.push(_loc4_[_loc3_]);
  321.             }
  322.          }
  323.       }
  324.    }
  325.    function constraints(v, acc)
  326.    {
  327.       var _loc18_ = this.player;
  328.       var _loc35_ = this.lvl;
  329.       var _loc40_ = this.mc;
  330.       var _loc37_ = _loc40_.bg;
  331.       var _loc17_ = Math.sqrt;
  332.       var _loc22_ = undefined;
  333.       var _loc20_ = undefined;
  334.       var _loc12_ = undefined;
  335.       var _loc21_ = undefined;
  336.       var _loc19_ = undefined;
  337.       var _loc29_ = undefined;
  338.       var _loc26_ = undefined;
  339.       var _loc14_ = undefined;
  340.       var _loc13_ = undefined;
  341.       var _loc7_ = undefined;
  342.       v.ground = false;
  343.       var _loc24_ = v == _loc40_.driver0;
  344.       var _loc15_ = undefined;
  345.       var _loc25_ = undefined;
  346.       if(_loc24_)
  347.       {
  348.          _loc15_ = 11;
  349.          _loc25_ = 100;
  350.       }
  351.       else
  352.       {
  353.          _loc15_ = 25;
  354.          _loc25_ = 576;
  355.       }
  356.       if(_loc37_.hitTest(v.x,v.y,true))
  357.       {
  358.          if(_loc24_)
  359.          {
  360.             return true;
  361.          }
  362.          _loc14_ = v.ox - v.x;
  363.          _loc13_ = v.oy - v.y;
  364.          _loc7_ = _loc17_(_loc14_ * _loc14_ + _loc13_ * _loc13_);
  365.          _loc14_ /= _loc7_;
  366.          _loc13_ /= _loc7_;
  367.          do
  368.          {
  369.             v.x += _loc14_ * 20;
  370.             v.y += _loc13_ * 20;
  371.          }
  372.          while(_loc37_.hitTest(v.x,v.y,true));
  373.          
  374.          v.ox = v.x;
  375.          v.oy = v.y;
  376.          trace("SND cheap collision");
  377.          _global.snd.playEvent("sndBump",1);
  378.       }
  379.       var _loc33_ = undefined;
  380.       var _loc30_ = undefined;
  381.       var _loc31_ = undefined;
  382.       var _loc27_ = undefined;
  383.       var _loc9_ = undefined;
  384.       var _loc11_ = undefined;
  385.       var _loc8_ = undefined;
  386.       var _loc10_ = undefined;
  387.       var _loc6_ = undefined;
  388.       var _loc5_ = undefined;
  389.       var _loc4_ = undefined;
  390.       var _loc23_ = undefined;
  391.       var _loc36_ = undefined;
  392.       var _loc16_ = undefined;
  393.       var _loc41_ = undefined;
  394.       var _loc34_ = this.linesLen;
  395.       var _loc38_ = this.lines;
  396.       var _loc32_ = undefined;
  397.       var _loc28_ = undefined;
  398.       while(true)
  399.       {
  400.          _loc34_;
  401.          if(!_loc34_--)
  402.          {
  403.             break;
  404.          }
  405.          _loc16_ = _loc38_[_loc34_];
  406.          _loc9_ = _loc16_[0];
  407.          _loc11_ = _loc16_[1];
  408.          _loc8_ = _loc16_[2];
  409.          _loc10_ = _loc16_[3];
  410.          if(_loc9_ < _loc8_)
  411.          {
  412.             _loc33_ = _loc9_;
  413.             _loc30_ = _loc8_;
  414.          }
  415.          else
  416.          {
  417.             _loc33_ = _loc8_;
  418.             _loc30_ = _loc9_;
  419.          }
  420.          if(_loc11_ < _loc10_)
  421.          {
  422.             _loc31_ = _loc11_;
  423.             _loc27_ = _loc10_;
  424.          }
  425.          else
  426.          {
  427.             _loc31_ = _loc10_;
  428.             _loc27_ = _loc11_;
  429.          }
  430.          if(!(v.x + 30 < _loc33_ || v.x - 30 > _loc30_ || v.y + 30 < _loc31_ || v.y - 30 > _loc27_))
  431.          {
  432.             _loc6_ = _loc8_ - _loc9_;
  433.             _loc5_ = _loc10_ - _loc11_;
  434.             _loc23_ = _loc6_ * _loc6_ + _loc5_ * _loc5_;
  435.             _loc4_ = _loc17_(_loc23_);
  436.             _loc6_ /= _loc4_;
  437.             _loc5_ /= _loc4_;
  438.             _loc36_ = _loc6_;
  439.             _loc6_ = _loc5_;
  440.             _loc5_ = - _loc36_;
  441.             _loc22_ = _loc9_ - v.x;
  442.             _loc20_ = _loc11_ - v.y;
  443.             _loc12_ = _loc22_ * _loc6_ + _loc20_ * _loc5_;
  444.             _loc14_ = _loc6_ * _loc12_;
  445.             _loc13_ = _loc5_ * _loc12_;
  446.             _loc7_ = _loc14_ * _loc14_ + _loc13_ * _loc13_;
  447.             if(_loc7_ < _loc25_)
  448.             {
  449.                _loc21_ = _loc9_ - v.x - _loc14_;
  450.                _loc19_ = _loc11_ - v.y - _loc13_;
  451.                _loc29_ = _loc8_ - v.x - _loc14_;
  452.                _loc26_ = _loc10_ - v.y - _loc13_;
  453.                if(_loc21_ * _loc21_ + _loc19_ * _loc19_ < _loc23_ && _loc29_ * _loc29_ + _loc26_ * _loc26_ < _loc23_)
  454.                {
  455.                   _loc7_ = _loc17_(_loc7_);
  456.                   _loc14_ /= _loc7_;
  457.                   _loc13_ /= _loc7_;
  458.                   _loc32_ = _loc14_ * (_loc15_ - _loc7_);
  459.                   _loc28_ = _loc13_ * (_loc15_ - _loc7_);
  460.                   v.x -= _loc32_;
  461.                   v.y -= _loc28_;
  462.                   this.pushCount += _loc32_ + _loc28_;
  463.                   if(_loc24_)
  464.                   {
  465.                      return true;
  466.                   }
  467.                   v.ox += (1 - _loc35_.ice) * (v.x - v.ox) / (56 - _loc7_);
  468.                   v.oy += (1 - _loc35_.ice) * (v.y - v.oy) / (56 - _loc7_);
  469.                   _loc6_ = _loc8_ - _loc9_;
  470.                   _loc5_ = _loc10_ - _loc11_;
  471.                   _loc6_ /= _loc4_;
  472.                   _loc5_ /= _loc4_;
  473.                   if(_loc8_ < _loc9_)
  474.                   {
  475.                      _loc22_ = _loc8_ - v.x;
  476.                      _loc20_ = _loc10_ - v.y;
  477.                   }
  478.                   _loc12_ = _loc22_ * _loc21_ + _loc20_ * _loc19_;
  479.                   if(_loc12_ > 1)
  480.                   {
  481.                      _loc12_ = 1;
  482.                   }
  483.                   else
  484.                   {
  485.                      _loc12_ = -1;
  486.                   }
  487.                   v.ground = true;
  488.                   if(acc)
  489.                   {
  490.                      v.f = v.f + 1;
  491.                      v.fx += _loc12_ * _loc6_ * _loc18_.dir * _loc18_.vel / (25 - _loc7_);
  492.                      v.fy += _loc12_ * _loc5_ * _loc18_.dir * _loc18_.vel / (25 - _loc7_);
  493.                      v.fy *= 0.5;
  494.                   }
  495.                }
  496.                else
  497.                {
  498.                   _loc6_ = v.x - _loc9_;
  499.                   _loc5_ = v.y - _loc11_;
  500.                   _loc4_ = _loc6_ * _loc6_ + _loc5_ * _loc5_;
  501.                   if(_loc4_ < _loc25_)
  502.                   {
  503.                      if(_loc24_)
  504.                      {
  505.                         return true;
  506.                      }
  507.                      _loc4_ = _loc17_(_loc4_);
  508.                      _loc6_ /= _loc4_;
  509.                      _loc5_ /= _loc4_;
  510.                      v.x += _loc6_ * (_loc15_ - _loc4_);
  511.                      v.y += _loc5_ * (_loc15_ - _loc4_);
  512.                      v.ox += (v.x - v.ox) * 1 / (56 - _loc4_);
  513.                      v.oy += (v.y - v.oy) * 1 / (56 - _loc4_);
  514.                   }
  515.                   _loc6_ = v.x - _loc8_;
  516.                   _loc5_ = v.y - _loc10_;
  517.                   _loc4_ = _loc6_ * _loc6_ + _loc5_ * _loc5_;
  518.                   if(_loc4_ < _loc25_)
  519.                   {
  520.                      if(_loc24_)
  521.                      {
  522.                         return true;
  523.                      }
  524.                      _loc4_ = _loc17_(_loc4_);
  525.                      _loc6_ /= _loc4_;
  526.                      _loc5_ /= _loc4_;
  527.                      v.x += _loc6_ * (_loc15_ - _loc4_);
  528.                      v.y += _loc5_ * (_loc15_ - _loc4_);
  529.                      v.ox += (v.x - v.ox) * 1 / (56 - _loc4_);
  530.                      v.oy += (v.y - v.oy) * 1 / (56 - _loc4_);
  531.                   }
  532.                }
  533.             }
  534.          }
  535.       }
  536.       if(_loc24_)
  537.       {
  538.          return false;
  539.       }
  540.    }
  541.    function quit(win, reason)
  542.    {
  543.       var _loc6_ = this.mc;
  544.       var _loc4_ = _root.shared;
  545.       _loc6_.removeMovieClip();
  546.       _root.onEnterFrame = function()
  547.       {
  548.       };
  549.       _root.inGame = false;
  550.       var _loc0_ = null;
  551.       var _loc5_ = _root.lastMapTime = getTimer() - this.timeStart;
  552.       _loc4_.data.totalTime += _loc5_;
  553.       var _loc9_ = !win;
  554.       var _loc8_ = _root.mapId;
  555.       if(reason == "quit")
  556.       {
  557.          _root.gotoAndStop("level");
  558.       }
  559.       else if(reason == "win")
  560.       {
  561.          _root.resultTime = Math.max(0,Math.floor(333.99 - (getTimer() - this.timeStart) / this.timeSpeed));
  562.          _root.resultUnlock = _global.game.actLevel + 1 < _global.lib.lvls.length && _global.game.actLevel + 1 > _global.game.maxLevel;
  563.          _global.game.actLevel = Math.min(_global.game.actLevel + 1,_global.lib.lvls.length - 1);
  564.          _global.game.maxLevel = _loc4_.data.maxLevel = Math.max(_global.game.maxLevel,_global.game.actLevel);
  565.          _loc4_.flush();
  566.          _root.gotoAndStop("levelOver");
  567.       }
  568.       else
  569.       {
  570.          _root.reasonOfDeath = reason;
  571.          _root.gotoAndPlay("newGame");
  572.       }
  573.    }
  574.    function move()
  575.    {
  576.       if(this.freeze)
  577.       {
  578.          this.freeze = this.freeze - 1;
  579.          if(this.freeze == 0)
  580.          {
  581.             this.fx.fadeTo({ra:100,rb:0,ga:33,gb:0,ba:0,bb:0,aa:100,ab:0},0);
  582.             this.fx.fadeTo(com.neodelight.std.ColorFader.FX_BLACK,this.player.deathCount);
  583.          }
  584.          else if(this.freeze % 2)
  585.          {
  586.             this.fx.fadeTo({ra:100,rb:0,ga:66,gb:0,ba:0,bb:0,aa:100,ab:0},0);
  587.          }
  588.          else
  589.          {
  590.             this.fx.fadeTo({ra:100,rb:0,ga:33,gb:0,ba:0,bb:0,aa:100,ab:0},0);
  591.          }
  592.          return undefined;
  593.       }
  594.       var _loc42_ = Math.sin;
  595.       var _loc34_ = Math.cos;
  596.       var _loc19_ = Math.atan2;
  597.       var _loc16_ = 0.017453292519943295;
  598.       var _loc20_ = Math.sqrt;
  599.       var _loc4_ = this.mc;
  600.       var _loc46_ = _root.shared;
  601.       var _loc31_ = this.lvl;
  602.       var player = this.player;
  603.       var _loc35_ = Math.max(0,333.99 - (getTimer() - this.timeStart) / this.timeSpeed);
  604.       if(_loc35_ == 0)
  605.       {
  606.          this.timeStart = getTimer() - 333.99 * this.timeSpeed;
  607.       }
  608.       var _loc38_ = Math.floor(_loc35_);
  609.       var _loc39_ = Math.floor((_loc35_ - _loc38_) * 100);
  610.       _loc4_.hud.t.text = _loc4_.hud.t1.text = _loc38_;
  611.       _loc4_.hud.h.text = _loc4_.hud.h1.text = this.zero(_loc39_);
  612.       if(!player.dead)
  613.       {
  614.          if(_loc4_.wheel1.y + this.worldY > _loc31_.groundY)
  615.          {
  616.             _global.snd.playEvent("sndAbyss",1);
  617.             this.death();
  618.          }
  619.       }
  620.       var _loc30_ = this.worldX;
  621.       var worldY = this.worldY;
  622.       var _loc55_ = undefined;
  623.       var _loc53_ = undefined;
  624.       var _loc27_ = _loc30_ - 100;
  625.       var _loc25_ = _loc30_ + 650;
  626.       var _loc26_ = worldY - 100;
  627.       var _loc24_ = worldY + 500;
  628.       var _loc11_ = null;
  629.       var _loc45_ = _loc4_.wheel1.x + _loc30_;
  630.       var _loc58_ = _loc4_.wheel1.y + worldY;
  631.       var _loc59_ = _loc4_.wheel2.x + _loc30_;
  632.       var _loc56_ = _loc4_.wheel2.y + worldY;
  633.       var _loc12_ = {x:0,y:0};
  634.       _loc12_.x = _loc4_.body.c._x;
  635.       _loc12_.y = _loc4_.body.c._y;
  636.       _loc4_.body.localToGlobal(_loc12_);
  637.       var _loc22_ = this.xtras;
  638.       var _loc13_ = _loc22_.length;
  639.       var _loc5_ = undefined;
  640.       while(true)
  641.       {
  642.          _loc13_;
  643.          if(!_loc13_--)
  644.          {
  645.             break;
  646.          }
  647.          _loc5_ = _loc22_[_loc13_];
  648.          if(!_loc5_[4])
  649.          {
  650.             _loc55_ = _loc5_[0];
  651.             _loc53_ = _loc5_[1];
  652.             if(!(_loc55_ < _loc27_ || _loc55_ > _loc25_ || _loc53_ < _loc26_ || _loc53_ > _loc24_))
  653.             {
  654.                if(!_loc5_[3])
  655.                {
  656.                   var _loc6_ = _loc4_.xtrasMc.getNextHighestDepth();
  657.                   var _loc0_ = null;
  658.                   _loc11_ = _loc5_[3] = _loc4_.xtrasMc.attachMovie("xtra","f" + _loc6_,_loc6_);
  659.                   _loc11_.gotoAndStop(_loc5_[2]);
  660.                }
  661.                _loc11_ = _loc5_[3];
  662.                _loc11_._x = _loc55_ - this.worldX;
  663.                _loc11_._y = _loc53_ - this.worldY;
  664.                if(_loc5_[2] < 4 && Math.sqrt(Math.pow(_loc11_._x - _loc12_.x,2) + Math.pow(_loc11_._y - _loc12_.y,2)) < 55)
  665.                {
  666.                   var _loc14_ = false;
  667.                   switch(_loc5_[2])
  668.                   {
  669.                      case 1:
  670.                         this.timeStart += 17600;
  671.                         _root.attachMovie("titleBonusTime",com.neodelight.std.Unique.getKey(),_root.getNextHighestDepth());
  672.                         _global.snd.playEvent("sndTime",1);
  673.                         _root.mapRedraw();
  674.                         _loc14_ = true;
  675.                         break;
  676.                      case 2:
  677.                         _global.tagCount = _global.tagCount + 1;
  678.                         _root.attachMovie("titleExitUnlocked",com.neodelight.std.Unique.getKey(),_root.getNextHighestDepth());
  679.                         _global.snd.playEvent("sndKey",1);
  680.                         _loc14_ = true;
  681.                         break;
  682.                      case 3:
  683.                         if(_global.tagCount == _global.numberOfTags)
  684.                         {
  685.                            _global.snd.playEvent("sndPortal",1);
  686.                            this.quit(true,"win");
  687.                            _loc14_ = true;
  688.                         }
  689.                         break;
  690.                      default:
  691.                         trace("error: unknown tag type: " + _loc5_[2]);
  692.                   }
  693.                   if(_loc14_)
  694.                   {
  695.                      _loc5_[4] = true;
  696.                      _loc5_[3].removeMovieClip();
  697.                      _loc5_[3] = null;
  698.                   }
  699.                }
  700.             }
  701.             else if(_loc5_[3])
  702.             {
  703.                _loc5_[3].removeMovieClip();
  704.                _loc5_[3] = null;
  705.             }
  706.          }
  707.       }
  708.       if(Key.isDown(45))
  709.       {
  710.          trace(_root._xmouse + this.worldX + "," + (_root._ymouse + this.worldY));
  711.       }
  712.       var _loc7_ = undefined;
  713.       var _loc8_ = undefined;
  714.       var _loc21_ = undefined;
  715.       var _loc18_ = undefined;
  716.       var _loc17_ = false;
  717.       if(!player.dead)
  718.       {
  719.          if(Key.isDown(27))
  720.          {
  721.             _global.snd.fadeChannel("athmo",-1,10);
  722.             _global.snd.playLoop("sndMusic",1,undefined,"music");
  723.             this.sndDrive.stop();
  724.             this.quit(false,"quit");
  725.             return undefined;
  726.          }
  727.          if(Key.isDown(38))
  728.          {
  729.             player.vel += player.acc1;
  730.             player.vel = Math.min(player.maxVel,player.vel);
  731.          }
  732.          else if(Key.isDown(40))
  733.          {
  734.             player.vel -= player.acc2;
  735.             player.vel = Math.max(player.minVel,player.vel);
  736.          }
  737.          else
  738.          {
  739.             player.vel *= 0.5;
  740.          }
  741.          if(this.idleTimer > -1)
  742.          {
  743.             this.idleTimer = this.idleTimer + 1;
  744.             if(this.idleTimer > 80)
  745.             {
  746.                this.idleTimer = -1;
  747.             }
  748.          }
  749.          if(Key.isDown(32))
  750.          {
  751.             if(!_root.keySpace)
  752.             {
  753.                _root.keySpace = true;
  754.                player.dir *= -1;
  755.                _loc4_.leg2b._yscale = _loc0_ = player.dir * 100;
  756.                _loc4_.leg1b._yscale = _loc0_;
  757.                _loc4_.driver.leg2._yscale = _loc0_;
  758.                _loc4_.driver.leg1._yscale = _loc0_;
  759.                _loc4_.driver.arm2._yscale = _loc0_;
  760.                _loc4_.driver.arm1._yscale = _loc0_;
  761.                _loc4_.driver.torso._yscale = _loc0_;
  762.                _loc4_.body._xscale = _loc0_;
  763.                _global.snd.playEvent("sndFlip",0.1);
  764.                _loc17_ = true;
  765.             }
  766.          }
  767.          else
  768.          {
  769.             _root.keySpace = false;
  770.          }
  771.          if(Key.isDown(37))
  772.          {
  773.             _loc7_ = _loc4_.wheel2.x - _loc4_.wheel1.x;
  774.             _loc8_ = _loc4_.wheel2.y - _loc4_.wheel1.y;
  775.             var _loc41_ = Math.max(0.5,Math.abs(_loc34_(4.71238898038469 - com.neodelight.std.XMath.vAngle(_loc7_,_loc8_))));
  776.             var _loc37_ = com.neodelight.std.XMath.vRotate(new com.neodelight.std.Vector(_loc7_,_loc8_),(- this.accTilt) * _loc41_);
  777.             var fx = _loc37_.x - _loc7_;
  778.             var _loc40_ = _loc37_.y - _loc8_;
  779.             _loc4_.wheel2.f = _loc4_.wheel2.f + 1;
  780.             _loc4_.wheel2.fx += fx;
  781.             _loc4_.wheel2.fy += _loc40_;
  782.             player.tilt -= 4;
  783.          }
  784.          else if(Key.isDown(39))
  785.          {
  786.             _loc7_ = _loc4_.wheel1.x - _loc4_.wheel2.x;
  787.             _loc8_ = _loc4_.wheel1.y - _loc4_.wheel2.y;
  788.             _loc41_ = Math.max(0.5,Math.abs(_loc34_(4.71238898038469 - com.neodelight.std.XMath.vAngle(_loc7_,_loc8_))));
  789.             _loc37_ = com.neodelight.std.XMath.vRotate(new com.neodelight.std.Vector(_loc7_,_loc8_),this.accTilt * _loc41_);
  790.             var fx = _loc37_.x - _loc7_;
  791.             _loc40_ = _loc37_.y - _loc8_;
  792.             _loc4_.wheel1.f = _loc4_.wheel1.f + 1;
  793.             _loc4_.wheel1.fx += fx;
  794.             _loc4_.wheel1.fy += _loc40_;
  795.             player.tilt += 4;
  796.          }
  797.          this.hopSustain = this.hopSustain - 1;
  798.          this.hopLock = this.hopLock - 1;
  799.          this.hopSoundLock = this.hopSoundLock - 1;
  800.          if(Key.isDown(16))
  801.          {
  802.             this.hopSustain = 5;
  803.          }
  804.          if(_loc4_.wheel1.ground || _loc4_.wheel2.ground)
  805.          {
  806.             if(this.hopSustain > 0)
  807.             {
  808.                _loc41_ = com.neodelight.std.XMath.vAngle(_loc4_.wheel2.x - _loc4_.wheel1.x,_loc4_.wheel2.y - _loc4_.wheel1.y);
  809.                _loc8_ = Math.sin(_loc41_) * -10;
  810.                _loc7_ = 0;
  811.                _loc4_.wheel1.fx += _loc7_;
  812.                _loc4_.wheel1.fy += _loc8_;
  813.                _loc4_.wheel2.fx += _loc7_;
  814.                _loc4_.wheel2.fy += _loc8_;
  815.                player.ducking = 10;
  816.                if(this.hopSoundLock <= 0)
  817.                {
  818.                   if(Math.random() < 0.66)
  819.                   {
  820.                      _global.snd.playEvent("sndHep0",0.22);
  821.                   }
  822.                   else
  823.                   {
  824.                      _global.snd.playEvent("sndHep1",0.22);
  825.                   }
  826.                   this.hopSoundLock = 15;
  827.                }
  828.                this.hopLock = 5;
  829.             }
  830.          }
  831.       }
  832.       player.tilt *= 0.94;
  833.       player.ducking *= 0.9;
  834.       this.refreshMap();
  835.       this.drawMap();
  836.       if(!player.dead)
  837.       {
  838.          _loc12_ = {x:0,y:0};
  839.          _loc12_.x = _loc4_.body.a0._x;
  840.          _loc12_.y = _loc4_.body.a0._y;
  841.          _loc4_.body.localToGlobal(_loc12_);
  842.          _loc4_.anchor0.x = _loc12_.x;
  843.          _loc4_.anchor0.y = _loc12_.y;
  844.          var _loc32_ = _loc42_(player.pedalPos);
  845.          var _loc33_ = _loc34_(player.pedalPos);
  846.          _loc12_.x = _loc4_.body.a2._x + _loc32_ * 15;
  847.          _loc12_.y = _loc4_.body.a2._y - _loc33_ * 10;
  848.          _loc4_.body.localToGlobal(_loc12_);
  849.          _loc4_.anchor2.x = _loc12_.x;
  850.          _loc4_.anchor2.y = _loc12_.y;
  851.          _loc12_.x = _loc4_.body.a2b._x - _loc32_ * 15;
  852.          _loc12_.y = _loc4_.body.a2b._y + _loc33_ * 10;
  853.          _loc4_.body.localToGlobal(_loc12_);
  854.          _loc4_.anchor2b.x = _loc12_.x;
  855.          _loc4_.anchor2b.y = _loc12_.y;
  856.          _loc12_.x = _loc4_.body.a1._x;
  857.          _loc12_.y = _loc4_.body.a1._y;
  858.          _loc4_.body.localToGlobal(_loc12_);
  859.          _loc4_.anchor1.x += (_loc12_.x - _loc4_.anchor1.x) / (!_loc17_ ? 6 : 1);
  860.          _loc4_.anchor1.y += (_loc12_.y - _loc4_.anchor1.y) / (!_loc17_ ? 6 : 1);
  861.          if(player.tilt * player.dir < 0)
  862.          {
  863.             _loc12_.x = _loc4_.body.r0._x - player.tilt * 0.5 * player.dir;
  864.             _loc12_.y = _loc4_.body.r0._y - Math.abs(player.tilt) - player.ducking * 5;
  865.          }
  866.          else
  867.          {
  868.             _loc12_.x = _loc4_.body.r0._x - player.tilt;
  869.             _loc12_.y = _loc4_.body.r0._y - player.ducking * 5;
  870.          }
  871.          _loc4_.body.localToGlobal(_loc12_);
  872.          _loc4_.driver0.x += (_loc12_.x - _loc4_.driver0.x) / (!_loc17_ ? 4 : 1);
  873.          _loc4_.driver0.y += (_loc12_.y - _loc4_.driver0.y) / (!_loc17_ ? 4 : 1);
  874.          _loc12_.x = _loc4_.body.r2._x - _loc32_ * 10 + Math.max(0,player.tilt) * 0.2 * player.dir;
  875.          _loc12_.y = _loc4_.body.r2._y - _loc33_ * 10 + player.ducking * 0.3;
  876.          _loc4_.body.localToGlobal(_loc12_);
  877.          _loc4_.driver2.x += (_loc12_.x - _loc4_.driver2.x) / (!_loc17_ ? 2 : 1);
  878.          _loc4_.driver2.y += (_loc12_.y - _loc4_.driver2.y) / (!_loc17_ ? 2 : 1);
  879.          _loc12_.x = _loc4_.body.r2b._x + _loc32_ * 10;
  880.          _loc12_.y = _loc4_.body.r2b._y + _loc33_ * 10;
  881.          _loc4_.body.localToGlobal(_loc12_);
  882.          _loc4_.driver2b.x += (_loc12_.x - _loc4_.driver2b.x) / (!_loc17_ ? 2 : 1);
  883.          _loc4_.driver2b.y += (_loc12_.y - _loc4_.driver2b.y) / (!_loc17_ ? 2 : 1);
  884.       }
  885.       var _loc23_ = this.verlet;
  886.       _loc23_(_loc4_.wheel1);
  887.       _loc23_(_loc4_.wheel2);
  888.       _loc23_(_loc4_.driver0);
  889.       _loc23_(_loc4_.driver1);
  890.       _loc23_(_loc4_.driver2);
  891.       _loc23_(_loc4_.driver2b);
  892.       _loc23_(_loc4_.anchor1);
  893.       var _loc10_ = undefined;
  894.       var _loc9_ = undefined;
  895.       var _loc15_ = this.springs;
  896.       if(!player.dead)
  897.       {
  898.          _loc13_ = _loc15_.length;
  899.          while(true)
  900.          {
  901.             _loc13_;
  902.             if(!_loc13_--)
  903.             {
  904.                break;
  905.             }
  906.             _loc10_ = _loc15_[_loc13_][0];
  907.             _loc9_ = _loc15_[_loc13_][1];
  908.             _loc7_ = _loc9_.x - _loc10_.x;
  909.             _loc8_ = _loc9_.y - _loc10_.y;
  910.             _loc6_ = _loc20_(_loc7_ * _loc7_ + _loc8_ * _loc8_);
  911.             _loc6_ = (_loc6_ - this.springs[_loc13_][2]) / _loc6_;
  912.             if(_loc10_.a)
  913.             {
  914.                _loc9_.x -= _loc7_ * _loc6_;
  915.                _loc9_.y -= _loc8_ * _loc6_;
  916.             }
  917.             else if(_loc9_.a)
  918.             {
  919.                _loc10_.x += _loc7_ * _loc6_;
  920.                _loc10_.y += _loc8_ * _loc6_;
  921.             }
  922.             else
  923.             {
  924.                _loc10_.x += _loc7_ * 0.5 * _loc6_;
  925.                _loc10_.y += _loc8_ * 0.5 * _loc6_;
  926.                _loc9_.x -= _loc7_ * 0.5 * _loc6_;
  927.                _loc9_.y -= _loc8_ * 0.5 * _loc6_;
  928.             }
  929.          }
  930.       }
  931.       this.pushCount = 0;
  932.       var _loc44_ = _loc4_.wheel1.ground;
  933.       var _loc43_ = _loc4_.wheel2.ground;
  934.       this.constraints(_loc4_.wheel1,player.dir == 1);
  935.       this.constraints(_loc4_.wheel2,player.dir == -1);
  936.       if(!_loc44_ && _loc4_.wheel1.ground || !_loc43_ && _loc4_.wheel2.ground)
  937.       {
  938.          if(this.pushCount > 8)
  939.          {
  940.             _global.snd.playEvent("sndBump",(this.pushCount - 8) * 0.1);
  941.          }
  942.       }
  943.       if(!player.dead && this.constraints(_loc4_.driver0) && !_global.godMode)
  944.       {
  945.          this.death();
  946.          _global.snd.playEvent("sndDie",0.8);
  947.       }
  948.       this.cameraX += (_loc4_.wheel1.x - _loc4_.wheel1.ox + _loc4_.wheel2.x - _loc4_.wheel2.ox + player.dir * 30) * 0.5;
  949.       this.cameraY += (_loc4_.wheel1.y - _loc4_.wheel1.oy + _loc4_.wheel2.y - _loc4_.wheel2.oy) * 0.5;
  950.       this.cameraX *= 0.7;
  951.       this.cameraY *= 0.6;
  952.       var _loc29_ = int(((_loc4_.wheel1.x + _loc4_.wheel2.x) / 2 - 275 + this.cameraX) * 0.6);
  953.       var _loc28_ = int(((_loc4_.wheel1.y + _loc4_.wheel2.y) / 2 - 250 + this.cameraY) * 0.6);
  954.       _loc4_.backgroundMc._y = 335 + this.worldY * -0.3;
  955.       _loc4_.backgroundMc._x = (_loc30_ * -0.3 + 5500) % 550 - 550;
  956.       this.worldX += _loc29_;
  957.       this.worldY += _loc28_;
  958.       _loc4_.wheel1.x -= _loc29_;
  959.       _loc4_.wheel1.y -= _loc28_;
  960.       _loc4_.wheel1.ox -= _loc29_;
  961.       _loc4_.wheel1.oy -= _loc28_;
  962.       _loc4_.wheel2.x -= _loc29_;
  963.       _loc4_.wheel2.y -= _loc28_;
  964.       _loc4_.wheel2.ox -= _loc29_;
  965.       _loc4_.wheel2.oy -= _loc28_;
  966.       _loc7_ = _loc4_.wheel1.x - _loc4_.wheel1.ox;
  967.       _loc8_ = _loc4_.wheel1.y - _loc4_.wheel1.oy;
  968.       _loc21_ = _loc20_(_loc7_ * _loc7_ + _loc8_ * _loc8_);
  969.       if(_loc21_ > 25)
  970.       {
  971.          _loc21_ = 25;
  972.       }
  973.       if(_loc7_ < 0)
  974.       {
  975.          _loc21_ *= -1;
  976.       }
  977.       _loc7_ = _loc4_.wheel2.x - _loc4_.wheel2.ox;
  978.       _loc8_ = _loc4_.wheel2.y - _loc4_.wheel2.oy;
  979.       _loc18_ = _loc20_(_loc7_ * _loc7_ + _loc8_ * _loc8_);
  980.       if(_loc18_ > 25)
  981.       {
  982.          _loc18_ = 25;
  983.       }
  984.       if(_loc7_ < 0)
  985.       {
  986.          _loc18_ *= -1;
  987.       }
  988.       _loc4_.wheel1._x = _loc4_.wheel1.x;
  989.       _loc4_.wheel1._y = _loc4_.wheel1.y;
  990.       var _loc36_ = undefined;
  991.       if(player.dir == 1)
  992.       {
  993.          _loc21_ = (1 - _loc31_.ice) * _loc21_ + _loc31_.ice * (player.vel * 2.7 + _loc21_ * 0.4);
  994.          _loc36_ = _loc21_ * _loc16_ * player.dir;
  995.       }
  996.       else
  997.       {
  998.          _loc18_ = (1 - _loc31_.ice) * _loc18_ + _loc31_.ice * (- (player.vel <= 0 ? Math.min(player.vel * 2.5,_loc18_) : Math.max(player.vel * 2.5,_loc18_)));
  999.          _loc36_ = _loc18_ * _loc16_ * player.dir;
  1000.       }
  1001.       player.pedalPos += _loc36_;
  1002.       if(!player.dead)
  1003.       {
  1004.          this.sndDrive.fade(Math.pow(_loc36_,2) * 2.8,5);
  1005.       }
  1006.       _loc4_.wheel1._rotation += _loc21_;
  1007.       _loc4_.wheel2._x = _loc4_.wheel2.x;
  1008.       _loc4_.wheel2._y = _loc4_.wheel2.y;
  1009.       _loc4_.wheel2._rotation += _loc18_;
  1010.       if(player.dead)
  1011.       {
  1012.          if(!player.deathCount--)
  1013.          {
  1014.             this.fx.fadeTo(com.neodelight.std.ColorFader.FX_NONE,0);
  1015.             this.quit(false,"col");
  1016.          }
  1017.          _loc4_.body.vy += 1.2;
  1018.          _loc4_.body._y += _loc4_.body.vy;
  1019.          _loc4_.body._rotation += _loc4_.body.vr;
  1020.       }
  1021.       else
  1022.       {
  1023.          _loc4_.body._x = (_loc4_.wheel1.x + _loc4_.wheel2.x) / 2;
  1024.          _loc4_.body._y = (_loc4_.wheel1.y + _loc4_.wheel2.y) / 2;
  1025.          _loc4_.body._rotation = _loc19_(_loc4_.wheel2.y - _loc4_.wheel1.y,_loc4_.wheel2.x - _loc4_.wheel1.x) / _loc16_;
  1026.       }
  1027.       this.fx.step();
  1028.       _loc4_.driver.torso._x = (_loc4_.anchor1.x + _loc4_.driver0.x) / 2;
  1029.       _loc4_.driver.torso._y = (_loc4_.anchor1.y + _loc4_.driver0.y) / 2;
  1030.       _loc4_.driver.torso._rotation = _loc19_(_loc4_.driver0.y - _loc4_.anchor1.y,_loc4_.driver0.x - _loc4_.anchor1.x) / _loc16_;
  1031.       _loc4_.driver.arm1._x = (_loc4_.driver1.x + _loc4_.anchor0.x) / 2;
  1032.       _loc4_.driver.arm1._y = (_loc4_.driver1.y + _loc4_.anchor0.y) / 2;
  1033.       _loc4_.driver.arm1._rotation = _loc19_(_loc4_.anchor0.y - _loc4_.driver1.y,_loc4_.anchor0.x - _loc4_.driver1.x) / _loc16_;
  1034.       _loc4_.driver.arm2._x = (_loc4_.driver0.x + _loc4_.driver1.x) / 2;
  1035.       _loc4_.driver.arm2._y = (_loc4_.driver0.y + _loc4_.driver1.y) / 2;
  1036.       _loc4_.driver.arm2._rotation = _loc19_(_loc4_.driver1.y - _loc4_.driver0.y,_loc4_.driver1.x - _loc4_.driver0.x) / _loc16_;
  1037.       _loc4_.driver.leg1._x = (_loc4_.anchor2.x + _loc4_.driver2.x) / 2;
  1038.       _loc4_.driver.leg1._y = (_loc4_.anchor2.y + _loc4_.driver2.y) / 2;
  1039.       _loc4_.driver.leg1._rotation = _loc19_(_loc4_.anchor2.y - _loc4_.driver2.y,_loc4_.anchor2.x - _loc4_.driver2.x) / _loc16_;
  1040.       _loc4_.driver.leg2._x = (_loc4_.driver2.x + _loc4_.anchor1.x) / 2;
  1041.       _loc4_.driver.leg2._y = (_loc4_.driver2.y + _loc4_.anchor1.y) / 2;
  1042.       _loc4_.driver.leg2._rotation = _loc19_(_loc4_.driver2.y - _loc4_.anchor1.y,_loc4_.driver2.x - _loc4_.anchor1.x) / _loc16_;
  1043.       _loc4_.leg1b._x = (_loc4_.anchor2b.x + _loc4_.driver2b.x) / 2;
  1044.       _loc4_.leg1b._y = (_loc4_.anchor2b.y + _loc4_.driver2b.y) / 2;
  1045.       _loc4_.leg1b._rotation = _loc19_(_loc4_.anchor2b.y - _loc4_.driver2b.y,_loc4_.anchor2b.x - _loc4_.driver2b.x) / _loc16_;
  1046.       _loc4_.leg2b._x = (_loc4_.driver2b.x + _loc4_.anchor1.x) / 2;
  1047.       _loc4_.leg2b._y = (_loc4_.driver2b.y + _loc4_.anchor1.y) / 2;
  1048.       _loc4_.leg2b._rotation = _loc19_(_loc4_.driver2b.y - _loc4_.anchor1.y,_loc4_.driver2b.x - _loc4_.anchor1.x) / _loc16_;
  1049.       _loc4_.body.pedalFront._rotation = player.pedalPos / _loc16_;
  1050.       _loc4_.body.pedalFront.pedal._rotation = - _loc4_.body.pedalFront._rotation;
  1051.       _loc4_.body.pedalBack._rotation = player.pedalPos / _loc16_ + 180;
  1052.       _loc4_.body.pedalBack.pedal._rotation = - _loc4_.body.pedalBack._rotation;
  1053.       _loc4_.driver._visible = true;
  1054.    }
  1055.    function death()
  1056.    {
  1057.       _root.attachMovie("ouch","ouch",_root.getNextHighestDepth());
  1058.       this.freeze = 10;
  1059.       this.player.dead = 1;
  1060.       this.sndDrive.fade(0,10);
  1061.       this.player.deathCount = 45;
  1062.       this.player.vel = 0;
  1063.       this.mc.body.vy = 0;
  1064.       this.mc.body.vr = (Math.random() - 0.5) * 10;
  1065.    }
  1066. }
  1067.