ollie.as

Papervision3d的源码

/**
 * Paperskated3d - simple skateboard simulator in Papervision3d
 * 
 * @author Bartek Drozdz 
 * @version 1.0
 * 
 * Released under Creative Commons Attribution-Non-Commercial-Share Alike 3.0 License.
 */
package com.paperskate3d.tricks {
	
	import caurina.transitions.Tweener;
	import com.everydayflash.util.Rotator;
	import flash.display.DisplayObject;
	import com.paperskate3d.skate.SkateBoard;
	import com.paperskate3d.SkateView;
	import flash.events.Event;
	import flash.events.TimerEvent;
	import flash.geom.Point;
	import flash.utils.Timer;
	
	import com.carlcalderon.arthropod.Debug;

	public class Ollie extends BasicTrick {
		
		private var jumpHeight:Number;
		private var MAX_HEIGHT:Number = 500;
		
		private var nollie:Boolean = false;
		private var landingBounce:Number;
		public var landed:Boolean;
		
		public static var ROTATE:int = 1;
		public static var LEVEL:int = 2;
		public static var DROP:int = 3;
		public static var BOUNCE:int = 4;
		public var phase:int;
		
		private var wheelieTarget:Wheelie = null;

		public function Ollie(nollie:Boolean=false) {
			this.nollie = nollie;
			landed = false;
		}
		
		override public function get name():String { return "ollie" };
		
		override protected function prepareTrick():void {
			phase = ROTATE;
			jumpHeight = speed * 8;
			jumpHeight = Math.min(MAX_HEIGHT, jumpHeight);
			if (nollie) jumpHeight *= .8;
			
			var s:Number = (nollie) ? -135 : 135;
			var a:Number = (nollie) ? -35 : 35;

			if (!nollie) {
				var sf:Number = (speed - SkateView.MINIMAL_TRICK_SPEED) / 4;
				s += sf * 2;
				a += sf * .8;
				if (fromWheelie) a *= .85;
			}

			var jumpRotator:Rotator = new Rotator(this, new Point(s, -35));

			Tweener.addTween(jumpRotator, { 
				rotation:manager.baseRotationX - a, 
				time:TRICK_TIME * .2,
				transition:"easeInOutSine"
				,onComplete:levelUp
			} );
		}
		
		private function levelUp():void {
			phase = LEVEL;
			var s:Number = (nollie) ? 130 : -130;
			var levelRotator:Rotator = new Rotator(this, new Point(s, skateboard.y));
			
			Tweener.addTween(levelRotator, { 
				rotation:manager.baseRotationX, 
				time:TRICK_TIME * .4,
				transition:"easeInOutQuart",
				onComplete:drop 
			} );
			
			climb();
		}
		
		private function climb(e:Event=null):void {
			Tweener.addTween(this, { 
				y:jumpHeight,
				time:TRICK_TIME * .4,
				transition:"easeInOutSine"
			} );
		}
		
		private function drop():void {
			phase = DROP;
			var dx:Number = (wheelieTarget == null) ? 0 : wheelieTarget.wheelieBasePosition[0];
			var dy:Number = (wheelieTarget == null) ? manager.terrainLevel : wheelieTarget.wheelieBasePosition[1];
			var dr:Number = (wheelieTarget == null) ? manager.baseRotationX : wheelieTarget.wheelieBasePosition[2];
			
			var func:Function = (wheelieTarget == null) ? land : end;
			
			//Debug.log("Drop: " + dx + " / " + dy + " / " + dr);
			
			Tweener.addTween(this, { 
				x:dx,
				y:dy,
				rotation:dr,
				time:TRICK_TIME * .4,
				transition:"easeInQuad",
				onComplete:func 
			} );
		}
		
		private function land():void {
			phase = BOUNCE;
			landed = true;
			//Debug.log("Land");
			var sign:int = (Math.random() > .5) ? -1 : 1;
			landingBounce = (3 + Math.random() * 3) * sign * (jumpHeight / MAX_HEIGHT);

			Tweener.addTween(this, { 
				bounce:Math.PI,
				time:TRICK_TIME * .2,
				transition:"easeOutSine",
				onComplete:end 
			} );
			
			skateboard.deck.tiltDeck(jumpHeight / 50, .3);
		}
		
		override protected function finalizeTrick():void {
			//Debug.log("Ollie.finalize");
			if (wheelieTarget != null) {
				wheelieTarget.startFromOllie(speed, playbackSpeed);
			} else {
				skateboard.rotationX = manager.baseRotationX;
				skateboard.z = 0;
				skateboard.y = manager.terrainLevel;
			}
		}
		
		public function get rotation():Number {
			return skateboard.rotationX;
		}
		
		public function set rotation(r:Number):void {
			skateboard.rotationX = r;
		}
		
		public function get x():Number {
			return skateboard.z;
		}
		
		public function set x(nx:Number):void {
			skateboard.z = nx;
		}
		
		public function get y():Number {
			return skateboard.y;
		}
		
		public function set y(ny:Number):void {
			skateboard.y = ny;
		}
		
		public function get bounce():Number {
			return skateboard.y;
		}
		
		public function set bounce(a:Number):void {
			skateboard.rotationX = manager.baseRotationX + Math.sin(a) * landingBounce;
			skateboard.y = Math.sin(a) * Math.abs(landingBounce) * 3;
		}
		
		public function setWheelieTarget(wt:Wheelie):void {
			wheelieTarget = wt;
		}
	}
}