home *** CD-ROM | disk | FTP | other *** search
/ 600 Games / 600games.iso / Puzzle / 3lines.swf / scripts / DefineSprite_144 / frame_2 / DoAction.as
Encoding:
Text File  |  2005-10-06  |  11.6 KB  |  487 lines
  1. function on_over(pn)
  2. {
  3.    if(selected_pn < 0)
  4.    {
  5.       draw_curs(pn);
  6.       draw_line(pn);
  7.    }
  8. }
  9. function on_click(click_pn)
  10. {
  11.    if(selected_pn < 0)
  12.    {
  13.       first_click(click_pn);
  14.       _parent.sndClick.start();
  15.    }
  16.    else if(pair_pai[click_pn] == 1)
  17.    {
  18.       his_pat[his_c] = pat[click_pn];
  19.       his_pn1[his_c] = click_pn;
  20.       his_pn2[his_c] = selected_pn;
  21.       his_c++;
  22.       pat[selected_pn] = 0;
  23.       var mc = eval("mcPiece" + selected_pn);
  24.       mc.gotoAndStop(35);
  25.       pat[click_pn] = 0;
  26.       mcSmoke0._x = mc._x;
  27.       mcSmoke0._y = mc._y;
  28.       mcSmoke0.gotoAndPlay(2);
  29.       mc = eval("mcPiece" + click_pn);
  30.       mc.gotoAndStop(35);
  31.       mcSmoke1._x = mc._x;
  32.       mcSmoke1._y = mc._y;
  33.       mcSmoke1.gotoAndPlay(2);
  34.       _parent.sndErase.start();
  35.       selected_pn = -1;
  36.       mcLine.clear();
  37.       draw_curs(click_pn);
  38.       if(his_c * 2 >= pai_max)
  39.       {
  40.          gotoAndStop("clear");
  41.       }
  42.    }
  43.    else
  44.    {
  45.       _parent.sndClick.start();
  46.       selected_pn = -1;
  47.       if(pair_pai[click_pn] == 0)
  48.       {
  49.          draw_curs(click_pn);
  50.          draw_line(click_pn);
  51.          first_click(click_pn);
  52.       }
  53.       else
  54.       {
  55.          draw_curs(click_pn);
  56.          draw_line(click_pn);
  57.       }
  58.    }
  59. }
  60. function first_click(click_pn)
  61. {
  62.    if(pair_pai[click_pn] == 2)
  63.    {
  64.       var i = 0;
  65.       while(i < 4)
  66.       {
  67.          if(curs_pai[i] == click_pn)
  68.          {
  69.             mc = eval("mcCurs" + i);
  70.             mc.gotoAndStop(2);
  71.          }
  72.          i++;
  73.       }
  74.       selected_pn = click_pn;
  75.    }
  76. }
  77. function draw_curs(pn)
  78. {
  79.    var i;
  80.    var c = 0;
  81.    i = 0;
  82.    while(i < 4)
  83.    {
  84.       curs_pai[i] = -1;
  85.       i++;
  86.    }
  87.    if(pat[pn] > 0)
  88.    {
  89.       i = 0;
  90.       while(i < pai_max)
  91.       {
  92.          if(pat[i] == pat[pn])
  93.          {
  94.             curs_pai[c] = i;
  95.             c++;
  96.          }
  97.          i++;
  98.       }
  99.    }
  100.    i = 0;
  101.    while(i < 4)
  102.    {
  103.       var mc = eval("mcCurs" + i);
  104.       var n = curs_pai[i];
  105.       if(n < 0)
  106.       {
  107.          mc._visible = false;
  108.       }
  109.       else
  110.       {
  111.          mc._visible = true;
  112.          mc.gotoAndStop(1);
  113.          var mcPai = eval("mcPiece" + n);
  114.          mc._x = mcPai._x;
  115.          mc._y = mcPai._y;
  116.       }
  117.       i++;
  118.    }
  119. }
  120. function draw_line(click_pn)
  121. {
  122.    var _loc12_ = 0;
  123.    var _loc4_ = undefined;
  124.    _loc4_ = 0;
  125.    while(_loc4_ < pai_max)
  126.    {
  127.       pair_pai[_loc4_] = 0;
  128.       _loc4_ = _loc4_ + 1;
  129.    }
  130.    var _loc14_ = Math.floor(click_pn % 17);
  131.    var _loc13_ = Math.floor(click_pn / 17);
  132.    mcLine.clear();
  133.    mcLine.lineStyle(6,4521728,100);
  134.    _loc4_ = 0;
  135.    while(_loc4_ < 4)
  136.    {
  137.       var _loc1_ = curs_pai[_loc4_];
  138.       if(_loc1_ >= 0)
  139.       {
  140.          if(_loc1_ != click_pn)
  141.          {
  142.             var _loc10_ = check_tate(_loc1_,click_pn);
  143.             if(_loc10_ >= -1)
  144.             {
  145.                _loc12_ = 1;
  146.                pair_pai[_loc1_] = 1;
  147.                var _loc8_ = disp_ox + _loc1_ % xmax * CEL_W + CEL_W / 2;
  148.                var _loc6_ = disp_ox + click_pn % xmax * CEL_W + CEL_W / 2;
  149.                var _loc7_ = disp_oy + Math.floor(_loc1_ / xmax) * CEL_H + CEL_H / 2;
  150.                var _loc5_ = disp_oy + Math.floor(click_pn / xmax) * CEL_H + CEL_H / 2;
  151.                var _loc3_ = disp_oy + _loc10_ * CEL_H + CEL_H / 2;
  152.                if(_loc3_ < _loc7_)
  153.                {
  154.                   _loc7_ -= CEL_H / 3;
  155.                }
  156.                if(_loc3_ > _loc7_)
  157.                {
  158.                   _loc7_ += CEL_H / 3;
  159.                }
  160.                if(_loc3_ < _loc5_)
  161.                {
  162.                   _loc5_ -= CEL_H / 3;
  163.                }
  164.                if(_loc3_ > _loc5_)
  165.                {
  166.                   _loc5_ += CEL_H / 3;
  167.                }
  168.                if(_loc3_ == _loc7_)
  169.                {
  170.                   if(_loc8_ < _loc6_)
  171.                   {
  172.                      _loc8_ += CEL_W / 3;
  173.                   }
  174.                   else
  175.                   {
  176.                      _loc8_ -= CEL_W / 3;
  177.                   }
  178.                }
  179.                if(_loc3_ == _loc5_)
  180.                {
  181.                   if(_loc6_ < _loc8_)
  182.                   {
  183.                      _loc6_ += CEL_W / 3;
  184.                   }
  185.                   else
  186.                   {
  187.                      _loc6_ -= CEL_W / 3;
  188.                   }
  189.                }
  190.                mcLine.moveTo(_loc8_,_loc7_);
  191.                mcLine.lineTo(_loc8_,_loc3_);
  192.                mcLine.lineTo(_loc6_,_loc3_);
  193.                mcLine.lineTo(_loc6_,_loc5_);
  194.             }
  195.             else
  196.             {
  197.                var _loc11_ = check_yoko(_loc1_,click_pn);
  198.                if(_loc11_ >= -1)
  199.                {
  200.                   _loc12_ = 1;
  201.                   pair_pai[_loc1_] = 1;
  202.                   _loc8_ = disp_ox + _loc1_ % xmax * CEL_W + CEL_W / 2;
  203.                   _loc6_ = disp_ox + click_pn % xmax * CEL_W + CEL_W / 2;
  204.                   _loc7_ = disp_oy + Math.floor(_loc1_ / xmax) * CEL_H + CEL_H / 2;
  205.                   _loc5_ = disp_oy + Math.floor(click_pn / xmax) * CEL_H + CEL_H / 2;
  206.                   var _loc2_ = disp_ox + _loc11_ * CEL_W + CEL_W / 2;
  207.                   if(_loc2_ < _loc8_)
  208.                   {
  209.                      _loc8_ -= CEL_W / 3;
  210.                   }
  211.                   if(_loc2_ > _loc8_)
  212.                   {
  213.                      _loc8_ += CEL_W / 3;
  214.                   }
  215.                   if(_loc2_ < _loc6_)
  216.                   {
  217.                      _loc6_ -= CEL_W / 3;
  218.                   }
  219.                   if(_loc2_ > _loc6_)
  220.                   {
  221.                      _loc6_ += CEL_W / 3;
  222.                   }
  223.                   if(_loc2_ == _loc8_)
  224.                   {
  225.                      if(_loc7_ < _loc5_)
  226.                      {
  227.                         _loc7_ += CEL_H / 3;
  228.                      }
  229.                      else
  230.                      {
  231.                         _loc7_ -= CEL_H / 3;
  232.                      }
  233.                   }
  234.                   if(_loc2_ == _loc6_)
  235.                   {
  236.                      if(_loc5_ < _loc7_)
  237.                      {
  238.                         _loc5_ += CEL_H / 3;
  239.                      }
  240.                      else
  241.                      {
  242.                         _loc5_ -= CEL_H / 3;
  243.                      }
  244.                   }
  245.                   mcLine.moveTo(_loc8_,_loc7_);
  246.                   mcLine.lineTo(_loc2_,_loc7_);
  247.                   mcLine.lineTo(_loc2_,_loc5_);
  248.                   mcLine.lineTo(_loc6_,_loc5_);
  249.                }
  250.             }
  251.          }
  252.       }
  253.       _loc4_ = _loc4_ + 1;
  254.    }
  255.    if(_loc12_ == 1)
  256.    {
  257.       pair_pai[click_pn] = 2;
  258.    }
  259.    return _loc12_;
  260. }
  261. function check_yoko(pn1, pn2)
  262. {
  263.    var _loc11_ = -2;
  264.    if(pn1 > pn2)
  265.    {
  266.       var _loc15_ = pn1;
  267.       pn1 = pn2;
  268.       pn2 = _loc15_;
  269.    }
  270.    var _loc16_ = undefined;
  271.    var _loc1_ = undefined;
  272.    var _loc2_ = undefined;
  273.    var _loc10_ = Math.floor(pn1 % xmax);
  274.    var _loc5_ = Math.floor(pn1 / xmax);
  275.    var _loc9_ = Math.floor(pn2 % xmax);
  276.    var _loc4_ = Math.floor(pn2 / xmax);
  277.    if(_loc5_ == _loc4_)
  278.    {
  279.       return _loc11_;
  280.    }
  281.    var _loc7_ = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];
  282.    _loc7_[_loc10_] = 0;
  283.    _loc1_ = _loc10_ - 1;
  284.    while(_loc1_ >= 0)
  285.    {
  286.       if(pat[_loc5_ * xmax + _loc1_] > 0)
  287.       {
  288.          break;
  289.       }
  290.       _loc7_[_loc1_] = 0;
  291.       _loc1_ = _loc1_ - 1;
  292.    }
  293.    _loc1_ = _loc10_ + 1;
  294.    while(_loc1_ < xmax)
  295.    {
  296.       if(pat[_loc5_ * xmax + _loc1_] > 0)
  297.       {
  298.          break;
  299.       }
  300.       _loc7_[_loc1_] = 0;
  301.       _loc1_ = _loc1_ + 1;
  302.    }
  303.    var _loc6_ = [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];
  304.    _loc6_[_loc9_] = 0;
  305.    _loc1_ = _loc9_ - 1;
  306.    while(_loc1_ >= 0)
  307.    {
  308.       if(pat[_loc4_ * xmax + _loc1_] > 0)
  309.       {
  310.          break;
  311.       }
  312.       _loc6_[_loc1_] = 0;
  313.       _loc1_ = _loc1_ - 1;
  314.    }
  315.    _loc1_ = _loc9_ + 1;
  316.    while(_loc1_ < xmax)
  317.    {
  318.       if(pat[_loc4_ * xmax + _loc1_] > 0)
  319.       {
  320.          break;
  321.       }
  322.       _loc6_[_loc1_] = 0;
  323.       _loc1_ = _loc1_ + 1;
  324.    }
  325.    var _loc8_ = 99;
  326.    _loc1_ = 0;
  327.    while(_loc1_ < xmax)
  328.    {
  329.       if(!(_loc7_[_loc1_] || _loc6_[_loc1_]))
  330.       {
  331.          var _loc3_ = 1;
  332.          _loc2_ = _loc5_ + 1;
  333.          while(_loc2_ < _loc4_)
  334.          {
  335.             if(pat[_loc2_ * xmax + _loc1_] > 0)
  336.             {
  337.                _loc3_ = 0;
  338.                break;
  339.             }
  340.             _loc2_ = _loc2_ + 1;
  341.          }
  342.          if(_loc3_ == 1)
  343.          {
  344.             var _loc14_ = Math.abs(_loc10_ - _loc1_) + Math.abs(_loc9_ - _loc1_);
  345.             if(_loc14_ < _loc8_)
  346.             {
  347.                _loc8_ = _loc14_;
  348.                _loc11_ = _loc1_;
  349.             }
  350.          }
  351.       }
  352.       _loc1_ = _loc1_ + 1;
  353.    }
  354.    if(_loc7_[0] == 0 && _loc6_[0] == 0)
  355.    {
  356.       _loc14_ = _loc10_ + 1 + _loc9_ + 1;
  357.       if(_loc14_ < _loc8_)
  358.       {
  359.          _loc8_ = _loc14_;
  360.          _loc11_ = -1;
  361.       }
  362.    }
  363.    if(_loc7_[xmax - 1] == 0 && _loc6_[xmax - 1] == 0)
  364.    {
  365.       _loc14_ = xmax - _loc10_ + (xmax - _loc9_);
  366.       if(_loc14_ < _loc8_)
  367.       {
  368.          _loc8_ = _loc14_;
  369.          _loc11_ = xmax;
  370.       }
  371.    }
  372.    return _loc11_;
  373. }
  374. function check_tate(pn1, pn2)
  375. {
  376.    var _loc11_ = -2;
  377.    if(pn1 % xmax > pn2 % xmax)
  378.    {
  379.       var _loc15_ = pn1;
  380.       pn1 = pn2;
  381.       pn2 = _loc15_;
  382.    }
  383.    var _loc16_ = undefined;
  384.    var _loc2_ = undefined;
  385.    var _loc1_ = undefined;
  386.    var _loc5_ = Math.floor(pn1 % xmax);
  387.    var _loc10_ = Math.floor(pn1 / xmax);
  388.    var _loc4_ = Math.floor(pn2 % xmax);
  389.    var _loc9_ = Math.floor(pn2 / xmax);
  390.    if(_loc5_ == _loc4_)
  391.    {
  392.       return _loc11_;
  393.    }
  394.    var _loc7_ = [1,1,1,1,1,1,1,1];
  395.    _loc7_[_loc10_] = 0;
  396.    _loc1_ = _loc10_ - 1;
  397.    while(_loc1_ >= 0)
  398.    {
  399.       if(pat[_loc1_ * xmax + _loc5_] > 0)
  400.       {
  401.          break;
  402.       }
  403.       _loc7_[_loc1_] = 0;
  404.       _loc1_ = _loc1_ - 1;
  405.    }
  406.    _loc1_ = _loc10_ + 1;
  407.    while(_loc1_ < ymax)
  408.    {
  409.       if(pat[_loc1_ * xmax + _loc5_] > 0)
  410.       {
  411.          break;
  412.       }
  413.       _loc7_[_loc1_] = 0;
  414.       _loc1_ = _loc1_ + 1;
  415.    }
  416.    var _loc6_ = [1,1,1,1,1,1,1,1];
  417.    _loc6_[_loc9_] = 0;
  418.    _loc1_ = _loc9_ - 1;
  419.    while(_loc1_ >= 0)
  420.    {
  421.       if(pat[_loc1_ * xmax + _loc4_] > 0)
  422.       {
  423.          break;
  424.       }
  425.       _loc6_[_loc1_] = 0;
  426.       _loc1_ = _loc1_ - 1;
  427.    }
  428.    _loc1_ = _loc9_ + 1;
  429.    while(_loc1_ < ymax)
  430.    {
  431.       if(pat[_loc1_ * xmax + _loc4_] > 0)
  432.       {
  433.          break;
  434.       }
  435.       _loc6_[_loc1_] = 0;
  436.       _loc1_ = _loc1_ + 1;
  437.    }
  438.    var _loc8_ = 99;
  439.    _loc1_ = 0;
  440.    while(_loc1_ < ymax)
  441.    {
  442.       if(!(_loc7_[_loc1_] || _loc6_[_loc1_]))
  443.       {
  444.          var _loc3_ = 1;
  445.          _loc2_ = _loc5_ + 1;
  446.          while(_loc2_ < _loc4_)
  447.          {
  448.             if(pat[_loc1_ * xmax + _loc2_] > 0)
  449.             {
  450.                _loc3_ = 0;
  451.                break;
  452.             }
  453.             _loc2_ = _loc2_ + 1;
  454.          }
  455.          if(_loc3_ == 1)
  456.          {
  457.             var _loc14_ = Math.abs(_loc10_ - _loc1_) + Math.abs(_loc9_ - _loc1_);
  458.             if(_loc14_ < _loc8_)
  459.             {
  460.                _loc8_ = _loc14_;
  461.                _loc11_ = _loc1_;
  462.             }
  463.          }
  464.       }
  465.       _loc1_ = _loc1_ + 1;
  466.    }
  467.    if(_loc7_[0] == 0 && _loc6_[0] == 0)
  468.    {
  469.       _loc14_ = _loc10_ + 1 + _loc9_ + 1;
  470.       if(_loc14_ < _loc8_)
  471.       {
  472.          _loc8_ = _loc14_;
  473.          _loc11_ = -1;
  474.       }
  475.    }
  476.    if(_loc7_[ymax - 1] == 0 && _loc6_[ymax - 1] == 0)
  477.    {
  478.       _loc14_ = ymax - _loc10_ + (ymax - _loc9_);
  479.       if(_loc14_ < _loc8_)
  480.       {
  481.          _loc8_ = _loc14_;
  482.          _loc11_ = ymax;
  483.       }
  484.    }
  485.    return _loc11_;
  486. }
  487.