package {
import flash.display.MovieClip;
import flash.display.Loader;
import flash.events.*;
import flash.text.*;
import flash.net.URLRequest;
import flash.utils.*;
import flash.net.*;
import flash.ui.Keyboard;
import flash.utils.getTimer;
import flash.geom.*;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import com.adobe.crypto.MD5;
import flash.desktop.*;
import djarts.core.*;
import djarts.events.*;
import djarts.components.*;
import djarts.utils.*;
import djarts.resources.*;
import djarts.display.*;
import djarts.utils.Base64;
import com.adobe.images.JPGEncoder;
import flash.display.BitmapData;
import com.adobe.serialization.json.JSON;
import com.adobe.serialization.json.*;
import flash.display.Stage3D;
import flash.display.Bitmap;
import Packer.AsyncGraphicPacker;
import Defs.GraphicDef;
import Defs.HeroDef;
import CharacterExport.CharacterExporter;
import CharacterExport.ExportBuilder;
import CharacterExport.PieceLibrary;
import GraphicExport.IconPacker;
import GraphicExport.SkelAnimPacker;
import Defs.MapDef;
import GraphicExport.AnimSetPacker;
import GraphicExport.AnimPiecePacker;
import GraphicExport.ScenePacker;
import flash.filesystem.*;
public class GraphicExport extends MovieClip
{
var UILayer:MovieClip = new MovieClip();
public static var ISLOCAL = true;
public static var wrapper:Socket = null;
private static var lastData = "";
public function GraphicExport()
{
GraphicFactory.FAILEDGRAPHICASBLANK = true;
GameSettings.ISLOCAL = true;
DialogManager.Instance().SetUILayer(UILayer);
DialogManager.Instance().SetUIOverLayer(UILayer);
DialogManager.Instance().ResolutionChanged(stage.width, stage.height);
this.stage.addChild(UILayer);
this.removeChild(newGraphicDialog);
Init();
try
{
NativeApplication.nativeApplication.addEventListener("invoke", ApplicationInvoked);
}
catch (e)
{
// not an air runtime app
ConnectWrapper(7890); // try default port
}
}
public function ApplicationInvoked(e)
{
if (e.arguments.length == 1)
{
ConnectWrapper(parseInt(e.arguments[0]));
}
else
{
StartUI();
}
}
private function WrapperIOError(e)
{
Log("Couldn't connect wrapper");
Log(e.toString());
StartUI();
}
private function WrapperConnect(e:Event)
{
wrapper = e.target as Socket;
Log("Wrapper Connected");
_strace("Wrapper Connected");
wrapper.addEventListener(ProgressEvent.SOCKET_DATA, WrapperData);
}
private function WrapperData(e:ProgressEvent)
{
var data:String = wrapper.readUTFBytes(wrapper.bytesAvailable);
for (var i = 0; i < data.length; i++)
{
var c = data.charAt(i);
if (c == "\0")
{
if (lastData != "") DispatchCommand(lastData);
lastData = "";
}
else
{
lastData += c;
}
}
}
private function DispatchCommand(command)
{
Log("Wrapper Command: " + command);
_strace("exeucting: " + command);
}
private function ConnectWrapper(port)
{
Log("Attempting to connect wrapper");
try
{
var s = new Socket();
s.addEventListener(IOErrorEvent.IO_ERROR, WrapperIOError);
s.addEventListener(Event.CONNECT, WrapperConnect);
s.connect("localhost", port);
} catch (e)
{
Log("Error establishing wrapper connection");
StartUI();
return;
}
}
public function Init()
{
_trace("Initializing game params!!");
//Set a scale mode for window resizing
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
GameSettings.GameplayArea = new Rectangle(0, 0, stage.stageWidth, stage.stageHeight);
ResourceManager.Instance().Init(ISLOCAL, "RootGame");
ResourceManager.Instance().SetLocations([""]);
GameSettings.Instance().SetStage(this.stage);
Globals.Instance().SetStage(this.stage);
FlashConsole.Instance().Admin = true;
stage.addEventListener(Event.ENTER_FRAME, EnterFrame);
stage.addEventListener(KeyboardEvent.KEY_UP, KeyUp);
this.addChild(previewHolder);
CreateUI();
ActivateExportButtons(false);
}
var exportButtons:Array = [];
public function ActivateExportButtons(active)
{
for(var i = 0; i < exportButtons.length; i++)
{
exportButtons[i].Enabled = active;
}
this.heuristicCheck.Enabled = active;
this.edgeExpand.Enabled = active;
this.skeletal_scale.type = active ? TextFieldType.INPUT : TextFieldType.DYNAMIC;
}
protected function CreateUI()
{
/*
var maxWidth = 0;
for (var i = 0; i < exportButtons.length; i++) maxWidth = Math.max(maxWidth, exportButtons[i].width);
var startX = buttonArea.x + (maxWidth / 2); //stage.stageWidth - 110;
var startY = buttonArea.y + 20;
for(var i = 0; i < exportButtons.length; i++)
{
this.addChild(exportButtons[i])
exportButtons[i].x = startX;
exportButtons[i].y = startY;
maxWidth = Math.max(maxWidth, exportButtons[i].width);
if (exportButtons[i].GetButtonText() == "Generic Use")
{
addChild(genericUseText);
genericUseText.x = startX - exportButtons[i].width / 2;
genericUseText.y = startY + 18;
startY += 25;
}
if (exportButtons[i].GetButtonText() == "Single ID")
{
addChild(singleIdText);
singleIdText.x = startX - exportButtons[i].width / 2;
singleIdText.y = startY + 18;
startY += 25;
}
if (exportButtons[i].GetButtonText() == "Single Asset")
{
addChild(singleAssetText);
singleAssetText.x = startX - exportButtons[i].width / 2;
singleAssetText.y = startY + 18;
startY += 25;
}
startY += 35;
if (startY > buttonArea.y + buttonArea.height - 20)
{
startY = buttonArea.y + 20;
startX += (maxWidth + 20);
maxWidth = 0;
}
}
*/
heuristicCheck.Checked = false;
heuristicCheck.OnClickParam = heuristicCheck;
heuristicCheck.OnClick = ClickedHeuristic;
heuristicCheck.Text = "Flat Animated Clip Heuristic";
edgeExpand.Checked = false;
edgeExpand.OnClickParam = edgeExpand;
edgeExpand.OnClick = ClickedEdgeExpand;
edgeExpand.Text = "Expand edge alpha.";
PNGExportHelper.UseExpandedBitmaps = true;
edgeExpand.Checked = PNGExportHelper.UseExpandedBitmaps;
this.skeletal_scale.addEventListener(Event.CHANGE, SkeletalScaleChanged);
}
public function StartUI()
{
ActivateExportButtons(true);
ShowNewGraphicDialog();
}
public function ShowNewGraphicDialog()
{
newGraphicDialog.Show(this);
}
public function ExportGraphicDef(graphicDef)
{
ExportItem(graphicDef.ID, DoneAll);
}
public function ExportGraphicDefs(graphicDefs:Array)
{
var graphicIDs = new Array();
for(var i = 0; i < graphicDefs.length; i++)
{
graphicIDs.push(graphicDefs[i].ID);
}
ExportItems(graphicIDs, DoneAll);
}
var skeletalScale = 1;
private function SkeletalScaleChanged(e:Event)
{
try
{
var number = Number(skeletal_scale.text);
skeletalScale = number;
} catch(exception){
}
}
private function ClickedHeuristic(button:Checkbox)
{
AsyncGraphicPacker.UseFlatHeuristic = !AsyncGraphicPacker.UseFlatHeuristic;
button.Checked = AsyncGraphicPacker.UseFlatHeuristic;
}
private function ClickedEdgeExpand(button:Checkbox)
{
PNGExportHelper.UseExpandedBitmaps = !PNGExportHelper.UseExpandedBitmaps;
button.Checked = PNGExportHelper.UseExpandedBitmaps;
}
var outputFormat = "json_png_set";
protected var lastTime = null;
protected function EnterFrame(e:Event)
{
var now = getTimer() / 1000.0;
if (lastTime == null) lastTime = now;
var timeElapsed = now - lastTime;
ResourceManager.Instance().StartUpdateLoop();
EnterFrameManager.Instance().EnterFrame(new TimeElapsedEvent(timeElapsed), timeElapsed);
ResourceManager.Instance().EndUpdateLoop();
HeroSpriteLoader.Instance().Update(1);
lastTime = now;
}
protected var graphicPreloader:GraphicPreloader = new GraphicPreloader();
protected function KeyUp(e:KeyboardEvent)
{
if (this.stage.focus is TextField) return;
if (e.keyCode == Keyboard.P)
{
HeroSpriteLoader.Instance().BeginLoadingHeroes(null);
graphicPreloader.PackHeros(/*true*/);
}
if (e.keyCode == Keyboard.I)
{
ExportAsset(1);
}
}
protected function ExportAll(doItems = true, doAssets = true, startingGraphicID = 1, endingGraphicID = 999999)
{
ActivateExportButtons(false);
var items:Array = [];
var assets:Array = [];
var defs:Array = GameData.Instance().GraphicDefines;
for (var i in defs)
{
if (defs[i].ID < startingGraphicID || defs[i].ID > endingGraphicID) continue;
if (defs[i].ExportParams.hasOwnProperty("asset_id"))
{
if (doAssets && assets.indexOf(defs[i].ExportParams.asset_id) == -1)
{
assets.push(defs[i].ExportParams.asset_id);
}
} else {
if (doItems && items.indexOf(defs[i].ID) == -1)
{
items.push(defs[i].ID);
}
}
}
ExportItems(items, function()
{
ExportAssets(assets, DoneAll);
});
}
protected function ExportByUse(useType, doItems = true, doAssets = true, startingGraphicID = 1, endingGraphicID = 999999)
{
ActivateExportButtons(false);
var items:Array = [];
var assets:Array = [];
var defs:Array = GameData.Instance().GraphicDefines;
for (var i in defs)
{
if (defs[i].ID < startingGraphicID || defs[i].ID > endingGraphicID) continue;
if (defs[i].ExportParams.hasOwnProperty("uses") && defs[i].ExportParams.uses.indexOf(useType) != -1)
{
if (defs[i].ExportParams.hasOwnProperty("asset_id"))
{
if (doAssets && assets.indexOf(defs[i].ExportParams.asset_id) == -1)
{
assets.push(defs[i].ExportParams.asset_id);
}
} else {
if (doItems && items.indexOf(defs[i].ID) == -1)
{
items.push(defs[i].ID);
}
}
}
}
ExportItems(items, function()
{
ExportAssets(assets, DoneAll);
});
}
protected function DoneAll()
{
ActivateExportButtons(true);
_trace("========= DONE ALL =========");
}
protected function ExportItems(items:Array, callback)
{
if (items.length == 0)
{
if (callback) callback();
} else {
var itemId = items.shift();
ExportItem(itemId, function(){ExportItems(items, callback);});
}
}
protected function ExportAssets(assets:Array, callback)
{
if (assets.length == 0)
{
if (callback) callback();
} else {
var assetId = assets.shift();
ExportAsset(assetId, function(){ExportAssets(assets, callback);});
}
}
protected var lastCallback;
protected function ExportItem(graphicId, callback = null)
{
this.lastCallback = callback;
var def:Defs.GraphicDef = GameData.Instance().GetGraphicDefByID(graphicId);
var graphicDefs:Array = [def];
var type = def.Type;
var assetDef:Defs.GraphicDef = null;
if (def.ExportParams.hasOwnProperty("asset_id"))
{
assetDef = GameData.Instance().GetGraphicDefByID(def.ExportParams.asset_id);
type = assetDef.Type;
}
switch (type)
{
case Defs.GraphicDef.EXPORT_FORMAT_SPRITESHEET:
if (def.ExportParams.hasOwnProperty("export_animation"))
{
var graphicPacker:AsyncGraphicPacker = new AsyncGraphicPacker();
graphicPacker.ExportDefs(graphicDefs, DoneAsset, def, outputFormat);
} else {
var iconPacker:IconPacker = new IconPacker(DoneAsset, def, previewHolder, outputFormat);
iconPacker.ExportDefs(graphicDefs);
}
break;
case Defs.GraphicDef.EXPORT_FORMAT_CACHEDCLIP:
break;
case Defs.GraphicDef.EXPORT_FORMAT_SKELANIM:
var skelPacker:SkelAnimPacker = new SkelAnimPacker(DoneAsset, def, previewHolder,
assetDef && assetDef.ExportParams.hasOwnProperty("export_type") ? assetDef.ExportParams.export_type : null, skeletalScale, outputFormat);
skelPacker.ExportDefs(graphicDefs);
break;
case Defs.GraphicDef.EXPORT_FORMAT_ANIMSETS:
var animSetPacker:AnimSetPacker = new AnimSetPacker(DoneAsset, def, previewHolder);
animSetPacker.ExportDef(graphicDefs[0]);
break;
case Defs.GraphicDef.EXPORT_FORMAT_ANIMPIECES:
var animPiecePacker:AnimPiecePacker = new AnimPiecePacker(DoneAsset, def, previewHolder);
animPiecePacker.ExportDefs(graphicDefs);
break;
case Defs.GraphicDef.EXPORT_FORMAT_SCENE:
var scenePacker:ScenePacker = new ScenePacker(DoneAsset, def, previewHolder, outputFormat);
scenePacker.ExportDef(graphicDefs[0]);
break;
default:
_trace("COULDN'T DETERMINE EXPORT FORMAT");
break;
}
}
protected function ExportAsset(assetId, callback = null)
{
ActivateExportButtons(false);
this.lastCallback = callback;
var graphicDefs:Array = [];
var defs:Array = GameData.Instance().GraphicDefines;
for (var i in defs)
{
if (defs[i].ExportParams.hasOwnProperty("asset_id") && defs[i].ExportParams.asset_id == assetId)
{
graphicDefs.push(defs[i]);
}
}
_trace(graphicDefs.length);
var assetDef:Defs.GraphicDef = GameData.Instance().GetGraphicDefByID(assetId);
if (assetDef)
{
switch (assetDef.Type)
{
case Defs.GraphicDef.EXPORT_FORMAT_SPRITESHEET:
if (assetDef.ExportParams.hasOwnProperty("export_animation"))
{
var graphicPacker:AsyncGraphicPacker = new AsyncGraphicPacker();
graphicPacker.ExportDefs(graphicDefs, DoneAsset, assetDef);
} else {
var iconPacker:IconPacker = new IconPacker(DoneAsset, assetDef, previewHolder, outputFormat);
iconPacker.ExportDefs(graphicDefs);
}
break;
case Defs.GraphicDef.EXPORT_FORMAT_CACHEDCLIP:
break;
case Defs.GraphicDef.EXPORT_FORMAT_SKELANIM:
var skelPacker:SkelAnimPacker = new SkelAnimPacker(DoneAsset, assetDef, previewHolder,
assetDef.ExportParams.hasOwnProperty("export_type") ? assetDef.ExportParams.export_type : null, skeletalScale);
skelPacker.ExportDefs(graphicDefs);
break;
case Defs.GraphicDef.EXPORT_FORMAT_ANIMSETS:
throw new Error("Assetified Animation Sets are not supported! (Just put multiple avatars in this def)");
break;
case Defs.GraphicDef.EXPORT_FORMAT_ANIMPIECES:
var animPiecePacker:AnimPiecePacker = new AnimPiecePacker(DoneAsset, assetDef, previewHolder);
animPiecePacker.ExportDefs(graphicDefs);
break;
default:
_trace("COULDN'T DETERMINE EXPORT FORMAT");
break;
}
}
}
// TODO: make this more generic...
public static const UPLOAD = 0;
public static const SAVE = 1;
public static const TEST = 2;
protected var saveMode = SAVE;
public function Log(logStr)
{
logText.text += logStr + "\n";
}
protected function DoneAsset(output, assetDef:Defs.GraphicDef)
{
Log(assetDef.Folder + assetDef.Name);
var fileExport:FileExportSet = null;
if (output is FileExportSet) fileExport = output;
if (output is JSONPNGSet)
{
fileExport = new FileExportSet();
output.AssetName = assetDef.Name;
fileExport.AddJSONPNGSet(output);
}
if (output is ByteArray)
{
fileExport = new FileExportSet();
fileExport.Add(assetDef.Name, output);
}
if (saveMode == SAVE)
{
fileExport.Save(lastCallback);
}
/*
if (saveMode == UPLOAD)
{
var uploadURL = "";
fileExport.Upload(uploadURL, assetDef.Folder, lastCallback);
}
*/
if (saveMode == TEST && lastCallback) lastCallback();
}
}
}
