home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / animal_artist.swf / scripts / Gamefile / Move.as < prev    next >
Encoding:
Text File  |  2008-09-05  |  15.0 KB  |  464 lines
  1. package Gamefile
  2. {
  3.    import flash.display.MovieClip;
  4.    import flash.events.Event;
  5.    
  6.    public class Move
  7.    {
  8.        
  9.       
  10.       private var mcScaleX:int;
  11.       
  12.       private var lineCenterY:Number;
  13.       
  14.       private var lineCenterX:Number;
  15.       
  16.       private var anchorAngle:Number;
  17.       
  18.       private var radian:Number;
  19.       
  20.       private var xSpeed:Number;
  21.       
  22.       private var coefficient:int;
  23.       
  24.       public var startX:int;
  25.       
  26.       public var startY:int;
  27.       
  28.       private var anchorRadian:Number;
  29.       
  30.       public var anchorX:Number;
  31.       
  32.       public var anchorY:Number;
  33.       
  34.       private var speed:int;
  35.       
  36.       public var moveSum:Number;
  37.       
  38.       private var K:Number;
  39.       
  40.       private var ySpeed:Number;
  41.       
  42.       private var angle:Number;
  43.       
  44.       public var endX:int;
  45.       
  46.       public var endY:int;
  47.       
  48.       public var curveLineType:int;
  49.       
  50.       private var chooseAnimal:MovieClip;
  51.       
  52.       private var anchorLength:int;
  53.       
  54.       public function Move()
  55.       {
  56.          super();
  57.          initMove();
  58.       }
  59.       
  60.       private function initProperty() : *
  61.       {
  62.          speed = 6;
  63.          xSpeed = 0;
  64.          ySpeed = 0;
  65.          radian = 0;
  66.          angle = 0;
  67.          moveSum = 0;
  68.          anchorLength = 26;
  69.          coefficient = 1;
  70.          curveLineType = 0;
  71.       }
  72.       
  73.       public function getSpeed(param1:int, param2:int, param3:int, param4:int) : *
  74.       {
  75.          startX = param1;
  76.          startY = param2;
  77.          endX = param3;
  78.          endY = param4;
  79.          if(startX < endX)
  80.          {
  81.             mcScaleX = 1;
  82.             if(startY < endY)
  83.             {
  84.                radian = Math.atan((endY - startY) / (endX - startX));
  85.                xSpeed = Math.cos(radian) * speed;
  86.                ySpeed = Math.sin(radian) * speed;
  87.                getAngle();
  88.                angle = 90 + angle;
  89.             }
  90.             else if(startY > endY)
  91.             {
  92.                radian = Math.atan((startY - endY) / (endX - startX));
  93.                xSpeed = Math.cos(radian) * speed;
  94.                ySpeed = -(Math.sin(radian) * speed);
  95.                getAngle();
  96.                angle = 90 - angle;
  97.             }
  98.             else if(startY == endY)
  99.             {
  100.                radian = Math.atan(0);
  101.                xSpeed = Math.cos(radian) * speed;
  102.                ySpeed = 0;
  103.                angle = 90;
  104.             }
  105.          }
  106.          else if(startX > endX)
  107.          {
  108.             mcScaleX = -1;
  109.             if(startY < endY)
  110.             {
  111.                radian = Math.atan((endY - startY) / (startX - endX));
  112.                xSpeed = -(Math.cos(radian) * speed);
  113.                ySpeed = Math.sin(radian) * speed;
  114.                getAngle();
  115.                angle = 180 + 90 - angle;
  116.             }
  117.             else if(startY > endY)
  118.             {
  119.                radian = Math.atan((startY - endY) / (startX - endX));
  120.                xSpeed = -(Math.cos(radian) * speed);
  121.                ySpeed = -(Math.sin(radian) * speed);
  122.                getAngle();
  123.                angle = -(90 - angle);
  124.             }
  125.             else if(startY == endY)
  126.             {
  127.                radian = Math.atan(0);
  128.                xSpeed = -(Math.cos(radian) * speed);
  129.                ySpeed = 0;
  130.                angle = -90;
  131.             }
  132.          }
  133.          else if(startX == endX)
  134.          {
  135.             if(startY < endY)
  136.             {
  137.                xSpeed = 0;
  138.                ySpeed = speed;
  139.                angle = 180;
  140.             }
  141.             else if(startY > endY)
  142.             {
  143.                xSpeed = 0;
  144.                ySpeed = -speed;
  145.                angle = 0;
  146.             }
  147.          }
  148.       }
  149.       
  150.       public function initMove() : *
  151.       {
  152.          initProperty();
  153.       }
  154.       
  155.       private function getAngle() : *
  156.       {
  157.          angle = radian * (180 / Math.PI);
  158.       }
  159.       
  160.       public function getAnchor(param1:int, param2:int, param3:int, param4:int, param5:int) : *
  161.       {
  162.          if(param1 < param3)
  163.          {
  164.             if(param4 < param2)
  165.             {
  166.                curveLineType = 1;
  167.                K = Math.atan((param2 - param4) / (param3 - param1));
  168.                anchorAngle = 90 - K * (180 / Math.PI);
  169.                anchorRadian = anchorAngle / (180 / Math.PI);
  170.                anchorX = Math.cos(anchorRadian) * anchorLength;
  171.                anchorY = Math.sin(anchorRadian) * anchorLength;
  172.                lineCenterX = param1 + Math.abs((param1 - param3) / 2);
  173.                lineCenterY = param2 - Math.abs((param2 - param4) / 2);
  174.                if(param5 == 4 || param5 == 5 || param5 == 8)
  175.                {
  176.                   coefficient = 1;
  177.                   anchorX = lineCenterX + anchorX * coefficient;
  178.                   anchorY = lineCenterY + anchorY * coefficient;
  179.                }
  180.                else if(param5 == 2 || param5 == 6 || param5 == 7)
  181.                {
  182.                   coefficient = -1;
  183.                   anchorX = lineCenterX + anchorX * coefficient;
  184.                   anchorY = lineCenterY + anchorY * coefficient;
  185.                }
  186.                else
  187.                {
  188.                   anchorX = lineCenterX + anchorX * coefficient;
  189.                   anchorY = lineCenterY + anchorY * coefficient;
  190.                }
  191.             }
  192.             else if(param4 > param2)
  193.             {
  194.                curveLineType = 4;
  195.                K = Math.atan((param4 - param2) / (param3 - param1));
  196.                anchorAngle = 90 - K * (180 / Math.PI);
  197.                anchorRadian = anchorAngle / (180 / Math.PI);
  198.                anchorX = Math.cos(anchorRadian) * anchorLength;
  199.                anchorY = Math.sin(anchorRadian) * anchorLength;
  200.                lineCenterX = param1 + Math.abs((param1 - param3) / 2);
  201.                lineCenterY = param2 + Math.abs((param2 - param4) / 2);
  202.                if(param5 == 1 || param5 == 5 || param5 == 7)
  203.                {
  204.                   coefficient = 1;
  205.                   anchorX = lineCenterX + anchorX * coefficient;
  206.                   anchorY = lineCenterY - anchorY * coefficient;
  207.                }
  208.                else if(param5 == 3 || param5 == 6 || param5 == 8)
  209.                {
  210.                   coefficient = -1;
  211.                   anchorX = lineCenterX + anchorX * coefficient;
  212.                   anchorY = lineCenterY - anchorY * coefficient;
  213.                }
  214.                else
  215.                {
  216.                   anchorX = lineCenterX + anchorX * coefficient;
  217.                   anchorY = lineCenterY - anchorY * coefficient;
  218.                }
  219.             }
  220.             else if(param2 == param4)
  221.             {
  222.                curveLineType = 5;
  223.                anchorX = 0;
  224.                anchorY = anchorLength;
  225.                lineCenterX = param1 + Math.abs((param1 - param3) / 2);
  226.                lineCenterY = param2;
  227.                if(param5 == 1 || param5 == 2 || param5 == 7)
  228.                {
  229.                   coefficient = -1;
  230.                   anchorX += lineCenterX;
  231.                   anchorY = anchorY * coefficient + lineCenterY;
  232.                }
  233.                else if(param5 == 3 || param5 == 4 || param5 == 8)
  234.                {
  235.                   coefficient = 1;
  236.                   anchorX += lineCenterX;
  237.                   anchorY = anchorY * coefficient + lineCenterY;
  238.                }
  239.                else
  240.                {
  241.                   anchorX += lineCenterX;
  242.                   anchorY = anchorY * coefficient + lineCenterY;
  243.                }
  244.             }
  245.          }
  246.          else if(param1 > param3)
  247.          {
  248.             if(param4 < param2)
  249.             {
  250.                curveLineType = 2;
  251.                K = Math.atan((param2 - param4) / (param1 - param3));
  252.                anchorAngle = 90 - K * (180 / Math.PI);
  253.                anchorRadian = anchorAngle / (180 / Math.PI);
  254.                anchorX = Math.cos(anchorRadian) * anchorLength;
  255.                anchorY = Math.sin(anchorRadian) * anchorLength;
  256.                lineCenterX = param3 + Math.abs((param1 - param3) / 2);
  257.                lineCenterY = param4 + Math.abs((param2 - param4) / 2);
  258.                if(param5 == 1 || param5 == 5 || param5 == 7)
  259.                {
  260.                   coefficient = 1;
  261.                   anchorX = lineCenterX + anchorX * coefficient;
  262.                   anchorY = lineCenterY - anchorY * coefficient;
  263.                }
  264.                else if(param5 == 3 || param5 == 6 || param5 == 8)
  265.                {
  266.                   coefficient = -1;
  267.                   anchorX = lineCenterX + anchorX * coefficient;
  268.                   anchorY = lineCenterY - anchorY * coefficient;
  269.                }
  270.                else
  271.                {
  272.                   anchorX = lineCenterX + anchorX * coefficient;
  273.                   anchorY = lineCenterY - anchorY * coefficient;
  274.                }
  275.             }
  276.             else if(param4 > param2)
  277.             {
  278.                curveLineType = 3;
  279.                K = Math.atan((param4 - param2) / (param1 - param3));
  280.                anchorAngle = 90 - K * (180 / Math.PI);
  281.                anchorRadian = anchorAngle / (180 / Math.PI);
  282.                anchorX = Math.cos(anchorRadian) * anchorLength;
  283.                anchorY = Math.sin(anchorRadian) * anchorLength;
  284.                lineCenterX = param3 + Math.abs((param1 - param3) / 2);
  285.                lineCenterY = param4 - Math.abs((param2 - param4) / 2);
  286.                if(param5 == 4 || param5 == 5 || param5 == 8)
  287.                {
  288.                   coefficient = -1;
  289.                   anchorX = lineCenterX - anchorX * coefficient;
  290.                   anchorY = lineCenterY - anchorY * coefficient;
  291.                }
  292.                else if(param5 == 2 || param5 == 6 || param5 == 7)
  293.                {
  294.                   coefficient = 1;
  295.                   anchorX = lineCenterX - anchorX * coefficient;
  296.                   anchorY = lineCenterY - anchorY * coefficient;
  297.                }
  298.                else
  299.                {
  300.                   anchorX = lineCenterX - anchorX * coefficient;
  301.                   anchorY = lineCenterY - anchorY * coefficient;
  302.                }
  303.             }
  304.             else if(param2 == param4)
  305.             {
  306.                curveLineType = 6;
  307.                anchorX = 0;
  308.                anchorY = anchorLength;
  309.                lineCenterX = param3 + Math.abs((param1 - param3) / 2);
  310.                lineCenterY = param2;
  311.                if(param5 == 3 || param5 == 4 || param5 == 8)
  312.                {
  313.                   coefficient = 1;
  314.                   anchorX += lineCenterX;
  315.                   anchorY = anchorY * coefficient + lineCenterY;
  316.                }
  317.                else if(param5 == 1 || param5 == 2 || param5 == 7)
  318.                {
  319.                   coefficient = -1;
  320.                   anchorX += lineCenterX;
  321.                   anchorY = anchorY * coefficient + lineCenterY;
  322.                }
  323.                else
  324.                {
  325.                   anchorX += lineCenterX;
  326.                   anchorY = anchorY * coefficient + lineCenterY;
  327.                }
  328.             }
  329.          }
  330.          else if(param1 == param3)
  331.          {
  332.             anchorX = anchorLength;
  333.             anchorY = 0;
  334.             if(param2 < param4)
  335.             {
  336.                curveLineType = 7;
  337.                curveLineType = 0;
  338.                lineCenterY = Math.abs((param2 - param4) / 2) + param2;
  339.                lineCenterX = param1;
  340.                if(param5 == 2 || param5 == 3 || param5 == 6)
  341.                {
  342.                   coefficient = -1;
  343.                   anchorX = anchorX * coefficient + lineCenterX;
  344.                   anchorY += lineCenterY;
  345.                }
  346.                else if(param5 == 1 || param5 == 4 || param5 == 5)
  347.                {
  348.                   coefficient = 1;
  349.                   anchorX = anchorX * coefficient + lineCenterX;
  350.                   anchorY += lineCenterY;
  351.                }
  352.                else
  353.                {
  354.                   anchorX += lineCenterX;
  355.                   anchorY = anchorY * coefficient + lineCenterY;
  356.                }
  357.             }
  358.             else if(param2 > param4)
  359.             {
  360.                curveLineType = 8;
  361.                curveLineType = 0;
  362.                lineCenterY = Math.abs((param2 - param4) / 2) + param4;
  363.                lineCenterX = param1;
  364.                if(param5 == 1 || param5 == 4 || param5 == 5)
  365.                {
  366.                   coefficient = 1;
  367.                   anchorX = anchorX * coefficient + lineCenterX;
  368.                   anchorY += lineCenterY;
  369.                }
  370.                else if(param5 == 2 || param5 == 3 || param5 == 6)
  371.                {
  372.                   coefficient = -1;
  373.                   anchorX = anchorX * coefficient + lineCenterX;
  374.                   anchorY += lineCenterY;
  375.                }
  376.                else
  377.                {
  378.                   anchorX += lineCenterX;
  379.                   anchorY = anchorY * coefficient + lineCenterY;
  380.                }
  381.             }
  382.          }
  383.          coefficient *= -1;
  384.       }
  385.       
  386.       private function getRadian(param1:Number) : Number
  387.       {
  388.          var _loc2_:Number = NaN;
  389.          _loc2_ = 0;
  390.          _loc2_ = angle / (180 / Math.PI);
  391.          return radian;
  392.       }
  393.       
  394.       public function getCoord(param1:MovieClip, param2:int, param3:int) : *
  395.       {
  396.          if(param1 != null)
  397.          {
  398.             param1.x = param2;
  399.             param1.y = param3;
  400.          }
  401.       }
  402.       
  403.       public function getActionAnimal(param1:MovieClip) : *
  404.       {
  405.          chooseAnimal = param1;
  406.       }
  407.       
  408.       public function moving(param1:MovieClip, param2:Boolean) : *
  409.       {
  410.          param1.x += xSpeed;
  411.          param1.y += ySpeed;
  412.          if(param2 == true)
  413.          {
  414.             param1.scaleX = mcScaleX;
  415.          }
  416.          moveSum += Math.sqrt(xSpeed * xSpeed + ySpeed * ySpeed);
  417.          if(endX >= startX)
  418.          {
  419.             if(param1.x > endX)
  420.             {
  421.                param1.x = endX;
  422.                param1.y = endY;
  423.                param1.dispatchEvent(new Event("getSpeed",true));
  424.             }
  425.          }
  426.          else if(endX <= startX)
  427.          {
  428.             if(param1.x < endX)
  429.             {
  430.                param1.x = endX;
  431.                param1.y = endY;
  432.                param1.dispatchEvent(new Event("getSpeed",true));
  433.             }
  434.          }
  435.          if(endX == startX)
  436.          {
  437.             if(startY < endY)
  438.             {
  439.                if(param1.y >= endY)
  440.                {
  441.                   param1.x = endX;
  442.                   param1.y = endY;
  443.                   param1.dispatchEvent(new Event("getSpeed",true));
  444.                }
  445.             }
  446.             else if(startY > endY)
  447.             {
  448.                if(param1.y <= endY)
  449.                {
  450.                   param1.x = endX;
  451.                   param1.y = endY;
  452.                   param1.dispatchEvent(new Event("getSpeed",true));
  453.                }
  454.             }
  455.          }
  456.       }
  457.       
  458.       public function outPutAngle() : Number
  459.       {
  460.          return angle;
  461.       }
  462.    }
  463. }
  464.