package fkengine.

core
{
import away3d.animators.AnimatorBase;
import away3d.cameras.Camera3D;
import away3d.cameras.lenses.LensBase;
import away3d.cameras.lenses.OrthographicLens;
import away3d.containers.ObjectContainer3D;
import away3d.containers.View3D;
import away3d.controllers.HoverController;
import away3d.core.base.SubGeometryBase;
import away3d.core.managers.Stage3DManager;
import away3d.core.managers.Stage3DProxy;
import away3d.core.render.GameRenderer;
import away3d.debug.AwayStats;
import away3d.events.Stage3DEvent;
import away3d.materials.lightpickers.StaticLightPicker;
import fkengine.animator.Animator;
import fkengine.animator.Animator2D;
import fkengine.events.EngineEvents;
import fkengine.events.IMaskClickEvent;
import fkengine.events.InputEvents;
import fkengine.game.Connection;
import fkengine.gui.Components.RadiusMask.RadiusMaskView;
import fkengine.gui.Measures;
import fkengine.main.AppMain;
import fkengine.message.MessageHandler;
import fkengine.message.MessageReceiver;
import fkengine.utils.Defines;
import fkengine.utils.Utils;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.display.Stage;
import flash.errors.IllegalOperationError;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.TimerEvent;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.geom.Vector3D;
import flash.ui.Multitouch;
import flash.utils.Timer;
import flash.utils.getTimer;
import starling.animation.Tween;
import starling.core.Starling;
import starling.events.Event;
import starling.events.TouchEvent;
import starling.textures.Texture;

public class Engine implements MessageReceiver

{

private static var _frameSkipMechanismEnabled:Boolean;

public static var FPS_CALCULATOR_MECHANISM:Boolean = false;

public static var DESIRED_FPS_MECHANISM:Boolean = false;

public static var FRAMESKIP_MECHANISM_ENABLED:Boolean = false;

public static var FRAMESKIP_MECHANISM_BUFFER1:int = 32;

public static var FRAMESKIP_MECHANISM_BUFFER2:int = 4;

public static var FRAME_DISCARD_DIVIDER:int = 4;

private static var _instance:fkengine.core.Engine = null;

private static var _levelOfDetails:int;

private static var _pushedQuality:int = -1;

private var _frameSkipVector:Vector.<int>;

private var _frameTimeVector:Vector.<int>;

private var _meanFpsCount:Vector.<int>;

private var _numberOfFramesVector:Vector.<int>;

private var _currentFrameSkip:int = 0;

private var _frameSkip:int = 0;

public const DESIRED_FPS:Number = 16.666666666666668;

private var _view:Sprite;

private var _view3Ds:Vector.<View3D>;

private var _topView3Ds:Vector.<View3D>;

private var _stats3D:AwayStats;

private var _stage:Stage;

private var _rad:Number = 0;

private var _blackColor:Vector.<Number>;

private var _stage3DManager:Stage3DManager;

private var _stage3DProxy:Stage3DProxy;

private var _2d_front:Starling;

private var _2d_back:Starling;

private var _eventReceiver:EngineEvents;

private var _readyCount:int;

protected var _lightPicker:StaticLightPicker;

protected var _cameraController:HoverController;

private var _mouseIsDown:Boolean;

private var _lastPanAngle:Number;

private var _lastTiltAngle:Number;

private var _lastMouseX:Number;

private var _lastMouseY:Number;

private var _tiltIncrement:Number = 0;

private var _panIncrement:Number = 0;

private var _moon:ObjectContainer3D;

private var _lastFrameTime:int = 0;

private var _inputEventsReceiver:Vector.<InputEvents>;

private var _inputBeginPoint:Point;

private var _preloaderQueue:Vector.<fkengine.core.IPreloaderQueueItem>;

private var _preloadingCallback:fkengine.core.IPreloaderCallback;

private var _screenShotCallback:Boolean;

private var _backgrondColor:int;

private var _darkness:Number = 0;

private var _backgroundStartColor:uint;

private var _backgroundEndColor:uint;

private var _backgroundInterpolation:Number;

private var _callbacks:Vector.<Function>;

private var _animateBackground:Boolean;

private var _suspended:Boolean;

private var _starling2DText:Texture;

private var _tickers:Vector.<fkengine.core.IExpectedFrameTimer>;

private var _timer:Timer;

private var _timerPastTime:uint;

private var _frameDiscard:Number = 0;

private var _frameDrawCounter:Number = 0;

private var _test:int;

private var _previousFrameTime:int;

private var _requiredFpsAmount:int = 1;

private var _vecColor:Vector.<Number> = null;

private var _needsResetStage3D:Boolean;

public function Engine()

{
_frameSkipVector = new Vector.<int>();
_frameTimeVector = new Vector.<int>();
_meanFpsCount = new Vector.<int>();
_numberOfFramesVector = new Vector.<int>();
_view3Ds = new Vector.<View3D>();
_topView3Ds = new Vector.<View3D>();
_blackColor = new <Number>[0,0,0,0];
_inputBeginPoint = new Point();
_preloaderQueue = new Vector.<fkengine.core.IPreloaderQueueItem>();
_backgrondColor = Defines.BG_COLOR;
_callbacks = new Vector.<Function>();
_tickers = new Vector.<fkengine.core.IExpectedFrameTimer>();
super();
if(_instance)
{
throw new Error("Use getShared() instead");
}
_inputEventsReceiver = new Vector.<InputEvents>();
MessageHandler.listenToMessage(Defines.MESSAGE_WindowPause,this);
}

public static function getShared() : fkengine.core.Engine

{
_instance ||= new fkengine.core.Engine();
return _instance;
}

public static function set frameSkipMechanismEnabled(param1:Boolean) : void

{
_frameSkipMechanismEnabled = param1;
}

public static function pushQuality(param1:int, param2:Boolean) : void

{
_pushedQuality = param1;
if(param2)
{
Measures.pushDownsamplingEnabled();
}
else
{
Measures.pushDownsamplingDisabled();
}
}

public static function popQuality() : void

{
_pushedQuality = -1;
Measures.popDownsamplingEnabled();
}
 public static function get levelOfDetails() : int
{
return 9;
}

public function get backgroundColor() : int

{
return _backgrondColor;
}

final public function get requiredFpsAmount2() : int

{
var _loc1_:int = this._requiredFpsAmount * _requiredFpsAmount;
if(_loc1_ > 4)
{
_loc1_ = 4;
}
return _loc1_;
}

final public function get requiredFpsAmount() : int

{
return _requiredFpsAmount;
}

public function set backgroundColor(param1:int) : void

{
_backgrondColor = param1;
_vecColor = null;
}

public function get darkness() : Number

{
return _darkness;
}

public function set darkness(param1:Number) : void

{
_backgrondColor = Utils.interpolateColor(328965,2302755,param1);
_vecColor = null;
}

public function setAntiAliasing(param1:int) : void

{
_stage3DProxy.antiAlias = param1;
_needsResetStage3D = true;
}

public function messageReceived(param1:Object, param2:int, param3:Object) :

void
{
if(param2 == Defines.MESSAGE_WindowPause)
{
_screenShotCallback = param3;
}
if(param2 == Defines.MESSAGE_AppSuspended)
{
_suspended = true;
}
 if(param2 == Defines.MESSAGE_AppResumed)
{
if(_suspended)
{
_suspended = false;
_lastFrameTime = getTimer();
Animator2D.currentTimer = getTimer();
Animator.currentTimer = getTimer();
}
}
}

protected function onTimerTick(param1:TimerEvent) : void

{
if(_suspended)
{
_timerPastTime = -1;
return;
}
var _loc3_:uint = uint(getTimer() - _timerPastTime);
if(_timerPastTime == -1)
{
_timerPastTime = getTimer();
return;
}
_timerPastTime = getTimer();
if(_loc3_ < 17 * 1.2)
{
_loc3_ = 17;
}
for each(var _loc2_ in _tickers)
{
_loc2_.tick(_loc3_);
}
}

public function registerFrameTicker(param1:fkengine.core.IExpectedFrameTimer)

: void
{
_tickers.push(param1);
}

public function removeFrameTimer(param1:fkengine.core.IExpectedFrameTimer) :

void
{
var _loc2_:int = _tickers.indexOf(param1);
if(_loc2_ != -1)
{
_tickers.splice(_loc2_,1);
}
}

public function setLevelOfDetails(param1:int) : void

{
_levelOfDetails = param1;
}

public function get touchEnabled() : Boolean

{
 return _2d_front.touchProcessor.enabled;
}

public function set touchEnabled(param1:Boolean) : void

{
_2d_front.touchProcessor.enabled = param1;
}

public function registerForInputEvents(param1:InputEvents) : void

{
if(_inputEventsReceiver.indexOf(param1) == -1)
{
_inputEventsReceiver.push(param1);
}
}

public function unregisterForInputEvents(param1:InputEvents) : void

{
if(_inputEventsReceiver.indexOf(param1) != -1)
{
_inputEventsReceiver.splice(_inputEventsReceiver.indexOf(param1),1);
}
}

public function init(param1:Stage, param2:EngineEvents) : void

{
this._view = new Sprite();
this._stage = param1;
this._eventReceiver = param2;
param1.addEventListener("keyDown",keyDown);
param1.addEventListener("keyUp",keyUp);
MessageHandler.listenToMessage(Defines.MESSAGE_AppSuspended,this);
MessageHandler.listenToMessage(Defines.MESSAGE_AppResumed,this);
initProxies();
}

protected function keyDown(param1:KeyboardEvent) : void

{
var _loc3_:InputEventType = new InputEventType();
_loc3_.keyCode = param1.keyCode;
for each(var _loc2_ in _inputEventsReceiver)
{
_loc2_.userInputDispatchEvent(3,_loc3_);
}
}

protected function keyUp(param1:KeyboardEvent) : void

{
var _loc3_:InputEventType = new InputEventType();
_loc3_.keyCode = param1.keyCode;
for each(var _loc2_ in _inputEventsReceiver)
{
_loc2_.userInputDispatchEvent(4,_loc3_);
}
}

public function get stage() : Stage

{
return _stage;
 }

public function get stage3DProxy() : Stage3DProxy

{
return _stage3DProxy;
}

public function _mouseEvent(param1:TouchEvent) : void

{
}

public function objectRemoved(param1:starling.events.Event) : void

{
}

private function initProxies() : void

{
_stage3DManager = Stage3DManager.getInstance(_stage);
_stage3DProxy = _stage3DManager.getFreeStage3DProxy();
_stage3DProxy.addEventListener("Context3DCreated",onContextCreated);
var _loc1_:AppMain = AppMain;
_stage3DProxy.antiAlias = !!fkengine.main.AppMain._instance.isMobile ? 0 :
Utils.getCookieInt("msaa",2);
_stage3DProxy.color = 16777215;
Utils.setCurrentCirclePoints();
}

private function onContextCreated(param1:Stage3DEvent) : void

{
_stage3DProxy.addEventListener("enterFrame",renderFrame);
_stage3DProxy.context3D.enableErrorChecking = false;
if(_stage3DProxy.context3D.enableErrorChecking)
{
trace("!! WARNING :: STAGE3D DEBUG MODE !!");
}
else
{
trace("!! INFO :: STAGE3D STANDARD MODE !!");
}
initStarling();
}

private function initStarling() : void

{
var engine:fkengine.core.Engine;
var _loc7_:Boolean = true;
var _loc1_:Starling = Starling;
if(starling.core.Starling.sCurrent)
{
throw new flash.errors.IllegalOperationError("\'multitouchEnabled\'
must be set before Starling instance is created");
}
flash.ui.Multitouch.inputMode = _loc7_ ? "touchPoint" : "none";
var _loc2_:Measures = Measures;
var _loc3_:Measures = Measures;
_2d_back = new Starling(Layer2D,_stage,new
Rectangle(0,0,fkengine.gui.Measures._stageWidth,fkengine.gui.Measures._stageHeight)
,_stage3DProxy.stage3D,"auto","baselineConstrained",false);
var _loc4_:Measures = Measures;
 var _loc5_:Measures = Measures;
_2d_front = new Starling(Layer2D,_stage,new
Rectangle(0,0,fkengine.gui.Measures._stageWidth,fkengine.gui.Measures._stageHeight)
,_stage3DProxy.stage3D);
engine = this;

_2d_front.addEventListener("rootCreated",function(param1:starling.events.Event):voi
d
{
RadiusMaskView.initProgram(_2d_front);
_eventReceiver.engineReady(engine);
});
_2d_back.start();
_2d_front.start();
}

public function enableDownsampleSmoothing() : void

{
}

public function
registerPreloadingCallback(param1:fkengine.core.IPreloaderCallback) : void
{
_preloadingCallback = param1;
}

public function maskClickArea(param1:Vector3D, param2:Number,

param3:IMaskClickEvent) : void
{
_2d_front.touchProcessor.maskClickArea(param1,param2,param3);
}

public function animateBackground(param1:uint, param2:Number, param3:Boolean

= false) : void
{
_animateBackground = animateBackground;
_backgroundStartColor = _backgrondColor;
_backgroundEndColor = param1;
_backgroundInterpolation = 0;
var _loc4_:Tween;
(_loc4_ = new
Tween(this,param2)).animate("backgroundColorInterpolation",1);
var _loc5_:Starling = Starling;
(!!starling.core.Starling.sCurrent ?
starling.core.Starling.sCurrent.juggler : null).add(_loc4_);
}

public function get backgroundColorInterpolation() : Number

{
return _backgroundInterpolation;
}

public function set backgroundColorInterpolation(param1:Number) : void

{
_backgroundInterpolation = param1;
_backgrondColor =
Utils.interpolateColor(_backgroundStartColor,_backgroundEndColor,param1);
_vecColor = null;
}
 private function renderFrame(param1:flash.events.Event) : void
{
var _loc11_:View3D = null;
var _loc2_:PreloadingCompleteBroadcaster = null;
var _loc13_:int = 0;
var _loc12_:BitmapData = null;
var _loc7_:* = 0;
var _loc5_:int = 0;
if(_suspended)
{
return;
}
var _loc10_:int = getTimer();
Connection.processData();
Animator.currentTimer = _loc10_;
Animator2D.currentTimer = _loc10_;
var _loc9_:int = _lastFrameTime != 0 ? _loc10_ - _lastFrameTime : 0;
_lastFrameTime = _loc10_;
for each(_loc11_ in _view3Ds)
{
if(_loc11_.visible)
{
_loc11_.updateAnimationTime(Animator.currentTimer);
}
}
if(DESIRED_FPS_MECHANISM)
{
_frameDiscard += _loc9_;
_frameDrawCounter += _loc9_;
}
else
{
_frameDiscard = _frameDrawCounter = _loc9_;
}
var _loc4_:Number = Number(DESIRED_FPS_MECHANISM ? 16.666666666666668 :
_loc9_);
var _loc6_:int;
var _loc3_:* = _loc6_ = _frameDiscard == 0 ? 0 :
Math.round(_frameDiscard / _loc4_);
_frameDiscard -= _loc4_ * _loc6_;
if(_frameDiscard < 0)
{
_frameDiscard = 0;
}
Animator.update(_loc4_ * _loc6_);
Animator2D.update(_loc4_ * _loc6_);
for each(var _loc14_ in _callbacks)
{
_loc14_(_loc4_ * _loc6_);
}
if(DESIRED_FPS_MECHANISM && _loc6_ > 0)
{
if(_frameDiscard < _loc4_ / FRAME_DISCARD_DIVIDER)
{
_frameDiscard = 0;
}
if(FPS_CALCULATOR_MECHANISM == true && _frameSkipMechanismEnabled)
{
 _meanFpsCount.push(_loc6_);
if(_meanFpsCount.length > FRAMESKIP_MECHANISM_BUFFER1)
{
_meanFpsCount.shift();
}
}
§§push(Math);
§§push(Math);
var _loc29_:Vector.<int>;
if((_loc29_ = _meanFpsCount).length == 0)
{
§§push(0);
}
else
{
var _loc31_:Number = 0;
for each(var _loc30_ in _loc29_)
{
_loc31_ += _loc30_;
}
§§push(_loc31_ / _loc29_.length);
}
_requiredFpsAmount = §§pop().max(§§pop().round(§§pop()),1);
}
if(DESIRED_FPS_MECHANISM == true && FRAMESKIP_MECHANISM_ENABLED == true &&
_frameSkipMechanismEnabled == true && _frameDrawCounter < Math.floor(_loc4_) *
(_frameSkip + 1))
{
return;
}
_frameDrawCounter = 0;
_loc11_ = null;
AnimatorBase.beginFrame();
if(_preloaderQueue.length || _preloadingCallback != null)
{
_stage3DProxy.context3D.clear(0,0,0,0);
SubGeometryBase.unsetCurrentGeometry(_stage3DProxy);
_stage3DProxy.context3D.clear(0,0,0,0);
_preloaderQueue.length = 0;
if(_preloadingCallback)
{
_loc2_ = new PreloadingCompleteBroadcaster(_preloadingCallback);
_preloadingCallback = null;
_loc2_ = null;
}
_loc13_ = 0;
while(_loc13_ < 8)
{
_stage3DProxy.context3D.setTextureAt(_loc13_,null);
_loc13_++;
}
_loc13_ = 0;
while(_loc13_ < 8)
{
_stage3DProxy.context3D.setVertexBufferAt(_loc13_,null);
_loc13_++;
}
}
var _loc15_:int = _backgrondColor;
 var _loc8_:Vector.<Number>;
_vecColor = _loc8_ = !!_vecColor ? _vecColor :
Utils.hexColorToFloat(_loc15_);
if(_needsResetStage3D == true)
{
_needsResetStage3D = false;
_stage3DProxy.clear();
}
_stage3DProxy.context3D.clear(_loc8_[0],_loc8_[1],_loc8_[2],1);
_2d_back.nextFrame();
for each(_loc11_ in _view3Ds)
{
if(_loc11_.visible)
{
SubGeometryBase.unsetCurrentGeometry(_stage3DProxy);
_loc11_.render();
}
}
_2d_front.nextFrame();
if(_screenShotCallback)
{
var _loc24_:Measures = Measures;
var _loc25_:Measures = Measures;
_loc12_ = new
BitmapData(fkengine.gui.Measures._stageWidth,fkengine.gui.Measures._stageHeight);
_stage3DProxy.context3D.drawToBitmapData(_loc12_);
var _loc26_:AppMain = AppMain;
fkengine.main.AppMain._napp.screenshotReceived(_loc12_);
_screenShotCallback = false;
}
else
{
_stage3DProxy.present();
}
if(FRAMESKIP_MECHANISM_ENABLED == true && _frameSkipMechanismEnabled ==
true)
{
_loc7_ = _loc9_;
_frameTimeVector.push(_loc7_);
if(_frameTimeVector.length > FRAMESKIP_MECHANISM_BUFFER1)
{
_frameTimeVector.shift();
}
var _loc32_:Vector.<int>;
if((_loc32_ = _frameTimeVector).length == 0)
{
§§push(0);
}
else
{
var _loc34_:Number = 0;
for each(var _loc33_ in _loc32_)
{
_loc34_ += _loc33_;
}
§§push(_loc34_ / _loc32_.length);
}
_loc5_ = §§pop();
_frameSkipVector.push(_loc5_ <= 18 ? 0 : 1);
 if(_frameSkipVector.length > FRAMESKIP_MECHANISM_BUFFER2)
{
_frameSkipVector.shift();
}
var _loc37_:int = 0;
var _loc36_:Vector.<int> = _frameSkipVector;
var _loc35_:int = 0;
var _loc38_:int = 0;
while(_loc38_ < _loc36_.length)
{
if(_loc36_[_loc38_] == _loc37_)
{
_loc35_++;
}
_loc38_++;
}
if(_loc35_ > FRAMESKIP_MECHANISM_BUFFER2 / 2)
{
_frameSkip = 0;
}
else
{
_frameSkip = 1;
}
}
}

private function sleep(param1:int) : void

{
var _loc2_:int = getTimer();
while(getTimer() - _loc2_ < param1)
{
}
}

final private function vectorCount(param1:Vector.<int>, param2:int) : int

{
var _loc4_:int = 0;
var _loc3_:int = 0;
_loc4_ = 0;
while(_loc4_ < param1.length)
{
if(param1[_loc4_] == param2)
{
_loc3_++;
}
_loc4_++;
}
return _loc3_;
}

final private function vectorMean(param1:Vector.<int>) : Number

{
if(param1.length == 0)
{
return 0;
}
var _loc3_:Number = 0;
for each(var _loc2_ in param1)
 {
_loc3_ += _loc2_;
}
return _loc3_ / param1.length;
}

private function initScene() : void

{
}

public function dispose3DViewport(param1:View3D) : void

{
if(_topView3Ds.indexOf(param1) != -1)
{
_topView3Ds.splice(_view3Ds.indexOf(param1),1);
}
else
{
_view3Ds.splice(_view3Ds.indexOf(param1),1);
}
if(param1)
{
param1.dispose();
}
}

public function create3DViewport(param1:LensBase = null, param2:Boolean =

false) : View3D
{
if(!param1)
{
param1 = new OrthographicLens();
}
var _loc4_:Camera3D = new Camera3D(param1);
var _loc3_:View3D = new View3D(null,_loc4_,param2 == false ? new
GameRenderer() : null);
_loc3_.stage3DProxy = _stage3DProxy;
_loc3_.shareContext = true;
_view.addChild(_loc3_);
_loc3_.camera.lens.far = 5000;
_loc3_.camera.lens.near = 100;
_loc3_.camera.position = new Vector3D(0,0,-100);
if(param2)
{
_topView3Ds.push(_loc3_);
}
else
{
_view3Ds.push(_loc3_);
}
return _loc3_;
}

public function resize() : void

{
}

public function getGUILayer() : Layer2D

{
 return this.getFrontLayer();
}

public function getBackLayer() : Layer2D

{
return _2d_back.root as Layer2D;
}

public function getFrontLayer() : Layer2D

{
return _2d_front.root as Layer2D;
}

public function restoreTouch() : void

{
return _2d_front.touchProcessor.restoreTouch();
}

public function dispose() : void

{
for each(var _loc1_ in _view3Ds)
{
_stats3D.unregisterView(_loc1_);
_loc1_.dispose();
}
_view3Ds = null;
_2d_front.stop();
_2d_front.dispose();
_2d_front = null;
_2d_back.dispose();
_2d_back = null;
}

public function getView() : Sprite

{
return _view;
}

public function queuePreloading(param1:fkengine.core.IPreloaderQueueItem) :

void
{
for each(var _loc2_ in _preloaderQueue)
{
if(_loc2_.preloaderEqualsTo(param1))
{
return;
}
}
_preloaderQueue.push(param1);
}

public function registerCallback(param1:Function) : void

{
if(_callbacks.indexOf(param1) == -1)
{
_callbacks.push(param1);
}
}
 public function unregisterCallback(param1:Function) : void
{
var _loc2_:int = _callbacks.indexOf(param1);
if(_loc2_ != -1)
{
_callbacks.splice(_loc2_,1);
}
}
}
}