┃お┃┃め┃┃で┃┃と┃┃う┃┃ご┃┃ざ┃┃い┃┃ま┃┃す┃

┏━━┓ 1つの丸が頂点になることで、
┃＼／┃ 角ができて、多角。
┗━━┛ また丸くなる様子です。

by hgw 22 Nov 2010

Embed

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

/*
┏━━┓ 1つの丸が頂点になることで、
┃＼／┃ 角ができて、多角。
┗━━┛ また丸くなる様子です。
*/


package
{
	
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageQuality;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	
	public class mp extends Sprite
	{
		
		public function mp()
		{
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			stage.quality = StageQuality.LOW;
			
			var k:MetaPolygonAnimation = new MetaPolygonAnimation();
			addChild( k );
		}
	}
}


import flash.display.Graphics;
import flash.display.Shape;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.geom.Point;
import flash.utils.Timer;
	
	
internal  class MetaPolygonAnimation extends Sprite
{
	private const DEF_LENGTH:Number = 75;
	private var lengthSide:Number = DEF_LENGTH;
	private var numSide:int = 1;
	
	private var vertexPoints:Vector.<VertexShape>
	
	private var clocktimer:Timer;
	
	public function MetaPolygonAnimation()
	{
		super();
		addEventListener( Event.ADDED_TO_STAGE, added );
	}
	
	private function added(e:Event):void
	{
		vertexPoints = new Vector.<VertexShape>();
		stage.addEventListener( KeyboardEvent.KEY_DOWN, toggleDraw );
		stage.addEventListener( MouseEvent.MOUSE_DOWN, startValueSet );
		stage.addEventListener( MouseEvent.MOUSE_UP, stopValueSet );
		clocktimer = new Timer(1000);
		clocktimer.start();
		clocktimer.addEventListener( TimerEvent.TIMER, addVertex );
		addVertex();
		
		timer = new Timer(1000/60);
		timer.start();
		timer.addEventListener( TimerEvent.TIMER, updatepoints );
	}
	
	private var timer:Timer;
	private var isDraw:Boolean = false;
	private var isCircleDraw:Boolean = false;
	private var drawStep:int=0;
	
	private function toggleDraw(e:Event):void
	{
		drawStep++;
		if(drawStep>=4) drawStep=0;
		switch(drawStep){
			case 0:
				isDraw = false;
				VertexShape.circleDraw = false;
				break;
			case 1:
				isDraw = true;
				VertexShape.circleDraw = false;
				break;
			case 2:
				isDraw = true;
				VertexShape.circleDraw = true;
				break;
			case 3:
				isDraw = false;
				VertexShape.circleDraw = true;
				break;
		}
		
		var max:int = vertexPoints.length;
		for(var i:int=0; i<max; i++)
		{
			var obj:VertexShape = vertexPoints[i];
			obj.update(VertexShape.dist);
		}	
	}
	
	private var _dragStartPoint:Point = new Point();
	private function startValueSet(e:Event):void
	{
		_dragStartPoint.x = stage.mouseX;
_dragStartPoint.y = stage.mouseY;
		stage.addEventListener( MouseEvent.MOUSE_MOVE, updateValue );
	}
	
	private function stopValueSet(e:Event):void
	{
		stage.removeEventListener( MouseEvent.MOUSE_MOVE,  updateValue );
	}
	
	private function updateValue(e:MouseEvent):void
	{
		var sabun:Number = stage.mouseY-_dragStartPoint.y;
		if(sabun<0) sabun = 0;
		else if(sabun>DEF_LENGTH) sabun = DEF_LENGTH;
		
		VertexShape.dist = sabun;
		
		var max:int = vertexPoints.length;
		for(var i:int=0; i<max; i++)
		{
			var obj:VertexShape = vertexPoints[i];
			obj.update(VertexShape.dist);
		}			
	}
	
	

	public function updatepoints(e:Event):void
	{
		var g:Graphics = graphics;
		g.clear();
		if(isDraw) g.beginFill(0x0);
		else g.lineStyle(1);
		var max:int = vertexPoints.length;
		for(var i:int=0; i<max; i++)
		{
			var obj:VertexShape = vertexPoints[i];
			obj.x += (obj.targetX-obj.x)*.1;
			obj.y += (obj.targetY-obj.y)*.1;
				if(i==0){
					g.moveTo( obj.x, obj.y );
				}else{
					g.lineTo( obj.x, obj.y );					
				}
			}	
			
		g.lineTo( vertexPoints[0].x, vertexPoints[0].y );
		
		if(lengthSide==0&&Math.abs(vertexPoints[0].targetX-vertexPoints[0].x)<1){
			reset();
		}
	}
	
	
	private function scaleDown():void
	{
		lengthSide = 0;	
		update();
	}
		
	private function reset():void
	{
		var max:int = vertexPoints.length;
		for(var i:int=1; i<max; i++)
		{
			var obj:VertexShape = vertexPoints[i];
			removeChild( obj );	
		}
			
		vertexPoints.splice(1,vertexPoints.length-1);
			
		lengthSide = DEF_LENGTH;
	}
		
	/**
	 * 
	 * @param e
	 * 
	 */	
	private function addVertex(e:Event=null):void
	{
		if(vertexPoints.length>60){
			scaleDown();
			return;
			}
	
		var vs:VertexShape = new VertexShape(VertexShape.dist);
		var center:Point = new Point(int(stage.stageWidth*.5), int(stage.stageHeight*.5));
			
		var stX:Number = (vertexPoints.length>0)? vertexPoints[0].x:center.x;
		var stY:Number = (vertexPoints.length>0)? vertexPoints[0].y:center.y;
		vs.x = vs.targetX = stX;
		vs.y = vs.targetY = stY;
			
		addChild( vs );
		vertexPoints.push( vs );
		
		update();
		}
		
		
	private function update():void
	{
		var center:Point = new Point(int(stage.stageWidth*.5), int(stage.stageHeight*.5));
		var nstep:Number = 360/vertexPoints.length;
		var sabun:Number = (vertexPoints.length%2==0)? 180+(nstep*.5):180;
		for(var i:int=0; i<vertexPoints.length; i++){
			var vs:VertexShape = vertexPoints[i];
			
			var rad:Number = (nstep*i+sabun)*Math.PI / 180;
			vs.targetX = Math.sin( rad )*lengthSide+center.x;
			vs.targetY = Math.cos( rad )*lengthSide+center.y;
		}


	}
}


import flash.display.Shape;
import flash.events.Event;
import flash.events.TimerEvent;
import flash.utils.Timer;

internal class VertexShape extends Shape
{
	public static var dist:Number  = 2;
	public static var circleDraw:Boolean  = false;
	
	private var _targetX:Number = 0;
	public function get targetX():Number { return _targetX; }
	public function set targetX(value:Number):void{ _targetX = value; }

	private var _targetY:Number = 0;
	public function get targetY():Number{return _targetY;}
	public function set targetY(value:Number):void{_targetY = value;}

	
	public function VertexShape(n:Number){
		graphics.clear();
		if(circleDraw) graphics.beginFill(0,0.2);
		else graphics.lineStyle(1,0);
		graphics.drawCircle(0,0,n);		
	}

	public function update(n:Number):void
	{
		graphics.clear();
		if(circleDraw) graphics.beginFill(0,0.1);
		else graphics.lineStyle(1,0);
		graphics.drawCircle(0,0,n);		
	}
	
	
}