home *** CD-ROM | disk | FTP | other *** search
/ Champak 48 / cdrom_image.iso / Games / breakawish.swf / scripts / __Packages / Ball.as next >
Encoding:
Text File  |  2007-09-28  |  20.6 KB  |  605 lines
  1. class Ball extends BaseObject
  2. {
  3.    var nSpeed;
  4.    var nTempSpeedModifier;
  5.    var nPermanentSpeedModifier;
  6.    var nRadian;
  7.    var bPassThroughAbility;
  8.    var bHasTrailStars;
  9.    var mcRef;
  10.    var nTrailStarsDelay;
  11.    static var sSTATE_LAUNCH_WAIT = "LaunchWait";
  12.    static var sSTATE_LAUNCH_WAIT_PASSTHROUGH = "LWSuit";
  13.    static var sSTATE_LAUNCH_WAIT_CHEWINGGUM = "LWGum";
  14.    static var sSTATE_LAUNCH_WAIT_PASSPLUSGUM = "LWSuitGum";
  15.    static var sSTATE_MOVING = "Moving";
  16.    static var sSTATE_MOVING_PASSTHROUGH = "MSuit";
  17.    static var sSTATE_MOVING_CHEWINGGUM = "MGum";
  18.    static var sSTATE_MOVING_PASSPLUSGUM = "MSuitGum";
  19.    static var nHIT_WITH_BOTTOM = 1;
  20.    static var nHIT_WITH_TOP = 2;
  21.    static var nHIT_WITH_LEFT = 3;
  22.    static var nHIT_WITH_RIGHT = 4;
  23.    static var nPROHIBED_ANGLE_RANGE_1_MIN = 165;
  24.    static var nPROHIBED_ANGLE_RANGE_1_MAX = 195;
  25.    static var nPROHIBED_ANGLE_RANGE_2_MIN = 345;
  26.    static var nPROHIBED_ANGLE_RANGE_2_MAX = 360;
  27.    static var nPROHIBED_ANGLE_RANGE_3_MIN = 0;
  28.    static var nPROHIBED_ANGLE_RANGE_3_MAX = 15;
  29.    static var nPROHIBED_ANGLE_RANGE_4_MIN = 75;
  30.    static var nPROHIBED_ANGLE_RANGE_4_MAX = 105;
  31.    static var nPROHIBED_ANGLE_RANGE_5_MIN = 255;
  32.    static var nPROHIBED_ANGLE_RANGE_5_MAX = 285;
  33.    static var nPADDLE_HIT_SPEED_BURST = 6;
  34.    static var nBALL_HIT_SPEED_BURST = 3;
  35.    static var nSPEED_BURST_REDUCE_SPEED = 0.4;
  36.    static var nANGLE_RANDOM_ADDON_RAND = 10;
  37.    static var nTRAIL_STARS_DELAY = 2;
  38.    function Ball(_mcRef)
  39.    {
  40.       super(_mcRef);
  41.       this.setState(Ball.sSTATE_LAUNCH_WAIT);
  42.       this.nSpeed = 0;
  43.       this.nTempSpeedModifier = 0;
  44.       this.nPermanentSpeedModifier = 0;
  45.       this.nRadian = undefined;
  46.       this.bPassThroughAbility = false;
  47.       this.bHasTrailStars = false;
  48.       LevelManager.Instance.doAddListener(this);
  49.    }
  50.    function onGainPassThroughAbility()
  51.    {
  52.       this.bPassThroughAbility = true;
  53.       switch(this.CurrentState)
  54.       {
  55.          case Ball.sSTATE_LAUNCH_WAIT:
  56.             this.setState(Ball.sSTATE_LAUNCH_WAIT_PASSTHROUGH);
  57.             break;
  58.          case Ball.sSTATE_MOVING:
  59.             this.setState(Ball.sSTATE_MOVING_PASSTHROUGH);
  60.             break;
  61.          case Ball.sSTATE_LAUNCH_WAIT_CHEWINGGUM:
  62.             this.setState(Ball.sSTATE_LAUNCH_WAIT_PASSPLUSGUM);
  63.             break;
  64.          case Ball.sSTATE_MOVING_CHEWINGGUM:
  65.             this.setState(Ball.sSTATE_MOVING_PASSPLUSGUM);
  66.       }
  67.    }
  68.    function onBallHit(_oBall, _nHitSide)
  69.    {
  70.       var _loc2_ = this.Speeds;
  71.       switch(_nHitSide)
  72.       {
  73.          case Ball.nHIT_WITH_BOTTOM:
  74.             if(Library.Utils.MoreMath.getPolarity(_loc2_.y) == -1)
  75.             {
  76.                this.onBounceY();
  77.             }
  78.             break;
  79.          case Ball.nHIT_WITH_TOP:
  80.             if(Library.Utils.MoreMath.getPolarity(_loc2_.y) == 1)
  81.             {
  82.                this.onBounceY();
  83.             }
  84.             break;
  85.          case Ball.nHIT_WITH_LEFT:
  86.             if(Library.Utils.MoreMath.getPolarity(_loc2_.c) == -1)
  87.             {
  88.                this.onBounceX();
  89.             }
  90.             break;
  91.          case Ball.nHIT_WITH_RIGHT:
  92.             if(Library.Utils.MoreMath.getPolarity(_loc2_.c) == 1)
  93.             {
  94.                this.onBounceX();
  95.             }
  96.       }
  97.    }
  98.    function setPosition(_nPosX, _nPosY)
  99.    {
  100.       this.mcRef._x = _nPosX;
  101.       this.mcRef._y = _nPosY;
  102.    }
  103.    function setAngle(_nAngle)
  104.    {
  105.       this.nRadian = Library.Utils.MoreMath.getRadianFromDegree(_nAngle);
  106.    }
  107.    function doAffectSpeed(_nSpeedMod)
  108.    {
  109.       this.nPermanentSpeedModifier += _nSpeedMod;
  110.       this.bHasTrailStars = this.nPermanentSpeedModifier > 0;
  111.    }
  112.    function setSpeed(_nSpeed)
  113.    {
  114.       switch(this.CurrentState)
  115.       {
  116.          case Ball.sSTATE_LAUNCH_WAIT:
  117.             this.setState(Ball.sSTATE_MOVING);
  118.             break;
  119.          case Ball.sSTATE_LAUNCH_WAIT_PASSTHROUGH:
  120.             this.setState(Ball.sSTATE_MOVING_PASSTHROUGH);
  121.             break;
  122.          case Ball.sSTATE_LAUNCH_WAIT_CHEWINGGUM:
  123.             this.setState(Ball.sSTATE_MOVING_CHEWINGGUM);
  124.             break;
  125.          case Ball.sSTATE_LAUNCH_WAIT_PASSPLUSGUM:
  126.             this.setState(Ball.sSTATE_MOVING_PASSPLUSGUM);
  127.       }
  128.       this.nSpeed = _nSpeed;
  129.    }
  130.    function onChewingGumCatch()
  131.    {
  132.       switch(this.CurrentState)
  133.       {
  134.          case Ball.sSTATE_LAUNCH_WAIT:
  135.             this.setState(Ball.sSTATE_LAUNCH_WAIT_CHEWINGGUM);
  136.             break;
  137.          case Ball.sSTATE_MOVING:
  138.             this.setState(Ball.sSTATE_MOVING_CHEWINGGUM);
  139.             break;
  140.          case Ball.sSTATE_LAUNCH_WAIT_PASSTHROUGH:
  141.             this.setState(Ball.sSTATE_LAUNCH_WAIT_PASSPLUSGUM);
  142.             break;
  143.          case Ball.sSTATE_MOVING_PASSTHROUGH:
  144.             this.setState(Ball.sSTATE_MOVING_PASSPLUSGUM);
  145.       }
  146.    }
  147.    function onChewingGumEnd()
  148.    {
  149.       switch(this.CurrentState)
  150.       {
  151.          case Ball.sSTATE_LAUNCH_WAIT_CHEWINGGUM:
  152.             this.setState(Ball.sSTATE_LAUNCH_WAIT);
  153.             break;
  154.          case Ball.sSTATE_MOVING_CHEWINGGUM:
  155.             this.setState(Ball.sSTATE_MOVING);
  156.             break;
  157.          case Ball.sSTATE_LAUNCH_WAIT_PASSPLUSGUM:
  158.             this.setState(Ball.sSTATE_LAUNCH_WAIT_PASSTHROUGH);
  159.             break;
  160.          case Ball.sSTATE_MOVING_PASSPLUSGUM:
  161.             this.setState(Ball.sSTATE_MOVING_PASSTHROUGH);
  162.       }
  163.    }
  164.    function doDestroy()
  165.    {
  166.       LevelManager.Instance.doRemoveListener(this);
  167.       super.doDestroy();
  168.    }
  169.    function get Angle()
  170.    {
  171.       return Library.Utils.MoreMath.getDegreeFromRadius(this.nRadian);
  172.    }
  173.    function get Speed()
  174.    {
  175.       return this.nSpeed;
  176.    }
  177.    function get Speeds()
  178.    {
  179.       var _loc2_ = new Object();
  180.       if(this.CurrentState == Ball.sSTATE_MOVING || this.CurrentState == Ball.sSTATE_MOVING_PASSTHROUGH || this.CurrentState == Ball.sSTATE_MOVING_CHEWINGGUM || this.CurrentState == Ball.sSTATE_MOVING_PASSPLUSGUM)
  181.       {
  182.          var _loc3_ = Math.cos(this.nRadian) * (this.nSpeed + this.nPermanentSpeedModifier + this.nTempSpeedModifier);
  183.          var _loc4_ = Math.sin(this.nRadian) * (this.nSpeed + this.nPermanentSpeedModifier + this.nTempSpeedModifier);
  184.          _loc2_.x = _loc3_;
  185.          _loc2_.y = _loc4_;
  186.       }
  187.       else
  188.       {
  189.          _loc2_.x = 0;
  190.          _loc2_.y = 0;
  191.       }
  192.       return _loc2_;
  193.    }
  194.    function doMSuit()
  195.    {
  196.       this.doMoving();
  197.    }
  198.    function doMGum()
  199.    {
  200.       this.doMoving();
  201.    }
  202.    function doMSuitGum()
  203.    {
  204.       this.doMoving();
  205.    }
  206.    function doMoving()
  207.    {
  208.       this.doValidateAngle();
  209.       this.nTempSpeedModifier = Library.Utils.MoreMath.getReachZero(this.nTempSpeedModifier,Ball.nSPEED_BURST_REDUCE_SPEED);
  210.       var _loc8_ = this.Speeds;
  211.       var _loc4_ = _loc8_.x;
  212.       var _loc5_ = _loc8_.y;
  213.       var _loc2_ = this.mcRef._x + _loc4_;
  214.       var _loc3_ = this.mcRef._y + _loc5_;
  215.       _loc3_ = this.doCheckTopBottom(_loc5_,_loc3_);
  216.       _loc2_ = this.doCheckSides(_loc4_,_loc2_);
  217.       var _loc6_ = this.doCheckPaddles(_loc4_,_loc5_,_loc2_,_loc3_);
  218.       _loc2_ = _loc6_.nFutureX;
  219.       _loc3_ = _loc6_.nFutureY;
  220.       var _loc9_ = this.doCheckBlocks(_loc4_,_loc5_,_loc2_,_loc3_);
  221.       _loc2_ = _loc9_.nFutureX;
  222.       _loc3_ = _loc9_.nFutureY;
  223.       var _loc7_ = this.doCheckBalls(_loc4_,_loc5_,_loc2_,_loc3_);
  224.       _loc2_ = _loc7_.nFutureX;
  225.       _loc3_ = _loc7_.nFutureY;
  226.       if(this.bHasTrailStars)
  227.       {
  228.          this.doTrailStars();
  229.       }
  230.       this.mcRef._x = _loc2_;
  231.       this.mcRef._y = _loc3_;
  232.    }
  233.    function doCheckPaddles(_nSpeedX, _nSpeedY, _nFutureX, _nFutureY)
  234.    {
  235.       var _loc2_ = LevelManager.Instance.getNearPaddlesForObject(this);
  236.       for(var _loc9_ in _loc2_)
  237.       {
  238.          switch(Library.Utils.MoreMath.getPolarity(_nSpeedY))
  239.          {
  240.             case 1:
  241.                if(this.getCollideBottom(_loc2_[_loc9_],_nFutureX,_nFutureY))
  242.                {
  243.                   _nFutureY = _loc2_[_loc9_].Bounds.yMin - this.StateBounds.yMax;
  244.                   var _loc5_ = _loc2_[_loc9_].getBallHitReaction(this);
  245.                   if(_loc5_ == Paddle.nBALL_HIT_BOUNCE_BACK)
  246.                   {
  247.                      this.onBounceY();
  248.                      _loc2_[_loc9_].onPaddleBounce();
  249.                      var _loc6_ = _loc2_[_loc9_].getAffectedBounceAngleForBall(this);
  250.                      this.nRadian = Library.Utils.MoreMath.getRadianFromDegree(_loc6_);
  251.                      this.nTempSpeedModifier = Ball.nPADDLE_HIT_SPEED_BURST;
  252.                   }
  253.                   else if(_loc5_ == Paddle.nBALL_HIT_STICKS)
  254.                   {
  255.                      switch(this.CurrentState)
  256.                      {
  257.                         case Ball.sSTATE_MOVING:
  258.                            this.setState(Ball.sSTATE_LAUNCH_WAIT);
  259.                            break;
  260.                         case Ball.sSTATE_MOVING_PASSTHROUGH:
  261.                            this.setState(Ball.sSTATE_LAUNCH_WAIT_PASSTHROUGH);
  262.                            break;
  263.                         case Ball.sSTATE_MOVING_CHEWINGGUM:
  264.                            this.setState(Ball.sSTATE_LAUNCH_WAIT_CHEWINGGUM);
  265.                            break;
  266.                         case Ball.sSTATE_MOVING_PASSPLUSGUM:
  267.                            this.setState(Ball.sSTATE_LAUNCH_WAIT_PASSPLUSGUM);
  268.                      }
  269.                      _loc2_[_loc9_].onBallSticks(this);
  270.                      this.nSpeed = 0;
  271.                   }
  272.                   this.onPaddleTouch(_loc2_[_loc9_],true);
  273.                }
  274.                break;
  275.             case -1:
  276.                if(this.getCollideTop(_loc2_[_loc9_],_nFutureX,_nFutureY))
  277.                {
  278.                   _nFutureY = _loc2_[_loc9_].Bounds.yMax - this.StateBounds.yMin;
  279.                   this.onBounceY();
  280.                   this.onPaddleTouch();
  281.                }
  282.          }
  283.          switch(Library.Utils.MoreMath.getPolarity(_nSpeedX))
  284.          {
  285.             case 1:
  286.                if(this.getCollideRight(_loc2_[_loc9_],_nFutureX,_nFutureY))
  287.                {
  288.                   _nFutureX = _loc2_[_loc9_].Bounds.xMin - this.StateBounds.xMax;
  289.                   this.onBounceX();
  290.                   this.onPaddleTouch(_loc2_[_loc9_]);
  291.                }
  292.                break;
  293.             case -1:
  294.                if(this.getCollideLeft(_loc2_[_loc9_],_nFutureX,_nFutureY))
  295.                {
  296.                   _nFutureX = _loc2_[_loc9_].Bounds.xMax - this.StateBounds.xMin;
  297.                   this.onBounceX();
  298.                   this.onPaddleTouch(_loc2_[_loc9_]);
  299.                }
  300.          }
  301.       }
  302.       return {nFutureX:_nFutureX,nFutureY:_nFutureY};
  303.    }
  304.    function doCheckBlocks(_nSpeedX, _nSpeedY, _nFutureX, _nFutureY)
  305.    {
  306.       var _loc2_ = LevelManager.Instance.getNearBlocksForObject(this);
  307.       for(var _loc9_ in _loc2_)
  308.       {
  309.          var _loc5_ = false;
  310.          switch(Library.Utils.MoreMath.getPolarity(_nSpeedY))
  311.          {
  312.             case 1:
  313.                if(this.getCollideBottom(_loc2_[_loc9_],_nFutureX,_nFutureY))
  314.                {
  315.                   _loc2_[_loc9_].onBallHit(this,Ball.nHIT_WITH_BOTTOM);
  316.                   var _loc6_ = false;
  317.                   if(_loc2_[_loc9_].StillAlive)
  318.                   {
  319.                      this.onBounceY();
  320.                   }
  321.                   else
  322.                   {
  323.                      if(!this.bPassThroughAbility)
  324.                      {
  325.                         this.onBounceY();
  326.                      }
  327.                      else
  328.                      {
  329.                         _loc6_ = false;
  330.                      }
  331.                      this.onBlockDestroy();
  332.                   }
  333.                   if(_loc6_)
  334.                   {
  335.                      _nFutureY = _loc2_[_loc9_].Bounds.yMin - this.StateBounds.yMax;
  336.                   }
  337.                   _loc5_ = true;
  338.                }
  339.                break;
  340.             case -1:
  341.                if(this.getCollideTop(_loc2_[_loc9_],_nFutureX,_nFutureY))
  342.                {
  343.                   _loc2_[_loc9_].onBallHit(this,Ball.nHIT_WITH_TOP);
  344.                   _loc6_ = false;
  345.                   if(_loc2_[_loc9_].StillAlive)
  346.                   {
  347.                      this.onBounceY();
  348.                   }
  349.                   else
  350.                   {
  351.                      if(!this.bPassThroughAbility)
  352.                      {
  353.                         this.onBounceY();
  354.                      }
  355.                      else
  356.                      {
  357.                         _loc6_ = false;
  358.                      }
  359.                      this.onBlockDestroy();
  360.                   }
  361.                   if(_loc6_)
  362.                   {
  363.                      _nFutureY = _loc2_[_loc9_].Bounds.yMax - this.StateBounds.yMin;
  364.                   }
  365.                   _loc5_ = true;
  366.                }
  367.          }
  368.          if(!_loc5_)
  369.          {
  370.             switch(Library.Utils.MoreMath.getPolarity(_nSpeedX))
  371.             {
  372.                case 1:
  373.                   if(this.getCollideRight(_loc2_[_loc9_],_nFutureX,_nFutureY))
  374.                   {
  375.                      _loc2_[_loc9_].onBallHit(this,Ball.nHIT_WITH_RIGHT);
  376.                      _loc6_ = false;
  377.                      if(_loc2_[_loc9_].StillAlive)
  378.                      {
  379.                         this.onBounceX();
  380.                      }
  381.                      else
  382.                      {
  383.                         if(!this.bPassThroughAbility)
  384.                         {
  385.                            this.onBounceX();
  386.                         }
  387.                         else
  388.                         {
  389.                            _loc6_ = false;
  390.                         }
  391.                         this.onBlockDestroy();
  392.                      }
  393.                      if(_loc6_)
  394.                      {
  395.                         _nFutureX = _loc2_[_loc9_].Bounds.xMin - this.StateBounds.xMax;
  396.                      }
  397.                   }
  398.                   break;
  399.                case -1:
  400.                   if(this.getCollideLeft(_loc2_[_loc9_],_nFutureX,_nFutureY))
  401.                   {
  402.                      _loc2_[_loc9_].onBallHit(this,Ball.nHIT_WITH_LEFT);
  403.                      _loc6_ = false;
  404.                      if(_loc2_[_loc9_].StillAlive)
  405.                      {
  406.                         this.onBounceX();
  407.                      }
  408.                      else
  409.                      {
  410.                         if(!this.bPassThroughAbility)
  411.                         {
  412.                            this.onBounceX();
  413.                         }
  414.                         else
  415.                         {
  416.                            _loc6_ = false;
  417.                         }
  418.                         this.onBlockDestroy();
  419.                      }
  420.                      if(_loc6_)
  421.                      {
  422.                         _nFutureX = _loc2_[_loc9_].Bounds.xMax - this.StateBounds.xMin;
  423.                      }
  424.                   }
  425.             }
  426.          }
  427.       }
  428.       return {nFutureX:_nFutureX,nFutureY:_nFutureY};
  429.    }
  430.    function doCheckBalls(_nSpeedX, _nSpeedY, _nFutureX, _nFutureY)
  431.    {
  432.       var _loc2_ = LevelManager.Instance.getNearBallsForObject(this);
  433.       for(var _loc8_ in _loc2_)
  434.       {
  435.          var _loc3_ = false;
  436.          switch(Library.Utils.MoreMath.getPolarity(_nSpeedY))
  437.          {
  438.             case 1:
  439.                if(this.getCollideBottom(_loc2_[_loc8_],_nFutureX,_nFutureY))
  440.                {
  441.                   this.onBallHit(_loc2_[_loc8_],Ball.nHIT_WITH_TOP);
  442.                   _loc2_[_loc8_].onBallHit(this,Ball.nHIT_WITH_BOTTOM);
  443.                   _loc3_ = true;
  444.                }
  445.                break;
  446.             case -1:
  447.                if(this.getCollideTop(_loc2_[_loc8_],_nFutureX,_nFutureY))
  448.                {
  449.                   this.onBallHit(_loc2_[_loc8_],Ball.nHIT_WITH_BOTTOM);
  450.                   _loc2_[_loc8_].onBallHit(this,Ball.nHIT_WITH_TOP);
  451.                   _loc3_ = true;
  452.                }
  453.          }
  454.          if(!_loc3_)
  455.          {
  456.             switch(Library.Utils.MoreMath.getPolarity(_nSpeedX))
  457.             {
  458.                case 1:
  459.                   if(this.getCollideRight(_loc2_[_loc8_],_nFutureX,_nFutureY))
  460.                   {
  461.                      this.onBallHit(_loc2_[_loc8_],Ball.nHIT_WITH_LEFT);
  462.                      _loc2_[_loc8_].onBallHit(this,Ball.nHIT_WITH_RIGHT);
  463.                   }
  464.                   break;
  465.                case -1:
  466.                   if(this.getCollideLeft(_loc2_[_loc8_],_nFutureX,_nFutureY))
  467.                   {
  468.                      this.onBallHit(_loc2_[_loc8_],Ball.nHIT_WITH_RIGHT);
  469.                      _loc2_[_loc8_].onBallHit(this,Ball.nHIT_WITH_LEFT);
  470.                   }
  471.             }
  472.          }
  473.       }
  474.       return {nFutureX:_nFutureX,nFutureY:_nFutureY};
  475.    }
  476.    function doCheckSides(_nSpeedX, _nFutureX)
  477.    {
  478.       switch(Library.Utils.MoreMath.getPolarity(_nSpeedX))
  479.       {
  480.          case 1:
  481.             if(_nFutureX + this.StateBounds.xMax > LevelManager.nLIMITS_RIGHT)
  482.             {
  483.                this.onBounceX();
  484.                this.onBounceSides();
  485.                _nFutureX = LevelManager.nLIMITS_RIGHT - this.StateBounds.xMax;
  486.             }
  487.             break;
  488.          case -1:
  489.             if(_nFutureX + this.StateBounds.xMin < LevelManager.nLIMITS_LEFT)
  490.             {
  491.                this.onBounceX();
  492.                this.onBounceSides();
  493.                _nFutureX = LevelManager.nLIMITS_LEFT - this.StateBounds.xMin;
  494.             }
  495.       }
  496.       return _nFutureX;
  497.    }
  498.    function doCheckTopBottom(_nSpeedY, _nFutureY)
  499.    {
  500.       switch(Library.Utils.MoreMath.getPolarity(_nSpeedY))
  501.       {
  502.          case 1:
  503.             if(_nFutureY + this.StateBounds.yMax > LevelManager.nLIMITS_FLOOR)
  504.             {
  505.                LevelManager.Instance.onBallLost(this);
  506.             }
  507.             break;
  508.          case -1:
  509.             if(_nFutureY + this.StateBounds.yMin < LevelManager.nLIMITS_CEIL)
  510.             {
  511.                this.onBounceY();
  512.                this.onBounceSides();
  513.                _nFutureY = LevelManager.nLIMITS_CEIL - this.StateBounds.yMin;
  514.             }
  515.       }
  516.       return _nFutureY;
  517.    }
  518.    function onBounceX(_bRandomAdd)
  519.    {
  520.       if(_bRandomAdd == undefined)
  521.       {
  522.          _bRandomAdd = true;
  523.       }
  524.       var _loc3_ = this.Speeds;
  525.       var _loc2_ = _loc3_.x;
  526.       var _loc4_ = _loc3_.y;
  527.       _loc2_ *= -1;
  528.       if(_bRandomAdd)
  529.       {
  530.          this.doAngleRandomAdd();
  531.       }
  532.       this.nRadian = Math.atan2(_loc4_,_loc2_);
  533.    }
  534.    function onBounceY(_bRandomAdd)
  535.    {
  536.       if(_bRandomAdd == undefined)
  537.       {
  538.          _bRandomAdd = true;
  539.       }
  540.       var _loc3_ = this.Speeds;
  541.       var _loc4_ = _loc3_.x;
  542.       var _loc2_ = _loc3_.y;
  543.       _loc2_ *= -1;
  544.       if(_bRandomAdd)
  545.       {
  546.          this.doAngleRandomAdd();
  547.       }
  548.       this.nRadian = Math.atan2(_loc2_,_loc4_);
  549.    }
  550.    function doAngleRandomAdd()
  551.    {
  552.       var _loc2_ = Library.Utils.MoreMath.getDegreeFromRadius(this.nRadian);
  553.       _loc2_ += Library.Utils.MoreMath.getRandomRange(- Ball.nANGLE_RANDOM_ADDON_RAND,Ball.nANGLE_RANDOM_ADDON_RAND);
  554.       this.nRadian = Library.Utils.MoreMath.getRadianFromDegree(_loc2_);
  555.    }
  556.    function doTrailStars()
  557.    {
  558.       this.nTrailStarsDelay = this.nTrailStarsDelay - 1;
  559.       if(this.nTrailStarsDelay <= 0)
  560.       {
  561.          this.nTrailStarsDelay = Ball.nTRAIL_STARS_DELAY;
  562.          this.doSpecificTrailStar();
  563.       }
  564.    }
  565.    function doValidateAngle()
  566.    {
  567.       var _loc2_ = Library.Utils.MoreMath.getDegreeFromRadius(this.nRadian);
  568.       _loc2_ = this.doCheckAngleGroup(_loc2_,Ball.nPROHIBED_ANGLE_RANGE_1_MIN,Ball.nPROHIBED_ANGLE_RANGE_1_MAX);
  569.       _loc2_ = this.doCheckAngleGroup(_loc2_,Ball.nPROHIBED_ANGLE_RANGE_2_MIN,Ball.nPROHIBED_ANGLE_RANGE_2_MAX);
  570.       _loc2_ = this.doCheckAngleGroup(_loc2_,Ball.nPROHIBED_ANGLE_RANGE_3_MIN,Ball.nPROHIBED_ANGLE_RANGE_3_MAX);
  571.       _loc2_ = this.doCheckAngleGroup(_loc2_,Ball.nPROHIBED_ANGLE_RANGE_4_MIN,Ball.nPROHIBED_ANGLE_RANGE_4_MAX);
  572.       _loc2_ = this.doCheckAngleGroup(_loc2_,Ball.nPROHIBED_ANGLE_RANGE_5_MIN,Ball.nPROHIBED_ANGLE_RANGE_5_MAX);
  573.       this.nRadian = Library.Utils.MoreMath.getRadianFromDegree(_loc2_);
  574.    }
  575.    function doCheckAngleGroup(_nDegree, _nMin, _nMax)
  576.    {
  577.       if(_nDegree > _nMin && _nDegree < _nMax)
  578.       {
  579.          var _loc4_ = _nDegree - (_nMax + _nMin) / 2;
  580.          switch(Library.Utils.MoreMath.getPolarity(_loc4_))
  581.          {
  582.             case 1:
  583.                _nDegree = _nMax;
  584.                break;
  585.             case -1:
  586.             default:
  587.                _nDegree = _nMin;
  588.          }
  589.       }
  590.       return _nDegree;
  591.    }
  592.    function doSpecificTrailStar()
  593.    {
  594.    }
  595.    function onBlockDestroy()
  596.    {
  597.    }
  598.    function onBounceSides()
  599.    {
  600.    }
  601.    function onPaddleTouch(_oPaddle, _bBounceTop)
  602.    {
  603.    }
  604. }
  605.