等速系の命中計算(衝突半径を考慮しない)

/**
 * Copyright uwi ( http://wonderfl.net/user/uwi )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/3K2X
 */

package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.utils.getTimer;
    
    // 最速発射問題
    // 非線形連立方程式をニュートン法で解く。
    public class Test extends Sprite {
        private var _tf : TextField;
  
        // 自機の情報
        private var _x0x : Number = 0;
        private var _x0y : Number = 0;
        private var _th0 : Number = 0;
        
        // 弾速
        private var _bv : Number = 7;
        
        // 変位
        private const PHI : Number = 0.1;
        private const STEP : Number = 6.0;
        private const R : Number = STEP / (2 * Math.sin(PHI));
        private var _qx : Number;
        private var _qy : Number;
        
        // 敵弾の情報
        private var _exx : Number = 100;
        private var _exy : Number = 100;
        private var _evx : Number = -2;
        private var _evy : Number = -3;
        
        // 衝突判定距離
        private var _cr : Number = 10;
        
        public function Test() {
            _tf = new TextField();
            _tf.width = 465;
            _tf.height = 465;
            addChild(_tf);
            
            var s : int = getTimer();
            
            _qx = _x0x + R * Math.cos(_th0 + Math.PI / 2);
            _qy = _x0y + R * Math.sin(_th0 + Math.PI / 2);
            
            var t : Number = 10;
            var u : Number = 10;
            
            for(var i : int = 0;i < 10;i++){
                var G : Array = makeG(t, u);
                var J : Array = makeJ(t, u);
                var D : Number = J[0] * J[3] - J[1] * J[2];
                t -= (J[3] * G[0] - J[1] * G[1]) / D;
                u -= (-J[2] * G[0] + J[0] * G[1]) / D;
                tr(D, t, u);
            }
            
            // 検算
            tr(xx(t));
            tr(xx(t)[0] + w(t)[0] * _bv * u);
            tr(xx(t)[1] + w(t)[1] * _bv * u);
            tr(_exx + _evx * (t + u));
            tr(_exy + _evy * (t + u));
            
            var g : int = getTimer();
            tr((g - s) + " ms");
        }
        
        private function makeG(t : Number, u : Number) : Array
        {
            var vx : Array = xx(t);
            var vw : Array = w(t);
            return [
                vx[0] + vw[0] * _bv * u - _exx - _evx * (t + u),
                vx[1] + vw[1] * _bv * u - _exy - _evy * (t + u)
            ];
        }
        
        private function makeJ(t : Number, u : Number) : Array
        {
            var vdx : Array = dx(t);
            var vw : Array = w(t);
            var vdw : Array = dw(t);
            return [
                vdx[0] + vdw[0] * _bv * u - _evx,
                vw[0] * _bv - _evx,
                vdx[1] + vdw[1] * _bv * u - _evy,
                vw[1] * _bv - _evx
            ];
        }
        
        private function xx(t : Number) : Array
        {
            return [
                _qx + R * Math.cos(_th0 - Math.PI / 2 + t * 2 * PHI),
                _qy + R * Math.sin(_th0 - Math.PI / 2 + t * 2 * PHI)
                ];
        }
        
        private function dx(t : Number) : Array
        {
            return [
                2 * PHI * R * Math.cos(_th0 + t * 2 * PHI),
                2 * PHI * R * Math.sin(_th0 + t * 2 * PHI),
                ];
        }
        
        private function w(t : Number) : Array
        {
            return [
                Math.cos(_th0 + PHI * t),
                Math.sin(_th0 + PHI * t)
                ];
        }

        private function dw(t : Number) : Array
        {
            return [
                -PHI * Math.sin(_th0 + PHI * t),
                PHI * Math.cos(_th0 + PHI * t)
                ];
        }

        private function tr(...o : Array) : void
        {
            _tf.appendText(o + "\n");
        }
    }
}