home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Diversos / sheriff_tripeaks.swf / scripts / __Packages / Game.as next >
Encoding:
Text File  |  2006-06-13  |  22.6 KB  |  751 lines

  1. class Game
  2. {
  3.    static var snapNums;
  4.    static var playStartTime;
  5.    static var timeDisp;
  6.    static var is_paused;
  7.    static var pan;
  8.    static var msgPan;
  9.    static var timeLeft;
  10.    static var txtScore;
  11.    static var btnReturn;
  12.    static var pause_clip;
  13.    static var btnUndo;
  14.    static var playFinished;
  15.    static var toppest2Num;
  16.    static var playStarted;
  17.    static var playTime;
  18.    static var rndPlayTime;
  19.    static var toppest;
  20.    static var toppest2;
  21.    static var timeSetNum;
  22.    static var deletedAll;
  23.    static var noMoreMove;
  24.    static var bar;
  25.    static var strPlayTime;
  26.    static var txtTime;
  27.    static var currentDepth;
  28.    static var prvToppest;
  29.    static var undosLeft = 0;
  30.    static var tmpPoint = new Object();
  31.    static var state = 0;
  32.    static var score = 0;
  33.    static var lastMove = -1;
  34.    static var lastScore = 0;
  35.    function Game()
  36.    {
  37.    }
  38.    static function startIt()
  39.    {
  40.       Game.undosLeft = 3;
  41.       _root.undosLeftString = "x" + String(Game.undosLeft);
  42.       var _loc1_ = undefined;
  43.       _loc1_ = 0;
  44.       while(_loc1_ < 52)
  45.       {
  46.          Game.snapNums[_loc1_] = -1;
  47.          _loc1_ = _loc1_ + 1;
  48.       }
  49.       _loc1_ = 0;
  50.       while(_loc1_ < 52)
  51.       {
  52.          while(Game.snapNums[index] < 0)
  53.          {
  54.             var index = Math.floor(Math.random() * 52);
  55.             if(Game.snapNums[index] < 0)
  56.             {
  57.                Game.snapNums[index] = _loc1_;
  58.             }
  59.          }
  60.          _loc1_ = _loc1_ + 1;
  61.       }
  62.       if(SharedVals.playLevel == -1)
  63.       {
  64.          SharedVals.playLevel = Math.min(Settings.lastLevel + 1,Settings.levels.length);
  65.       }
  66.       if(true || SharedVals.playLevel <= Settings.lastLevel + 1)
  67.       {
  68.          Game.setLevel(Settings.levels[SharedVals.playLevel - 1]);
  69.       }
  70.       else
  71.       {
  72.          Game.delPrvLevel();
  73.          _root.gotoAndPlay("preLevelsFrame");
  74.       }
  75.    }
  76.    static function PauseOff()
  77.    {
  78.       Game.playStartTime = getTimer() - Game.timeDisp;
  79.       Game.is_paused = false;
  80.    }
  81.    static function activate()
  82.    {
  83.       SharedVals.snapShot = false;
  84.       SharedVals.panel = Game.pan;
  85.       Game.msgPan._visible = false;
  86.       Game.timeLeft = 300;
  87.       Game.txtScore.text = "0";
  88.       Game.is_paused = true;
  89.       Game.btnReturn.onPress = function()
  90.       {
  91.          if(!Game.is_paused)
  92.          {
  93.             Game.is_paused = true;
  94.             Game.pause_clip = _root.attachMovie("pause_clip","pc",100000);
  95.             Game.pause_clip._x = 275;
  96.             Game.pause_clip._y = 200;
  97.          }
  98.       };
  99.       Game.btnUndo.onPress = function()
  100.       {
  101.          if(Game.playFinished)
  102.          {
  103.             return undefined;
  104.          }
  105.          Game.undo();
  106.       };
  107.    }
  108.    static function TipsControl()
  109.    {
  110.       if(_root.show_tips)
  111.       {
  112.          Game.is_paused = true;
  113.          _root.attachMovie("window_tip","window_tip",100000);
  114.       }
  115.       else
  116.       {
  117.          Game.is_paused = false;
  118.       }
  119.    }
  120.    static function enableAll(e)
  121.    {
  122.       var _loc3_ = e;
  123.       var _loc2_ = undefined;
  124.       var _loc1_ = undefined;
  125.       _loc2_ = 0;
  126.       while(_loc2_ < 52)
  127.       {
  128.          _loc1_ = SharedVals.panel["rect" + String(_loc2_)];
  129.          if(_loc1_.exist && _loc1_.isShowing || Game.toppest2Num == _loc2_)
  130.          {
  131.             _loc1_.useHandCursor = _loc3_;
  132.          }
  133.          else
  134.          {
  135.             _loc1_.useHandCursor = false;
  136.          }
  137.          _loc2_ = _loc2_ + 1;
  138.       }
  139.       Game.btnUndo.useHandCursor = _loc3_ && Game.lastMove != -1;
  140.       Game.btnReturn.useHandCursor = _loc3_;
  141.    }
  142.    static function loadFromStr(s12)
  143.    {
  144.       var s1;
  145.       var s2;
  146.       var _loc3_ = new String("");
  147.       var _loc2_ = undefined;
  148.       var _loc1_ = undefined;
  149.       _loc3_ = s12;
  150.       _loc2_ = _loc3_.indexOf(">",0);
  151.       s1 = _loc3_.slice(0,_loc2_);
  152.       s2 = _loc3_.slice(_loc2_ + 1,_loc3_.length);
  153.       _loc2_ = -1;
  154.       _loc3_ = s2;
  155.       _loc1_ = _loc3_.indexOf(";",0);
  156.       if(_loc1_ >= 0)
  157.       {
  158.          do
  159.          {
  160.             Game.loadOneFromStr(_loc3_.substring(_loc2_ + 1,_loc1_));
  161.             _loc2_ = _loc1_;
  162.             _loc1_ = _loc3_.indexOf(";",_loc2_ + 1);
  163.          }
  164.          while(_loc1_ >= 0);
  165.          
  166.       }
  167.    }
  168.    static function loadOneFromStr(t)
  169.    {
  170.       var _loc2_ = new String(t);
  171.       var _loc3_ = undefined;
  172.       var k2;
  173.       var k3;
  174.       var k4;
  175.       var k5;
  176.       var s1;
  177.       var s2;
  178.       var s3;
  179.       var s4;
  180.       var s5;
  181.       var _loc1_ = undefined;
  182.       _loc3_ = _loc2_.indexOf(",",0);
  183.       if(_loc3_ >= 0)
  184.       {
  185.          k2 = _loc2_.indexOf(",",_loc3_ + 1);
  186.          if(k2 >= 0)
  187.          {
  188.             k3 = _loc2_.indexOf(",",k2 + 1);
  189.             if(k3 >= 0)
  190.             {
  191.                k4 = _loc2_.indexOf(",",k3 + 1);
  192.                if(k4 >= 0)
  193.                {
  194.                   k5 = _loc2_.indexOf(",",k4 + 1);
  195.                   if(k5 >= 0)
  196.                   {
  197.                      s1 = _loc2_.substring(0,_loc3_);
  198.                      s2 = _loc2_.substring(_loc3_ + 1,k2);
  199.                      s3 = _loc2_.substring(k2 + 1,k3);
  200.                      s4 = _loc2_.substring(k3 + 1,k4);
  201.                      s5 = _loc2_.substring(k4 + 1,k5);
  202.                      if(!isNaN(s1))
  203.                      {
  204.                         if(!isNaN(s2))
  205.                         {
  206.                            if(!isNaN(s3))
  207.                            {
  208.                               if(!isNaN(s4))
  209.                               {
  210.                                  if(!isNaN(s5))
  211.                                  {
  212.                                     SharedVals.panel.readyNum = SharedVals.panel.readyNum + 1;
  213.                                     _loc1_ = SharedVals.panel["rect" + String(SharedVals.panel.readyNum)];
  214.                                     _loc1_._x = Number(s1);
  215.                                     _loc1_._y = Number(s2);
  216.                                     _loc1_._rotation = Number(s3);
  217.                                     _loc1_.rVal = Number(s4);
  218.                                     _loc1_.depth = _loc1_.rVal;
  219.                                     _loc1_.swapDepths(_loc1_.depth);
  220.                                     if(SharedVals.snapShot)
  221.                                     {
  222.                                        _loc1_.makeIt = Number(s5) == 1;
  223.                                     }
  224.                                     else
  225.                                     {
  226.                                        _loc1_.makeIt = true;
  227.                                     }
  228.                                     _loc1_._visible = true;
  229.                                     _loc1_.exist = true;
  230.                                  }
  231.                               }
  232.                            }
  233.                         }
  234.                      }
  235.                   }
  236.                }
  237.             }
  238.          }
  239.       }
  240.    }
  241.    static function delPrvLevel()
  242.    {
  243.       var k;
  244.       var b;
  245.       var mc;
  246.       Game.playStarted = false;
  247.       Game.playFinished = false;
  248.       Game.playTime = 0;
  249.       Game.rndPlayTime = 0;
  250.       Game.playStartTime = 0;
  251.    }
  252.    static function setLevel(s)
  253.    {
  254.       var k;
  255.       var mc;
  256.       Game.delPrvLevel();
  257.       Game.reSet();
  258.       Game.loadFromStr(s);
  259.       Game.giveNumbers();
  260.       Game.toppest = SharedVals.panel["rect" + String(SharedVals.panel.readyNum + 1)];
  261.       if(SharedVals.panel.readyNum + 2 < 52)
  262.       {
  263.          Game.toppest2Num = SharedVals.panel.readyNum + 2;
  264.          Game.toppest2 = SharedVals.panel["rect" + String(Game.toppest2Num)];
  265.          _root.readyTxt = String(52 - Game.toppest2Num);
  266.       }
  267.       else
  268.       {
  269.          Game.toppest2Num = -1;
  270.          _root.readyTxt = "";
  271.       }
  272.       if(SharedVals.snapShot)
  273.       {
  274.          Game.toppest.makeNumber();
  275.       }
  276.       Game.toppest.showMe(true);
  277.       Game.toppest._x = SharedVals.panel.place2._x;
  278.       Game.toppest._y = SharedVals.panel.place2._y;
  279.       Game.playStarted = true;
  280.       Game.playStartTime = getTimer();
  281.    }
  282.    static function setOvers()
  283.    {
  284.       var k;
  285.       var k2;
  286.       var _loc3_ = undefined;
  287.       var _loc2_ = undefined;
  288.       var mc2;
  289.       var pmc;
  290.       var _loc1_ = new Object();
  291.       var fnd;
  292.       k = 0;
  293.       while(k < 52)
  294.       {
  295.          _loc2_ = SharedVals.panel["rect" + String(k)];
  296.          _loc2_.overs.splice(0);
  297.          if(_loc2_.exist)
  298.          {
  299.             k2 = 0;
  300.             while(k2 < 52)
  301.             {
  302.                mc2 = SharedVals.panel["rect" + String(k2)];
  303.                if(mc2.exist && mc2.depth > _loc2_.depth)
  304.                {
  305.                   fnd = false;
  306.                   _loc3_ = 0;
  307.                   while(_loc3_ <= 11)
  308.                   {
  309.                      pmc = _root.rect["pin" + String(_loc3_)];
  310.                      _loc1_.x = pmc._x;
  311.                      _loc1_.y = pmc._y;
  312.                      _loc2_.localToGlobal(_loc1_);
  313.                      if(mc2.hitTest(_loc1_.x,_loc1_.y,true))
  314.                      {
  315.                         fnd = true;
  316.                      }
  317.                      _loc3_ = _loc3_ + 1;
  318.                   }
  319.                   if(fnd)
  320.                   {
  321.                      _loc2_.overs.push(k2);
  322.                   }
  323.                }
  324.                k2++;
  325.             }
  326.          }
  327.          else
  328.          {
  329.             _loc2_.depth = 1000 - k;
  330.             _loc2_.swapDepths(_loc2_.depth);
  331.          }
  332.          k++;
  333.       }
  334.    }
  335.    static function reSet()
  336.    {
  337.       var k;
  338.       Game.state = 0;
  339.       Game.timeSetNum = 0;
  340.       SharedVals.frameNum = 0;
  341.       Game.playStarted = false;
  342.       Game.playFinished = false;
  343.       Game.playTime = 0;
  344.       Game.rndPlayTime = 0;
  345.       Game.playStartTime = 0;
  346.       Game.score = 0;
  347.       Game.deletedAll = false;
  348.       Game.noMoreMove = false;
  349.       Game.toppest2Num = -1;
  350.       Game.msgPan._visible = false;
  351.       SharedVals.panel.reset();
  352.       Game.lastMove = -1;
  353.       Game.btnUndo._alpha = 20;
  354.       Game.btnUndo.useHandCursor = false;
  355.       Game.bar.setVal(0);
  356.    }
  357.    static function setTime()
  358.    {
  359.       var tc;
  360.       var t0;
  361.       var _loc3_ = undefined;
  362.       var t2;
  363.       var ts0;
  364.       var _loc2_ = undefined;
  365.       var _loc1_ = undefined;
  366.       Game.playTime = Game.timeLeft - (getTimer() - Game.playStartTime) / 1000;
  367.       if(Math.floor(Game.playTime) == -1)
  368.       {
  369.          Game.playerLoosed(true);
  370.       }
  371.       if(Math.round(Game.playTime) != Game.rndPlayTime)
  372.       {
  373.          Game.rndPlayTime = int(Game.playTime);
  374.          t0 = int(Game.rndPlayTime / 3600);
  375.          ts0 = String(t0);
  376.          if(t0 < 10)
  377.          {
  378.             ts0 = "0" + ts0;
  379.          }
  380.          _loc3_ = int((Game.rndPlayTime - t0 * 60) / 60);
  381.          if(_loc3_ == 60)
  382.          {
  383.             _loc3_ = 0;
  384.          }
  385.          _loc2_ = String(_loc3_);
  386.          if(_loc3_ < 10)
  387.          {
  388.             _loc2_ = "0" + _loc2_;
  389.          }
  390.          t2 = Game.rndPlayTime % 60;
  391.          _loc1_ = String(t2);
  392.          if(t2 < 10)
  393.          {
  394.             _loc1_ = "0" + _loc1_;
  395.          }
  396.          if(t0 == 0)
  397.          {
  398.             Game.strPlayTime = _loc2_ + ":" + _loc1_;
  399.          }
  400.          else
  401.          {
  402.             Game.strPlayTime = ts0 + ":" + _loc2_ + ":" + _loc1_;
  403.          }
  404.          _root.playTimeText = String(Game.strPlayTime);
  405.          Game.txtTime.text = String(Game.strPlayTime);
  406.       }
  407.    }
  408.    static function doFrame()
  409.    {
  410.       if(!Game.is_paused)
  411.       {
  412.          Game.timeDisp = getTimer() - Game.playStartTime;
  413.          if(Game.playFinished)
  414.          {
  415.             return undefined;
  416.          }
  417.          if(Game.playStarted)
  418.          {
  419.             SharedVals.frameNum = SharedVals.frameNum + 1;
  420.             Game.setTime();
  421.          }
  422.          if(Game.state == 1)
  423.          {
  424.             Game.toppest.frames--;
  425.             if(Game.toppest.frames == 0)
  426.             {
  427.                Game.toppest.swapDepths(Game.currentDepth);
  428.                Game.state = 0;
  429.                Game.toppest.frames = -1;
  430.                Game.toppest.exist = false;
  431.                Game.toppest.showMe(true);
  432.                Game.toppest._x = Game.pan.place2._x;
  433.                Game.toppest._y = Game.pan.place2._y;
  434.                Game.toppest._rotation = 0;
  435.                if(Game.deletedAll)
  436.                {
  437.                   Game.playerWinned();
  438.                   return undefined;
  439.                }
  440.                if(Game.noMoreMove)
  441.                {
  442.                   Game.playerLoosed(false);
  443.                   return undefined;
  444.                }
  445.             }
  446.             else
  447.             {
  448.                Game.toppest._x += Game.toppest.dX;
  449.                Game.toppest._y += Game.toppest.dY;
  450.                Game.toppest._rotation += Game.toppest.dR;
  451.             }
  452.          }
  453.          Game.bar.addVal(-0.2);
  454.          Game.bar.refreshMe();
  455.       }
  456.    }
  457.    static function testAfterDelete()
  458.    {
  459.       var _loc2_ = undefined;
  460.       var _loc3_ = undefined;
  461.       var k3;
  462.       var v;
  463.       var _loc1_ = undefined;
  464.       var mc2;
  465.       var pmc;
  466.       var p = new Object();
  467.       var fnd;
  468.       var fnd2;
  469.       fnd = false;
  470.       _loc2_ = 0;
  471.       while(_loc2_ < 52)
  472.       {
  473.          _loc1_ = SharedVals.panel["rect" + String(_loc2_)];
  474.          if(_loc1_.exist)
  475.          {
  476.             fnd = true;
  477.             fnd2 = false;
  478.             _loc3_ = 0;
  479.             while(_loc3_ < _loc1_.overs.length)
  480.             {
  481.                mc2 = SharedVals.panel["rect" + String(_loc1_.overs[_loc3_])];
  482.                if(mc2.exist)
  483.                {
  484.                   fnd2 = true;
  485.                }
  486.                _loc3_ = _loc3_ + 1;
  487.             }
  488.             _loc1_.showMe(!fnd2);
  489.          }
  490.          _loc2_ = _loc2_ + 1;
  491.       }
  492.       Game.deletedAll = !fnd;
  493.       if(!Game.deletedAll)
  494.       {
  495.          if(Game.toppest2Num == -1)
  496.          {
  497.             fnd = false;
  498.             _loc2_ = 0;
  499.             while(_loc2_ < 52)
  500.             {
  501.                _loc1_ = SharedVals.panel["rect" + String(_loc2_)];
  502.                if(_loc1_.exist && _loc1_.isShowing)
  503.                {
  504.                   v = Math.abs(_loc1_.card_number - Game.toppest.card_number);
  505.                   if(v == 1 || v == 12)
  506.                   {
  507.                      fnd = true;
  508.                   }
  509.                }
  510.                _loc2_ = _loc2_ + 1;
  511.             }
  512.             if(!fnd)
  513.             {
  514.                Game.noMoreMove = true;
  515.             }
  516.          }
  517.       }
  518.    }
  519.    static function setScore(s)
  520.    {
  521.       _root.points_sfx.start(0,1);
  522.       Game.score += s;
  523.       _root.scoreText = String(Game.score);
  524.       Game.txtScore.text = String(Game.score);
  525.    }
  526.    static function playerLoosed(is_time_out)
  527.    {
  528.       Game.pan._x = Game.pan.x0;
  529.       Game.pan._y = Game.pan.y0;
  530.       Game.msgPan.showForLoose(is_time_out);
  531.       Game.enableAll(false);
  532.       Game.playFinished = true;
  533.    }
  534.    static function playerWinned()
  535.    {
  536.       Game.pan._x = Game.pan.x0;
  537.       Game.pan._y = Game.pan.y0;
  538.       Settings.setLastLevel(SharedVals.playLevel,Game.score);
  539.       Game.msgPan.showForWin(Game.score,SharedVals.playLevel != Settings.levels.length);
  540.       Game.enableAll(false);
  541.       Game.playFinished = true;
  542.    }
  543.    static function giveNumbers()
  544.    {
  545.       if(_root._currentframe > 21)
  546.       {
  547.          var _loc1_ = undefined;
  548.          var mc;
  549.          var _loc2_ = new Array();
  550.          var tempArray_2 = new Array();
  551.          _loc1_ = 0;
  552.          while(_loc1_ < 52)
  553.          {
  554.             _loc2_.push(-1);
  555.             tempArray_2.push(0);
  556.             _loc1_ = _loc1_ + 1;
  557.          }
  558.          _loc1_ = 0;
  559.          while(_loc1_ < 52)
  560.          {
  561.             var _loc3_ = Math.floor(Math.random() * 52);
  562.             if(_loc2_[_loc3_] < 0)
  563.             {
  564.                _loc2_[_loc3_] = _loc1_;
  565.             }
  566.             else
  567.             {
  568.                _loc1_ -= 1;
  569.             }
  570.             _loc1_ = _loc1_ + 1;
  571.          }
  572.          _loc1_ = 0;
  573.          while(_loc1_ < 52)
  574.          {
  575.             var flag = false;
  576.             do
  577.             {
  578.                _loc3_ = Math.floor(Math.random() * _loc2_.length);
  579.                var card_num = _loc2_[_loc3_];
  580.                var current_card = card_num % 13;
  581.                var previous_card = tempArray_2[_loc1_ - 1] % 13;
  582.                if(_loc1_ < 50)
  583.                {
  584.                   if(current_card != previous_card)
  585.                   {
  586.                      tempArray_2[_loc1_] = card_num;
  587.                      _loc2_.splice(_loc3_,1);
  588.                      flag = true;
  589.                   }
  590.                }
  591.                else
  592.                {
  593.                   tempArray_2[_loc1_] = card_num;
  594.                   _loc2_.splice(_loc3_,1);
  595.                   flag = true;
  596.                }
  597.             }
  598.             while(!flag);
  599.             
  600.             _loc1_ = _loc1_ + 1;
  601.          }
  602.          _loc1_ = 0;
  603.          while(_loc1_ < 52)
  604.          {
  605.             mc = SharedVals.panel["rect" + String(_loc1_)];
  606.             mc.setNumber(tempArray_2[_loc1_]);
  607.             mc.makeNumber();
  608.             _loc1_ = _loc1_ + 1;
  609.          }
  610.       }
  611.    }
  612.    static function undo()
  613.    {
  614.       var _loc1_ = _root;
  615.       if(!Game.playFinished)
  616.       {
  617.          if(Game.lastMove != -1)
  618.          {
  619.             if(Game.lastMove == 1)
  620.             {
  621.                Game.toppest._x = Game.toppest.prvX;
  622.                Game.toppest._y = Game.toppest.prvY;
  623.                Game.toppest._rotation = Game.toppest.prvRotation;
  624.                Game.toppest.depth = Game.toppest.prvDepth;
  625.                Game.toppest.swapDepths(Game.toppest.depth);
  626.                Game.toppest.exist = true;
  627.                Game.toppest = Game.prvToppest;
  628.                Game.bar.addVal(-20);
  629.                Game.setScore(- Game.lastScore);
  630.                Game.enableAll(true);
  631.             }
  632.             if(Game.lastMove == 2)
  633.             {
  634.                SharedVals.panel.readyNum--;
  635.                Game.toppest2Num = SharedVals.panel.readyNum + 2;
  636.                Game.toppest2 = SharedVals.panel["rect" + String(Game.toppest2Num)];
  637.                _loc1_.readyTxt = String(52 - Game.toppest2Num);
  638.                Game.toppest._x = Game.toppest.prvX;
  639.                Game.toppest._y = Game.toppest.prvY;
  640.                Game.toppest._rotation = Game.toppest.prvRotation;
  641.                Game.toppest.depth = Game.toppest.prvDepth;
  642.                Game.toppest.swapDepths(Game.toppest.depth);
  643.                Game.toppest.showMe(false);
  644.                Game.toppest = Game.prvToppest;
  645.                Game.enableAll(true);
  646.             }
  647.             _loc1_.undo_sfx.start(0,1);
  648.             Game.testAfterDelete();
  649.             Game.lastMove = -1;
  650.             Game.undosLeft -= 1;
  651.             _loc1_.undosLeftString = "x" + String(Game.undosLeft);
  652.             if(Game.undosLeft == 0)
  653.             {
  654.                Game.btnUndo._visible = false;
  655.                Game.btnUndo._x = -100;
  656.             }
  657.             else
  658.             {
  659.                Game.btnUndo._alpha = 20;
  660.                Game.btnUndo.useHandCursor = false;
  661.                Game.bar.setVal(0);
  662.             }
  663.          }
  664.       }
  665.    }
  666.    static function pressed(mc)
  667.    {
  668.       var _loc1_ = mc;
  669.       var _loc3_ = _root;
  670.       if(!Game.is_paused)
  671.       {
  672.          if(!Game.playFinished)
  673.          {
  674.             if(Game.state == 0)
  675.             {
  676.                if(_loc1_.exist && _loc1_.isShowing)
  677.                {
  678.                   var _loc2_ = Math.abs(Game.toppest.card_number - _loc1_.card_number);
  679.                   if(_loc2_ == 1 || _loc2_ == 12)
  680.                   {
  681.                      Game.state = 1;
  682.                      _loc1_.frames = 6;
  683.                      _loc1_.prvX = _loc1_._x;
  684.                      _loc1_.prvY = _loc1_._y;
  685.                      _loc1_.prvRotation = _loc1_._rotation;
  686.                      _loc1_.prvDepth = _loc1_.depth;
  687.                      _loc1_.dX = (Game.pan.place2._x - _loc1_._x) / _loc1_.frames;
  688.                      _loc1_.dY = (Game.pan.place2._y - _loc1_._y) / _loc1_.frames;
  689.                      _loc1_.dR = (- _loc1_._rotation) / _loc1_.frames;
  690.                      _loc1_.exist = false;
  691.                      _loc1_.depth = Game.toppest.depth + 10060;
  692.                      _loc1_.swapDepths(_loc1_.depth);
  693.                      Game.prvToppest = Game.toppest;
  694.                      Game.toppest = _loc1_;
  695.                      Game.lastMove = 1;
  696.                      Game.btnUndo._alpha = 100;
  697.                      Game.btnUndo.useHandCursor = true;
  698.                      Game.testAfterDelete();
  699.                      Game.bar.addVal(20);
  700.                      Game.lastScore = 20 + Game.bar.rndVal;
  701.                      Game.setScore(Game.lastScore);
  702.                      Game.enableAll(true);
  703.                   }
  704.                   else
  705.                   {
  706.                      _loc3_.wrong_card_sfx.start(0,1);
  707.                   }
  708.                }
  709.                else if(Game.toppest2Num != -1)
  710.                {
  711.                   if(_loc1_.bigNumber == Game.toppest2.bigNumber)
  712.                   {
  713.                      _loc3_.set_sfx.start(0,1);
  714.                      _loc1_.depth = Game.toppest.depth + 1;
  715.                      _loc1_.swapDepths(_loc1_.depth);
  716.                      _loc1_.prvX = _loc1_._x;
  717.                      _loc1_.prvY = _loc1_._y;
  718.                      _loc1_.prvRotation = _loc1_._rotation;
  719.                      _loc1_.prvDepth = _loc1_.depth;
  720.                      Game.prvToppest = Game.toppest;
  721.                      Game.toppest = _loc1_;
  722.                      Game.lastMove = 2;
  723.                      Game.btnUndo._alpha = 100;
  724.                      Game.btnUndo.useHandCursor = true;
  725.                      SharedVals.panel.readyNum = SharedVals.panel.readyNum + 1;
  726.                      if(SharedVals.panel.readyNum + 2 < 52)
  727.                      {
  728.                         Game.toppest2Num = SharedVals.panel.readyNum + 2;
  729.                         Game.toppest2 = SharedVals.panel["rect" + String(Game.toppest2Num)];
  730.                         _loc3_.readyTxt = String(52 - Game.toppest2Num);
  731.                      }
  732.                      else
  733.                      {
  734.                         Game.toppest2Num = -1;
  735.                         _loc3_.readyTxt = "";
  736.                      }
  737.                      Game.state = 1;
  738.                      _loc1_.frames = 2;
  739.                      _loc1_.dX = (Game.pan.place2._x - _loc1_._x) / _loc1_.frames;
  740.                      _loc1_.dY = (Game.pan.place2._y - _loc1_._y) / _loc1_.frames;
  741.                      _loc1_.dR = (- _loc1_._rotation) / _loc1_.frames;
  742.                      Game.testAfterDelete();
  743.                      Game.enableAll(true);
  744.                   }
  745.                }
  746.             }
  747.          }
  748.       }
  749.    }
  750. }
  751.