Forked from:: daniwell's if (isHit) { gameover(); }

if (!canDodge) { gameover(); }

GAME :: 避けゲーっぽいの
*
* 操作はマウスを動かすのみです。上方から降り注ぐ流星をひたすら避け続けます。
* Level 5 付近から結構きついです（主観）。

forked:2
favorite:9
lines:374
license : MIT License
modified : 2010-05-03 14:21:55

Embed: Tweet

// forked from daniwell's if (isHit) { gameover(); } 
/**
 * GAME :: 避けゲーっぽいの
 * 
 * 操作はマウスを動かすのみです。上方から降り注ぐ流星をひたすら避け続けます。
 * Level 5 付近から結構きついです（主観）。
 */
package  
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.ColorTransform;
	import flash.text.TextField;
	import flash.text.TextFormat;
	import flash.ui.Mouse;
	
	[SWF(backgroundColor = "0x333333", frameRate = "60", width = "465", height = "465")]
	public class Evade extends Sprite
	{
		private const WIDTH :uint = 390 / 3;
		private const HEIGHT:uint = 465 / 3;
		
		private var bmd :BitmapData;
		private var bmp :Bitmap;
		
		private var particles :Vector.<Vector.<Particle>> = new Vector.<Vector.<Particle>>(WIDTH);
		
		private var pos :int = 0;
		private var numList :Vector.<uint> = new Vector.<uint>(WIDTH);
		private var scoreText :TextField;
		private var tx :TextField = new TextField();
		
		private var lv :uint;
		private var speed :Number;
		private var particleNum :uint;
		
		public function Evade() 
		{
			bmd = new BitmapData(WIDTH, HEIGHT, false, 0);
			bmp = new Bitmap(bmd);
			bmp.scaleX = bmp.scaleY = 3;
			addChild(bmp);
			
			scoreText = new TextField();
			tx = new TextField();
			tx.autoSize = scoreText.autoSize = "left";
			tx.defaultTextFormat = scoreText.defaultTextFormat = new TextFormat("_等幅", 10, 0xffffff);
			
			scoreText.x = 395;
			scoreText.y = 435;
			addChild(scoreText);
			
			tx.text = "CLICK TO RESTART";
			tx.x = (465 - tx.width) / 2;
			tx.y = (465 - tx.height) / 2;
			addChild(tx);
			
			initialize();
		}
		private function initialize():void
		{
			var i:uint, j:uint, len:uint = 0;
			
			tx.visible = false;
			lv = pos = 0;
			
			for (i = 0; i < WIDTH; i++)
			{
				if (particles[i]) len = particles[i].length;
				for (j = 0; j < len; j++) particles[i][j] = null;
				
				numList[i] = i;
				particles[i] = new Vector.<Particle>();
			} 
			_particles = [];
			for (i = 0; i < WIDTH; i++)
			{
				var tmp:uint = numList[i];
				var r :uint = Math.random() * WIDTH;
				numList[i] = numList[r];
				numList[r] = tmp;
			}
			
//			Mouse.hide();
			stage.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
			stage.addEventListener(MouseEvent.CLICK, onClick);
			
			mX = 100; mY = 100;
		}
		
		private var _mode : uint = 0;
		
		private function onClick(e : MouseEvent) : void
		{
			_mode = ++_mode % 2;
		}
		
		private function addParticle():void
		{
			if (particleNum < pos) return;
			
			var n :uint = numList[pos % WIDTH];
			var p:Particle = new Particle();
			
			p.x = n;
			p.y = 0;
			p.vy = Math.random() * speed + 1;
			particles[n].push(p);
			_particles.push(p);
		}
		
		private var mX : int;
		private var mY : int;
		private var _particles : Array;
		
		private function enterFrameHandler(e:Event):void
		{
			if (lv < Level.max && Level.counts[lv] <= pos)
			{
				speed = Level.speeds[lv];
				particleNum = Level.nums[lv];
				lv ++;	// level up
			}
			
			addParticle();
			pos ++;
			
			scoreText.text = "level: " + lv + "\nscore: " + pos;
			
			var i:uint, j:uint, len:uint = 0;
			var p:Particle;
			
			bmd.lock();
			bmd.colorTransform(bmd.rect, new ColorTransform (0.4, 0.4, 0.4));
			
			for (i = 0; i < WIDTH; i++)
			{
				len = particles[i].length;
				
				for (j = 0; j < len; j++)
				{
					p = particles[i][j];
					p.py = p.y;
					p.y += p.vy;
					if (HEIGHT <= p.y)
					{
						p.vy = Math.random() * speed + 1;
						p.y = 0;
					}
					bmd.setPixel(p.x, p.y, 0xffffff);
					p.reflect();
				}
			}
			
//			var mX :int = mouseX / 3;
//			var mY :int = mouseY / 3; 
			var ret : Object;
			
			if(_mode == 0){
				ret = VelocityStrokeDodgeAlgorithm2D.run(mX, mY, 3, {
					maxxx : 133, maxxy : 145, minxx : 0, minxy : 0,
					bullets : _particles, selfr : 1, basex : 133 / 2, basey : 100
				}, [[0, 0], [1, 0], [-1, 0]], LInfinityNorm.calcLinearCollisionTime2D,
				40, 40 
				);
			}else if(_mode == 1){
				ret = VelocityStrokeDodgeAlgorithm2D.run(mX, mY, 1, {
					maxxx : 133, maxxy : 145, minxx : 0, minxy : 0,
					bullets : _particles, selfr : 1, basex : 133 / 2, basey : 100
				}, [[0, 0], [1, 1], [1, -1], [-1, 1], [-1, -1]], LInfinityNorm.calcLinearCollisionTime2D,
				40, 40 
				);
			}
			mX += ret.motion[0];
			mY += ret.motion[1];
			scoreText.appendText("\n" + ret.time);
			
			if (mX < 0) mX = 0; else if (WIDTH <= mX) mX = WIDTH - 1;
			
			// 衝突判定
			len = particles[mX].length;
			for (j = 0; j < len; j++)
			{
				p = particles[mX][j];
				if ( p.py <= mY && mY <= p.y )
				{
					Mouse.show();
					tx.visible = true;
					stage.removeEventListener(Event.ENTER_FRAME, enterFrameHandler);
					stage.addEventListener(MouseEvent.CLICK, clickHandler);
				}
			}
			
			bmd.setPixel(mX, mY, 0xff6600);	// mouse
			bmd.unlock();
		}
		private function clickHandler(e:MouseEvent):void
		{
			stage.removeEventListener(MouseEvent.CLICK, clickHandler);
			initialize();
		}
	}
}

/* Level 毎の 速さ調整 & 個数 管理 */
class Level
{
	public static const max :uint = 10;
	public static const counts :Array = [  0, 400, 800, 1200, 1500, 2000, 2500, 3000, 5000, 10000]; // pos
	public static const speeds :Array = [  0, 0.5,   1,    1,  1.5,  1.8,    2,  2.5,    3,     3]; // Particle 速さ
	public static const nums   :Array = [130, 150, 150,  180,  180,  200,  200,  200,  220,   260]; // Particle 個数
}

interface IBullet
  {
    function step() : void;
    function predict(t : Number) : Array;
  }
  
  class Bullet2D implements IBullet
  {
    public var xx : Number;
    public var xy : Number;
    public var r : Number;
    public var t : Number;
    
    public function Bullet2D(xx : Number, xy : Number, r : Number, t : Number = 0) 
    {
      this.xx = xx; this.xy = xy;
      this.r = r;
      this.t = t;
    }
    
    public function step() : void
    {
    }
    
    public function predict(t : Number) : Array
    {
      return null;
    }
  }
  
  class LinearBullet2D extends Bullet2D implements IBullet
  {
    public var vx : Number;
    public var vy : Number;
    
    public function LinearBullet2D(xx : Number, xy : Number, vx : Number, vy : Number, r : Number, t : Number = 0)
    {
      super(xx, xy, r, t);
      this.vx = vx; this.vy = vy;
    }
    
    public override function step() : void
    {
      xx += vx; xy += vy;
    }
    
    public override function predict(t : Number) : Array
    {
      return [xx + vx * t, xy + vy * t];
    }
  }

class Particle extends LinearBullet2D
{
	public var x :Number = 0;
	public var y :Number = 0;
//	public var vy:Number = 0;
	public var py:Number = 0; // previous y
	
	public function Particle()
	{
		super(0, 0, 0, 0, 1);
	}
	
	public function reflect() : void
	{
		this.xx = x;
		this.xy = y;
	}
}

class RangeUtils
  {
    public static function intersection(a : Array, b : Array) : Array
    {
      if (a == null || b == null) return null;
      if (a[1] < b[0] || b[1] < a[0]) return null;
//      return [Math.max(a[0], b[0]), Math.min(a[1], b[1])];
      return [a[0] > b[0] ? a[0] : b[0], a[1] < b[1] ? a[1] : b[1]];
    }
  }
  
  class VelocityStrokeDodgeAlgorithm2D
  {
    /**
     * the root of calcSurvivalTime
     * @param	xx
     * @param xy
     * @param	depth
     * @param	env {minxx, minxy, maxxx, maxxy, selfr, [bullets], [basex, basey]}
     * @param	motions
     * @param limt
     * @return
     */
    public static function run(xx : Number, xy : Number, depth : uint, env : *, motions : Array, collisionTimeCalculator : Function, width : Number = 0, limt : uint = 100) : Object
    {
      if (width > 0) env = filter(xx, xy, width, env, limt);
      
      var ret : Array = [0.0, 0.0];
      var maxval : Number = 0;
      var stability : Array = [];
      for each(var m : Array in motions) {
        var val : Number = calcSurvivalTime(xx, xy, m, 0, depth, env, motions, limt, collisionTimeCalculator);
        if(val >= limt)stability.push(m);
        if (val > maxval) {
          maxval = val;
          ret = m;
        }
      }
      
      if (stability.length >= 2) {
        var mind2 : Number = Number.MAX_VALUE;
        for each(m in stability) {
          var d2 : Number = (xx + m[0] - env.basex) * (xx + m[0] - env.basex) + (xy + m[1] - env.basey) * (xy + m[1] - env.basey);
          if (d2 < mind2) {
            mind2 = d2;
            ret = m;
          }
        }
      }
      return { motion : ret, time : maxval };
    }
    private static var _t : uint = 0;
    private static var _s : Number = 0;
    
    /**
     * calculate survival time.
     * This function is recursive.
     * @param	xx current state of self. (at the time of t)
     * @param xy
     * @param motion
     * @param	et elapsed time
     * @param	depth depth remaining
     * @param	env enemies' information etc.
     * @param	motions movable motions
     * @param limt upper limit of time
     * @return survival time
     */
    private static function calcSurvivalTime(xx : Number, xy : Number, motion : Array, et : Number, depth : uint, env : * , motions : Array, limt : Number, calcCollisionTime : Function) : Number
    {
        var mint : Number = limt - et;
        var t : Number;
        var rxx : Number, rxy : Number, rvx : Number, rvy : Number;
        var colr2 : Number;
        var colt : Number;
        var rxxt : Number, rxyt : Number;
        var d2 : Number;
        
        var vx : Number = motion[0];
        var vy : Number = motion[1];
        var r : Number = env.selfr;
        
        // collision with wall
        if (vx > 0) { t = ((env.maxxx - r) - xx) / vx; if (t < mint) mint = t; }
        if (vx < 0) { t = ((env.minxx + r) - xx) / vx; if (t < mint) mint = t; }
        if (vy > 0) { t = ((env.maxxy - r) - xy) / vy; if (t < mint) mint = t; }
        if (vy < 0) { t = ((env.minxy + r) - xy) / vy; if (t < mint) mint = t; }
        var self : LinearBullet2D = new LinearBullet2D(xx, xy, vx, vy, r);
        
        // collision with bullets
        if (env.bullets) {
          for each(var b : LinearBullet2D in env.bullets) {
            colt = calcCollisionTime(self, b, et);
            if (colt < mint) {
              mint = colt;
            }
          }
        }
        
        mint = Math.floor(mint);
        if (mint + et == limt) return mint + depth;
        if(mint >= 2 && depth >= 1){
            // recursion
            //var maxval : int = mint >= 10 ? mint / 10 - 1 : 0;
            //var tt : int = mint - 1 - maxval; // move to the edge of collision
            //mint -= maxval;
            var maxval : int = 0;
            var tt : int = mint - 1; // move to the edge of collision
            
            var newxx : Number = vx * tt + xx;
            var newxy : Number = vy * tt + xy;
            for each(var m : Array in motions) {
              if (m == motion) continue;
              var val : Number = calcSurvivalTime(newxx, newxy, m, et + tt, depth - 1, env, motions, limt, calcCollisionTime);
              if (val > maxval) {
                maxval = val;
              }
            }
            mint += maxval;
        }
        
        return mint;
    }

/**
     * develop tunnel vision
     * @param	w
     * @param	env
     * @return
     */
    private static function filter(xx : Number, xy : Number, w : Number, env : Object, limt : Number) : Object
    {
      var d : Number;
      
      var seen : Array = [];
      for each(var b : LinearBullet2D in env.bullets) {
        var ww : Number = w/2 + b.r;
        var dx0 : Number = b.xx - xx;
        var dy0 : Number = b.xy - xy;
        var tr : Array = [0, limt];
        if (b.vx != 0) {
          var tx0 : Number = (ww - dx0) / b.vx;
          var tx1 : Number = (-ww - dx0) / b.vx;
          if (tx0 > tx1) {
            d = tx0; tx0 = tx1; tx1 = d;
          }
          tr = RangeUtils.intersection(tr, [tx0, tx1]);
        }
        if (b.vy != 0) {
          var ty0 : Number = (ww - dy0) / b.vy;
          var ty1 : Number = (-ww - dy0) / b.vy;
          if (ty0 > ty1) {
            d = ty0; ty0 = ty1; ty1 = d;
          }
          tr = RangeUtils.intersection(tr, [ty0, ty1]);
        }
        if (tr != null) {
          seen.push(b);
        }
      }
      
      var ret : Object = { };
      for (var key : String in env) ret[key] = env[key];
      ret.bullets = seen;
      
      return ret;
    }
  }

class LInfinityNorm
  {
    public static function calcLinearCollisionTime2D(a : LinearBullet2D, b : LinearBullet2D, tb : Number = 0) : Number
    {
      var colr : Number = a.r + b.r; // collision radius
      
      // relative parameter
      var rxx : Number = a.xx - (b.xx + b.vx * tb);
      var rxy : Number = a.xy - (b.xy + b.vy * tb);
      var rvx : Number = a.vx - b.vx;
      var rvy : Number = a.vy - b.vy;
      var d : Number;
      
      var range : Array = [0, Number.MAX_VALUE]; // collision time range
      if(rvx != 0){
        var txinf : Number = (rxx - colr) / -rvx;
        var txsup : Number = (rxx + colr) / -rvx;
        if (txsup < txinf) { d = txinf; txinf = txsup; txsup = d; }
        range = RangeUtils.intersection(range, [txinf, txsup]);
      }else {
        if (rxx > colr || rxx < -colr) range = null;
      }
      
      if(rvy != 0){
        var tyinf : Number = (rxy - colr) / -rvy;
        var tysup : Number = (rxy + colr) / -rvy;
        if (tysup < tyinf) { d = tyinf; tyinf = tysup; tysup = d; }
        range = RangeUtils.intersection(range, [tyinf, tysup]);
      }else {
        if (rxy > colr || rxy < -colr) range = null;
      }
      
      return range != null ? range[0] : Number.MAX_VALUE;
    }
  }

Code Fullscreen

Preview Fullscreen