Arkanoid AI

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

package {
    import flash.display.*;
    import flash.text.TextField;
    public class FlashTest extends Sprite {
        private var _tf : TextField;
        
        public function FlashTest() {
            _tf = new TextField();
            addChild(_tf);
            _tf.width = 465;
            _tf.height = 465;
            
            var ranges : Array = [];
            ranges.push({t : 100, min : 40, max : 150, w : 1});
            ranges.push({t : 200, min : -150, max : -50, w : 2});
            ranges.push({t : 300, min : -100, max : 100, w : 1});
            drawRanges(ranges);
            
            var ret : Object = solvePath(0, 1, ranges);
            drawPath(ret, 0, 1);
            _tf.appendText("" + ret.min + "\n");
            _tf.appendText("" + ret.max + "\n");
        }
        
        private function drawRanges(ranges : Array) : void
        {
            var g : Graphics = graphics;
            for each(var r : Object in ranges){
                g.lineStyle(r.w, 0x000000);
                g.moveTo(r.t, -r.max + 465 / 2);
                g.lineTo(r.t, -r.min + 465 / 2);
            }
        }
        
        private function drawPath(range : Object, cur : Number, maxv : Number) : void
        {
            var g : Graphics = graphics;
            g.lineStyle(2, 0xff0000);
            g.moveTo(range.mostclose, -range.max + 465 / 2);
            g.lineTo(range.mostclose, -range.min + 465 / 2);
            
            g.lineStyle(2, 0x0000ff);
            g.moveTo(0, -cur + 465 / 2);
            g.lineTo(Math.abs(range.max - cur) / maxv, -range.max + 465 / 2) 
            g.lineTo(range.mostclose, -range.max + 465 / 2) 
            
            g.moveTo(0, -cur + 465 / 2);
            g.lineTo(Math.abs(range.min - cur) / maxv, -range.min + 465 / 2) 
            g.lineTo(range.mostclose, -range.min + 465 / 2) 
        }
        
        // range {t: min: max: w: }
        private function solvePath(cur : Number, maxv : Number, ranges : Array) : Object
        {
            var range : Object;
            var mostclose : Number = Number.MAX_VALUE;
            for each(range in ranges){
                if(mostclose > range.t)mostclose = range.t;
            }
            
            var rangemin : Number = cur - maxv * mostclose;
            var rangemax : Number = cur + maxv * mostclose;
            var updowns : Array = [];
            for each(range in ranges){
                var pos : Number;
                pos = range.max + maxv * (range.t - mostclose);
                if(pos >= rangemin && pos <= rangemax)updowns.push({pos : pos, w : -range.w});
                pos = range.min - maxv * (range.t - mostclose);
                if(pos >= rangemin && pos <= rangemax)updowns.push({pos : pos, w : range.w});
            }
            updowns.sortOn(["pos", "w"], [Array.NUMERIC, Array.NUMERIC | Array.DESCENDING]);
            var maxp : Number = Number.MIN_VALUE;
            var maxrange : Object = {min : rangemin, max : updowns[0].pos};
            var score : Number = 0;
            // TODO 範囲の絞り込み
            for(var i : int = 0;i < updowns.length;i++){
                var p : Object = updowns[i];
                score += p.w;
                _tf.appendText("" + p.pos + "\t" + score + "\n");
                if(maxp < score){
                    maxp = score;
                    var nextpos : Number = i + 1 < updowns.length ? updowns[i + 1].pos : rangemax;
                    maxrange = {min : p.pos, max : nextpos};
                }
            }
            maxrange.mostclose = mostclose;
            
            return maxrange;
        }
    }
}