Game.as

package
{
import com.legend.log.Logger;
import com.legend.manager.AppManager;

import flash.display.Sprite;
import flash.events.Event;
import flash.external.ExternalInterface;
import flash.net.URLVariables;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;

import org.as3lib.logging.ILogger;
import org.as3lib.logging.Log;

public class Game extends Sprite
{
CONFIG::debug
{
private static var logger:Logger = new Logger();

private var log:ILogger;
}

public function Game()
{
CONFIG::debug
{
log = Log.getLogger("Game");
}

this.addEventListener(Event.ADDED_TO_STAGE, onAddedToStageHandler);

}

private function onAddedToStageHandler(evt:Event):void
{
this.removeEventListener(Event.ADDED_TO_STAGE, onAddedToStageHandler);

debug_txt = new TextField();
debug_txt.selectable = false;
debug_txt.mouseEnabled = false;
debug_txt.autoSize = TextFieldAutoSize.LEFT;
debug_txt.width = 1000;
debug_txt.y = 20;
var tf:TextFormat = new TextFormat(null,12,0xFFFFFF);
debug_txt.defaultTextFormat = tf;
debug_txt.text = "start...";
stage.addChild(debug_txt);

if (ExternalInterface.available)
{
var params:String = ExternalInterface.call("getParams");

if (params.indexOf("?")!=-1)
{
var ary:Array = params.split("?");
var str:String=ary[ 1 ];
}
else
{
str=params;
}

var variables:URLVariables = new URLVariables(str);

CONFIG::debug
{
log.info(params);
}

launchGame( variables );
}
else
{
new LoadDebugConfig( launchGame );
}
}

public static function showDebug(val:String):void
{
if (debug_txt)
{
debug_txt.text = val;
debug_txt.parent.setChildIndex(debug_txt,debug_txt.parent.numChildren - 1);
trace("debug info:",val);
}
}

private function onDebugHandler(evt:* = null):void
{
debug_txt.text = "";
debug_txt.text = String(evt.data.desc);
debug_txt.parent.setChildIndex(debug_txt,debug_txt.parent.numChildren - 1);
}

private function launchGame(params:Object):void
{
CONFIG::debug
{
if (params.log_level)
{
logger.level = params.log_level;
}
if (params.log_filters)
{
logger.filters = [params.log_filters];
}
}

appManager = new AppManager(stage, params);
}

private var appManager:AppManager;

private static var debug_txt:TextField;

}
}

import flash.events.Event;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLVariables;

class LoadDebugConfig
{
public function LoadDebugConfig(execute:Function)
{
this.execute = execute;

var loader:URLLoader = new URLLoader();
loader.addEventListener(Event.COMPLETE, onConfigLoaded);
loader.load( new URLRequest(".dev") );
}

private function onConfigLoaded(evt:Event):void
{
var params:URLVariables = new URLVariables();
params.decode( evt.target.data );

execute( params );
}

private var execute:Function;
}

iLoader.as

package
{
import com.legend.loader.BasicLoader;
import com.legend.loader.SWFLoader;

import flash.display.Sprite;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.events.Event;
import flash.events.ProgressEvent;
import flash.events.TimerEvent;
import flash.external.ExternalInterface;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.utils.Timer;

[SWF(width = "1000", height = "618", backgroundColor = "0x0", frameRate = "30")]

public class iLoader extends Sprite
{
public static var PATH:String = "";

public static var VCM:Function;

public static var debug_txt:TextField;

public function iLoader()
{
stage.scaleMode = StageScaleMode.NO_SCALE;
stage.align = StageAlign.TOP_LEFT;
stage.stageFocusRect = false;
initDebugTxt();
if (ExternalInterface.available)
{
var timer:Timer = new Timer(100);
timer.addEventListener(TimerEvent.TIMER, checkExternalParams);
timer.start();
}
else
{
loadVersionFile();
}
}

private function initDebugTxt():void
{
debug_txt = new TextField();
debug_txt.selectable = false;
debug_txt.mouseEnabled = false;
debug_txt.autoSize = TextFieldAutoSize.CENTER;
debug_txt.x = stage.stageWidth/2;
debug_txt.y = (stage.stageHeight-20)/2;
debug_txt.defaultTextFormat = new TextFormat(null,32,0xFFFFFF);
debug_txt.text = "加载中，请稍后...";
this.addChild(debug_txt);
}

private function removeDebugTxt():void
{
if (debug_txt && debug_txt.parent)
{
debug_txt.parent.removeChild(debug_txt);
debug_txt = null;
}
}

private function checkExternalParams(evt:TimerEvent):void
{
if (ExternalInterface.call("isReady"))
{
(evt.target as Timer).stop();

PATH = ExternalInterface.call("getCDNPath");

loadVersionFile();
}
else
{
(evt.target as Timer).delay += 100;
}
}

private function loadVersionFile():void
{
new VersionManager( loadGameFile );
}

private function loadGameFile():void
{
BasicLoader.PATH = PATH;
BasicLoader.VCM = VCM;

var loader:SWFLoader = new SWFLoader();
loader.addEventListener(Event.COMPLETE, startGame);
loader.addEventListener(ProgressEvent.PROGRESS, gameProgress);
loader.Load( "Game.swf", 2);
}

private function startGame(evt:*):void
{
this.addChildAt(evt.data, 0);
removeDebugTxt();
}

private function gameProgress(evt:*):void
{
var count:int = evt.data.bytesLoaded;
var total:int = evt.data.bytesTotal;
debug_txt.text = "加载中，请稍后(2/2)... "+int(count/total*100)+"%";
}
}
}

import com.legend.loader.BasicLoader;

import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.utils.ByteArray;
import flash.utils.Dictionary;

class VersionManager
{
public function VersionManager(ref:Function)
{
this.ref = ref;

currData = new Dictionary();

var loader:BasicLoader = new BasicLoader();
loader.addEventListener(Event.COMPLETE, onConfigLoadedHanler);
loader.addEventListener(ProgressEvent.PROGRESS, onStreamProgress);
loader.addEventListener(IOErrorEvent.IO_ERROR, onConfigErrorHandler);
loader.Load( (iLoader.PATH ? (iLoader.PATH + "/") : "") + "version.data");
}

public function getVersion(url:String):String
{
try
{
var version:String = currData[ fm(url) ];
if (version)
{
return version;
}
}
catch (e:Error)
{
trace(e.getStackTrace());
}

return getTilesVersion(url);
// return String(0);
}

private function getTilesVersion(url:String):String
{
if (url.indexOf("res")!=-1&&url.indexOf("scene")!=-1&&url.indexOf("tiles")!=-1)
{
var arr:Array=url.split("/");
var index:int=arr.indexOf("scene");
index++;
index=int(arr[index]);
url="res/scene/"+index+"/scene.config";

try
{
var version:String = currData[ fm(url) ];
if (version)
{
return version;
}
}
catch (e:Error)
{
trace(e.getStackTrace());
}
}
return "0";
}

private function fm(url:String):String
{
if (url.indexOf(iLoader.PATH + "/") != -1)
{
return url.substr( iLoader.PATH.length);
}
return url;
}

private function onConfigLoadedHanler(evt:Event):void
{
var byte:ByteArray = new ByteArray();
evt.target.readBytes( byte );
byte.uncompress();
currData = byte.readObject() as Dictionary;

iLoader.VCM = getVersion;
ref();
}

private function onStreamProgress(evt:ProgressEvent):void
{
var count:int = evt.bytesLoaded;
var total:int = evt.bytesTotal;
iLoader.debug_txt.text = "加载中，请稍后(1/2)... "+int(count/total*100)+"%";
}

private function onConfigErrorHandler(evt:Event):void
{
iLoader.VCM = getVersion;
ref();
}

private var currData:Dictionary;

private var ref:Function;
}