{

import com.mignari.workers.IWorkerCommunicator;

import com.mignari.workers.WorkerCommand;

import com.mignari.workers.WorkerCommunicator;

import flash.display.BitmapData;

import flash.display.Sprite;

import flash.events.ErrorEvent;

import flash.events.Event;

import flash.filesystem.File;

import flash.geom.Rectangle;

import flash.utils.ByteArray;

import flash.utils.Dictionary;

import mx.resources.ResourceManager;

import nail.errors.NullArgumentError;

import nail.errors.NullOrEmptyArgumentError;

import nail.image.ImageCodec;

import nail.image.ImageFormat;

import nail.logging.Log;

import nail.utils.FileUtil;

import nail.utils.SaveHelper;

import nail.utils.StringUtil;

import nail.utils.VectorUtils;

import nail.utils.isNullOrEmpty;

import flash.utils.setTimeout;

import nail.utils.FileQueueHelper;

import ob.commands.FindResultCommand;

import ob.commands.HideProgressBarCommand;

import ob.commands.LoadVersionsCommand;

import ob.commands.LoadSpriteDimensionsCommand;

import ob.commands.NeedToReloadCommand;

import ob.commands.ProgressBarID;

import ob.commands.ProgressCommand;

import ob.commands.SetClientInfoCommand;

import ob.commands.SettingsCommand;

import ob.commands.files.CompileAsCommand;

import ob.commands.files.CompileCommand;

import ob.commands.files.CreateNewFilesCommand;

import ob.commands.files.LoadFilesCommand;

import ob.commands.files.MergeFilesCommand;

import ob.commands.files.UnloadFilesCommand;

import ob.commands.sprites.ExportSpritesCommand;

import ob.commands.sprites.FindSpritesCommand;

import ob.commands.sprites.GetSpriteListCommand;

import ob.commands.sprites.ImportSpritesCommand;

import ob.commands.sprites.ImportSpritesFromFileCommand;

import ob.commands.sprites.NewSpriteCommand;

import ob.commands.sprites.OptimizeSpritesCommand;

import ob.commands.sprites.OptimizeSpritesResultCommand;

import ob.commands.sprites.RemoveSpritesCommand;

import ob.commands.sprites.ReplaceSpritesCommand;

import ob.commands.sprites.ReplaceSpritesFromFilesCommand;

import ob.commands.sprites.SetSpriteListCommand;

import ob.commands.things.DuplicateThingCommand;

import ob.commands.things.ExportThingCommand;

import ob.commands.things.FindThingCommand;

import ob.commands.things.GetThingCommand;

import ob.commands.things.GetThingListCommand;

import ob.commands.things.ImportThingsCommand;

import ob.commands.things.ImportThingsFromFilesCommand;

import ob.commands.things.NewThingCommand;

import ob.commands.things.RemoveThingCommand;

import ob.commands.things.ReplaceThingsCommand;

import ob.commands.things.ReplaceThingsFromFilesCommand;

import ob.commands.things.SetThingDataCommand;

import ob.commands.things.SetThingListCommand;

import ob.commands.things.UpdateThingCommand;

import ob.commands.things.BulkUpdateThingsCommand;

import ob.commands.things.PasteThingDataCommand;

import ob.commands.things.UpdateThingPropertiesCommand;

import ob.commands.things.OptimizeFrameDurationsCommand;

import ob.commands.things.OptimizeFrameDurationsResultCommand;

import ob.commands.things.CreateMissingItemsCommand;

import ob.commands.things.ReloadItemAttributesCommand;

import ob.settings.ObjectBuilderSettings;

import ob.utils.SpritesFinder;

import otlib.items.ServerItemStorage;

import otlib.items.ServerItem;

import otlib.items.ServerItemType;

import otlib.items.TileStackOrder;

import otlib.items.OtbSync;

import otlib.events.ThingListEvent;

import otlib.utils.OtlibUtils;

import otlib.animation.FrameDuration;

import otlib.animation.FrameGroup;

import otlib.core.Version;

import otlib.core.VersionStorage;

import otlib.core.ClientFeatures;

import otlib.events.ProgressEvent;

import otlib.loaders.PathHelper;

import otlib.loaders.SpriteDataLoader;

import otlib.loaders.ThingDataLoader;

import otlib.obd.OBDEncoder;

import otlib.obd.OBDVersions;

import otlib.resources.Resources;

import otlib.sprites.SpriteData;

import otlib.sprites.SpriteStorage;

import otlib.storages.events.StorageEvent;

import otlib.things.FrameGroupType;

import otlib.things.ThingCategory;

import otlib.things.ThingData;

import otlib.things.ThingProperty;

import otlib.things.ThingType;

import otlib.things.ThingTypeStorage;

import otlib.utils.ChangeResult;

import otlib.utils.ClientInfo;

import otlib.utils.ClientMerger;

import otlib.utils.OTFI;

import otlib.utils.OTFormat;

import otlib.utils.SpritesOptimizer;

import otlib.utils.ThingListItem;

import otlib.utils.FrameDurationsOptimizer;

import otlib.utils.FrameGroupsConverter;

import otlib.core.SpriteDimensionStorage;

import otlib.utils.SpriteExtent;

import ob.commands.SetSpriteDimensionCommand;

import ob.commands.things.ConvertFrameGroupsCommand;

import ob.commands.things.ConvertFrameGroupsResultCommand;

import otlib.utils.ThingUtils;

import otlib.items.ItemAttributeStorage;

[ResourceBundle("strings")]

public class ObjectBuilderWorker extends flash.display.Sprite

{

// --------------------------------------------------------------------------

// PROPERTIES

// --------------------------------------------------------------------------

private var _communicator:IWorkerCommunicator;

private var _things:ThingTypeStorage;

private var _sprites:SpriteStorage;

private var _datFile:File;

private var _sprFile:File;

private var _version:Version;

private var _features:ClientFeatures;

private var _errorMessage:String;

private var _compiled:Boolean;

private var _isTemporary:Boolean;

private var _thingListAmount:uint;

private var _spriteListAmount:uint;

private var _settings:ObjectBuilderSettings;

// OTB support

private var _items:ServerItemStorage;

private var _attributeRegistry:ItemAttributeStorage;

private static const BATCH_SIZE:uint = 50;

// Reusable render buffer to avoid BitmapData allocation churn

private static var _renderBuffer:BitmapData;

private static var _renderBufferSize:uint = 0;

// --------------------------------------

// Getters / Setters

// --------------------------------------

public function get clientChanged():Boolean

{

return ((_things && _things.changed) || (_sprites && _sprites.changed) || (_items && _items.changed));

}

public function get clientIsTemporary():Boolean

{

return (_things && _things.isTemporary && _sprites && _sprites.isTemporary);

}

public function get clientLoaded():Boolean

{

return (_things && _things.loaded && _sprites && _sprites.loaded);

}

public function get otbLoaded():Boolean

{

return (_items && _items.loaded);

}

// --------------------------------------------------------------------------

// CONSTRUCTOR

// --------------------------------------------------------------------------

public function ObjectBuilderWorker()

{

super();

Resources.manager = ResourceManager.getInstance();

_communicator = new WorkerCommunicator();

Log.commnunicator = _communicator;

_thingListAmount = 100;

_spriteListAmount = 100;

// Initialize ItemAttributeStorage in the worker thread

try

{

var attrPath:String = File.applicationDirectory.resolvePath("config/attributes").nativePath;

_attributeRegistry = ItemAttributeStorage.getInstance();

_attributeRegistry.initialize(attrPath);

}

catch (e:Error)

{

Log.error("Failed to initialize ItemAttributeStorage in worker: " + e.message);

}

register();

}

// --------------------------------------------------------------------------

// METHODS

// --------------------------------------------------------------------------

// --------------------------------------

// Public

// --------------------------------------

public function getThingCallback(id:uint, category:String):void

{

sendThingData(id, category);

}

public function compileCallback():void

{

var serverItemsPath:String = null;

var serverItemsFormat:String = OTFormat.XML;

var serverItemsBinaryPeer:String = null;

if (_items && _items.loaded && _items.file)

{

serverItemsPath = _items.file.nativePath;

// Determine format from loaded definition format (e.g. XML or TOML)

if (_items.definitionFormat)

{

serverItemsFormat = _items.definitionFormat;

}

// Determine binary peer from binaryFormat or file extension

if (_items.binaryFormat)

{

serverItemsBinaryPeer = _items.binaryFormat;

}

else if (_items.file.extension && _items.file.extension.toLowerCase() == "otb")

{

serverItemsBinaryPeer = OTFormat.OTB;

}

}

compileAsCallback(_datFile.nativePath,

_sprFile.nativePath,

serverItemsPath,

serverItemsFormat,

serverItemsBinaryPeer,

_version,

_features);

}

public function setSelectedThingIds(value:Vector.<uint>, category:String, forceUpdate:Boolean = false):void

{

if (value && value.length > 0)

{

if (value.length > 1)

{

value.sort(Array.NUMERIC | Array.DESCENDING);

}

var max:uint = _things.getMaxId(category);

if (value[0] > max)

{

value = Vector.<uint>([max]);

}

sendThingList(value, category, forceUpdate);

}

}

public function setSelectedSpriteIds(value:Vector.<uint>, forceUpdate:Boolean = false):void

{

if (value && value.length > 0)

{

if (value.length > 1)

{

value.sort(Array.NUMERIC | Array.DESCENDING);

}

if (value[0] > _sprites.spritesCount)

{

value = Vector.<uint>([_sprites.spritesCount]);

}

sendSpriteList(value, forceUpdate);

}

}

public function sendCommand(command:WorkerCommand):void

{

_communicator.sendCommand(command);

}

// --------------------------------------

// Override Protected

// --------------------------------------

public function register():void

{

// Register classes.

_communicator.registerClass(ByteArray);

_communicator.registerClass(ClientInfo);

_communicator.registerClass(FrameDuration);

_communicator.registerClass(FrameGroup);

_communicator.registerClass(ObjectBuilderSettings);

_communicator.registerClass(PathHelper);

_communicator.registerClass(SpriteData);

_communicator.registerClass(ThingData);

_communicator.registerClass(ThingListItem);

_communicator.registerClass(ThingProperty);

_communicator.registerClass(ThingType);

_communicator.registerClass(Version);

_communicator.registerClass(ClientFeatures);

_communicator.registerCallback(SettingsCommand, settingsCallback);

_communicator.registerCallback(LoadVersionsCommand, loadClientVersionsCallback);

_communicator.registerCallback(LoadSpriteDimensionsCommand, loadSpriteDimensionsCallback);

_communicator.registerCallback(SetSpriteDimensionCommand, setSpriteDimensionCallback);

// File commands

_communicator.registerCallback(CreateNewFilesCommand, createNewFilesCallback);

_communicator.registerCallback(LoadFilesCommand, loadFilesCallback);

_communicator.registerCallback(MergeFilesCommand, mergeFilesCallback);

_communicator.registerCallback(CompileCommand, compileCallback);

_communicator.registerCallback(CompileAsCommand, compileAsCallback);

_communicator.registerCallback(UnloadFilesCommand, unloadFilesCallback);

// Thing commands

_communicator.registerCallback(NewThingCommand, newThingCallback);

_communicator.registerCallback(UpdateThingCommand, updateThingCallback);

_communicator.registerCallback(ImportThingsCommand, importThingsCallback);

_communicator.registerCallback(ImportThingsFromFilesCommand, importThingsFromFilesCallback);

_communicator.registerCallback(ExportThingCommand, exportThingCallback);

_communicator.registerCallback(ReplaceThingsCommand, replaceThingsCallback);

_communicator.registerCallback(ReplaceThingsFromFilesCommand, replaceThingsFromFilesCallback);

_communicator.registerCallback(DuplicateThingCommand, duplicateThingCallback);

_communicator.registerCallback(BulkUpdateThingsCommand, bulkUpdateThingsCallback);

_communicator.registerCallback(RemoveThingCommand, removeThingsCallback);

_communicator.registerCallback(GetThingCommand, getThingCallback);

_communicator.registerCallback(GetThingListCommand, getThingListCallback);

_communicator.registerCallback(FindThingCommand, findThingCallback);

_communicator.registerCallback(OptimizeFrameDurationsCommand, optimizeFrameDurationsCallback);

_communicator.registerCallback(ConvertFrameGroupsCommand, convertFrameGroupsCallback);

_communicator.registerCallback(PasteThingDataCommand, pasteThingDataCallback);

_communicator.registerCallback(CreateMissingItemsCommand, createMissingItemsCallback);

_communicator.registerCallback(ReloadItemAttributesCommand, reloadItemAttributesCallback);

// Sprite commands

_communicator.registerCallback(NewSpriteCommand, newSpriteCallback);

_communicator.registerCallback(ImportSpritesCommand, addSpritesCallback);

_communicator.registerCallback(ImportSpritesFromFileCommand, importSpritesFromFilesCallback);

_communicator.registerCallback(ExportSpritesCommand, exportSpritesCallback);

_communicator.registerCallback(ReplaceSpritesCommand, replaceSpritesCallback);

_communicator.registerCallback(ReplaceSpritesFromFilesCommand, replaceSpritesFromFilesCallback);

_communicator.registerCallback(RemoveSpritesCommand, removeSpritesCallback);

_communicator.registerCallback(GetSpriteListCommand, getSpriteListCallback);

_communicator.registerCallback(FindSpritesCommand, findSpritesCallback);

_communicator.registerCallback(OptimizeSpritesCommand, optimizeSpritesCallback);

// General commands

_communicator.registerCallback(NeedToReloadCommand, needToReloadCallback);

_communicator.start();

}

// --------------------------------------

// Private

// --------------------------------------

private function loadClientVersionsCallback(path:String):void

{

if (isNullOrEmpty(path))

throw new NullOrEmptyArgumentError("path");

VersionStorage.getInstance().load(new File(path));

}

private function loadSpriteDimensionsCallback(path:String):void

{

if (isNullOrEmpty(path))

throw new NullOrEmptyArgumentError("path");

SpriteDimensionStorage.getInstance().load(new File(path));

}

private function setSpriteDimensionCallback(value:String, size:uint, dataSize:uint):void

{

if (isNullOrEmpty(value))

throw new NullOrEmptyArgumentError("value");

if (isNullOrEmpty(size))

throw new NullOrEmptyArgumentError("size");

if (isNullOrEmpty(dataSize))

throw new NullOrEmptyArgumentError("dataSize");

SpriteExtent.DEFAULT_VALUE = value;

SpriteExtent.DEFAULT_SIZE = size;

SpriteExtent.DEFAULT_DATA_SIZE = dataSize;

}

private function settingsCallback(settings:ObjectBuilderSettings):void

{

if (isNullOrEmpty(settings))

throw new NullOrEmptyArgumentError("settings");

Resources.locale = settings.getLanguage()[0];

_thingListAmount = settings.objectsListAmount;

_spriteListAmount = settings.spritesListAmount;

_settings = settings;

}

private function createNewFilesCallback(datSignature:uint,

sprSignature:uint,

features:ClientFeatures):void

{

unloadFilesCallback();

_version = VersionStorage.getInstance().getBySignatures(datSignature, sprSignature);

_features = features.clone();

_features.applyVersionDefaults(_version.value);

// Update attribute server in registry

if (_features.attributeServer)

{

_attributeRegistry.loadServer(_features.attributeServer);

}

createStorage();

// Create things.

_things.createNew(_version, _features);

// Create sprites.

_sprites.createNew(_version, _features);

// Update preview.

var thing:ThingType = _things.getItemType(ThingTypeStorage.MIN_ITEM_ID);

getThingCallback(thing.id, thing.category);

// Send sprites.

sendSpriteList(Vector.<uint>([1]));

Log.info(Resources.getString("logCreatedNewFiles", _version.toString()));

}

private function createStorage():void

{

_things = new ThingTypeStorage(_settings);

_things.addEventListener(StorageEvent.LOAD, storageLoadHandler);

_things.addEventListener(StorageEvent.CHANGE, storageChangeHandler);

_things.addEventListener(ProgressEvent.PROGRESS, thingsProgressHandler);

_things.addEventListener(ErrorEvent.ERROR, thingsErrorHandler);

_sprites = new SpriteStorage();

_sprites.addEventListener(StorageEvent.LOAD, storageLoadHandler);

_sprites.addEventListener(StorageEvent.CHANGE, storageChangeHandler);

_sprites.addEventListener(ProgressEvent.PROGRESS, spritesProgressHandler);

_sprites.addEventListener(ErrorEvent.ERROR, spritesErrorHandler);

}

private function loadFilesCallback(datPath:String,

sprPath:String,

version:Version,

serverItemsPath:String,

features:ClientFeatures,

knownAttributes:Array = null):void

{

if (isNullOrEmpty(datPath))

throw new NullOrEmptyArgumentError("datPath");

if (isNullOrEmpty(sprPath))

throw new NullOrEmptyArgumentError("sprPath");

if (!version)

throw new NullArgumentError("version");

unloadFilesCallback();

_datFile = new File(datPath);

_sprFile = new File(sprPath);

_version = version;

_features = features.clone();

_features.applyVersionDefaults(_version.value);

// Update attribute server in registry

if (_features.attributeServer)

{

_attributeRegistry.loadServer(_features.attributeServer);

}

createStorage();

// 1/3 Loading DAT

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 0, 3, "Loading DAT"));

_things.load(_datFile, _version, _features);

// 2/3 Loading Server Items (if path was provided)

if (!isNullOrEmpty(serverItemsPath))

{

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 1, 3, "Loading Server Items"));

loadServerItemsCallback(serverItemsPath, null, knownAttributes);

}

// 3/3 Loading SPR

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 2, 3, "Loading SPR"));

_sprites.load(_sprFile, _version, _features);

}

private function mergeFilesCallback(datPath:String,

sprPath:String,

version:Version,

features:ClientFeatures):void

{

if (isNullOrEmpty(datPath))

throw new NullOrEmptyArgumentError("datPath");

if (isNullOrEmpty(sprPath))

throw new NullOrEmptyArgumentError("sprPath");

if (!version)

throw new NullArgumentError("version");

var datFile:File = new File(datPath);

var sprFile:File = new File(sprPath);

var mergeFeatures:ClientFeatures = features.clone();

mergeFeatures.applyVersionDefaults(version.value);

var merger:ClientMerger = new ClientMerger(_things, _sprites, _settings);

merger.addEventListener(ProgressEvent.PROGRESS, progressHandler);

merger.addEventListener(Event.COMPLETE, completeHandler);

merger.start(datFile, sprFile, version, mergeFeatures);

function progressHandler(event:ProgressEvent):void

{

sendCommand(new ProgressCommand(ProgressBarID.DEFAULT, event.loaded, event.total, event.label));

}

function completeHandler(event:Event):void

{

if (!_things || !_sprites)

{

sendCommand(new HideProgressBarCommand(ProgressBarID.DEFAULT));

return;

}

var category:String;

var id:uint;

if (merger.itemsCount != 0)

category = ThingCategory.ITEM;

else if (merger.outfitsCount != 0)

category = ThingCategory.OUTFIT;

else if (merger.effectsCount != 0)

category = ThingCategory.EFFECT;

else if (merger.missilesCount != 0)

category = ThingCategory.MISSILE;

if (category != null || merger.spritesCount != 0)

{

sendClientInfo();

if (merger.spritesCount != 0)

{

id = _sprites.spritesCount;

sendSpriteList(Vector.<uint>([id]));

}

if (category != null)

{

id = _things.getMaxId(category);

setSelectedThingIds(Vector.<uint>([id]), category);

}

}

sendCommand(new HideProgressBarCommand(ProgressBarID.DEFAULT));

// Log merge results

var parts:Array = [];

if (merger.itemsCount > 0)

parts.push(merger.itemsCount + " items");

if (merger.outfitsCount > 0)

parts.push(merger.outfitsCount + " outfits");

if (merger.effectsCount > 0)

parts.push(merger.effectsCount + " effects");

if (merger.missilesCount > 0)

parts.push(merger.missilesCount + " missiles");

if (merger.spritesCount > 0)

parts.push(merger.spritesCount + " sprites");

if (parts.length > 0)

{

Log.info(Resources.getString("logMerged", parts.join(", ")));

}

}

}

private function compileAsCallback(datPath:String,

sprPath:String,

serverItemsPath:String,

serverItemsFormat:String,

serverItemsBinaryPeer:String,

version:Version,

features:ClientFeatures):void

{

// ... skipped

if (isNullOrEmpty(datPath))

throw new NullOrEmptyArgumentError("datPath");

if (isNullOrEmpty(sprPath))

throw new NullOrEmptyArgumentError("sprPath");

if (!version)

throw new NullArgumentError("version");

if (!_things || !_things.loaded)

throw new Error(Resources.getString("metadataNotLoaded"));

if (!_sprites || !_sprites.loaded)

throw new Error(Resources.getString("spritesNotLoaded"));

var dat:File = new File(datPath);

var spr:File = new File(sprPath);

var structureChanged:Boolean = _features.differs(features);

// Update attribute server in registry using the features passed to compile

if (features.attributeServer)

{

_attributeRegistry.loadServer(features.attributeServer);

}

// 1/3 Saving DAT

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 0, 3, "Saving DAT"));

if (!_things.compile(dat, version, features))

{

return;

}

// 2/3 Saving SPR

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 1, 3, "Saving SPR"));

if (!_sprites.compile(spr, version, features))

{

return;

}

// 3/3 Exporting Server Items (if requested)

if (!isNullOrEmpty(serverItemsPath))

{

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 2, 3, "Exporting Server Items"));

var itemsFile:File = new File(serverItemsPath);

var itemsDir:File = itemsFile.parent;

var baseName:String = itemsFile.name;

var dotIndex:int = baseName.lastIndexOf(".");

if (dotIndex != -1)

baseName = baseName.substring(0, dotIndex);

// 1. Export Definitions (XML/TOML)

var defFile:File = itemsDir.resolvePath(baseName + "." + (serverItemsFormat == OTFormat.TOML ? "toml" : "xml"));

if (!_items.saveDefinitions(defFile, serverItemsFormat))

{

Log.error("Failed to save server items to " + defFile.nativePath);

}

// 2. Export Binary Peer (OTB/DAT/ASSETS)

if (serverItemsBinaryPeer != null)

{

var peerExtension:String = "otb";

if (serverItemsBinaryPeer == OTFormat.DAT)

peerExtension = "dat";

else if (serverItemsBinaryPeer == OTFormat.ASSETS)

peerExtension = "dat";

var peerFile:File = itemsDir.resolvePath(baseName + "." + peerExtension);

if (!_items.save(peerFile, serverItemsBinaryPeer, dat))

{

Log.error("Failed to save/export binary peer: " + peerFile.nativePath);

}

}

}

// Save .otfi file

var dir:File = FileUtil.getDirectory(dat);

var otfiFile:File = dir.resolvePath(FileUtil.getName(dat) + ".otfi");

var otfi:OTFI = new OTFI(features, dat.name, spr.name, SpriteExtent.DEFAULT_SIZE, SpriteExtent.DEFAULT_DATA_SIZE);

otfi.save(otfiFile);

// Complete

sendCommand(new ProgressCommand(ProgressBarID.METADATA, 3, 3, "Saving complete"));

clientCompileComplete();

if (!_datFile || !_sprFile)

{

_datFile = dat;

_sprFile = spr;

}

if (structureChanged)

sendCommand(new NeedToReloadCommand(features));

else

sendClientInfo();

}

private function unloadFilesCallback():void

{

if (_things)

{

_things.unload();

_things.removeEventListener(StorageEvent.LOAD, storageLoadHandler);

_things.removeEventListener(StorageEvent.CHANGE, storageChangeHandler);

_things.removeEventListener(ProgressEvent.PROGRESS, thingsProgressHandler);

_things.removeEventListener(ErrorEvent.ERROR, thingsErrorHandler);

_things = null;

}

if (_sprites)

{

_sprites.unload();

_sprites.removeEventListener(StorageEvent.LOAD, storageLoadHandler);

_sprites.removeEventListener(StorageEvent.CHANGE, storageChangeHandler);

_sprites.removeEventListener(ProgressEvent.PROGRESS, spritesProgressHandler);

_sprites.removeEventListener(ErrorEvent.ERROR, spritesErrorHandler);

_sprites = null;

}

_datFile = null;

_sprFile = null;

_version = null;

_features = null;

_errorMessage = null;

if (_items)

{

_items.unload();

_items.removeEventListener(ProgressEvent.PROGRESS, itemsProgressHandler);

_items = null;

}

}

/**

private function loadServerItemsCallback(serverItemsPath:String, itemsXmlPath:String = null, knownAttributes:Array = null):void

{

if (isNullOrEmpty(serverItemsPath))

{

Log.error(Resources.getString("otbPathEmpty")); // Keep resource key for now unless invalid

return;

}

var otbFile:File = new File(serverItemsPath);

if (!_items)

{

_items = new ServerItemStorage();

_items.addEventListener(ProgressEvent.PROGRESS, itemsProgressHandler);

}

// Set known attributes (injected from main thread)

if (knownAttributes)

{

_items.knownAttributeKeys = knownAttributes;

}

if (_items.load(otbFile))

{

// Update client info with otbLoaded state

sendClientInfo();

// Refresh the thing list to show server IDs

if (clientLoaded)

{

sendThingList(Vector.<uint>([ThingTypeStorage.MIN_ITEM_ID]), ThingCategory.ITEM);

}

Log.info(Resources.getString("logOtbLoaded", _items.items.count));

}

}

/**

private function createMissingItemsCallback(selectedId:uint):void

{

if (!_items || !_items.loaded)

{

Log.error(Resources.getString("noOtbLoaded", "create missing items"));

return;

}

if (!_things || !_things.loaded)

{

Log.error(Resources.getString("noDatLoaded", "create missing items"));

return;

}

// itemsCount returns the MAX item ID, not the count

var maxClientId:uint = _things.itemsCount;

var otbMaxClientId:uint = _items.items.getMaxClientId();

Log.info(Resources.getString("logCreateMissingItems", maxClientId, otbMaxClientId, _items.items.count));

var created:uint = _items.createMissingItems(maxClientId);

Log.info(Resources.getString("logCreatedOtbItems", created));

if (created > 0)

{

// Determine missing items to sync

var itemsToSync:Array = [];

for (var cid:uint = otbMaxClientId + 1; cid <= maxClientId; cid++)

{

var serverItem:ServerItem = _items.getItemByClientId(cid);

if (serverItem)

{

itemsToSync.push(serverItem);

}

}

if (itemsToSync.length > 0)

{

syncOtbItems(itemsToSync, true, true, "Syncing new items...");

}

// Mark OTB as changed to enable Compile

_items.invalidate();

// Update client info to reflect new OTB items count

sendClientInfo();

// Refresh the thing list preserving selection

var targetId:uint = selectedId > 0 ? selectedId : ThingTypeStorage.MIN_ITEM_ID;

sendThingList(Vector.<uint>([targetId]), ThingCategory.ITEM);

}

}

/**

private function reloadItemAttributesCallback(selectedId:uint, recalculateHashes:Boolean = false):void

{

if (!_items || !_items.loaded)

{

Log.error(Resources.getString("noOtbLoaded", "reload item attributes"));

return;

}

if (!_things || !_things.loaded)

{

Log.error(Resources.getString("noDatLoaded", "reload item attributes"));

return;

}

var items:Array = _items.items.toArray();

var progressLabel:String = recalculateHashes ? Resources.getString("reloadingWithHashes") : Resources.getString("reloadingItemAttributes");

var reloaded:uint = syncOtbItems(items, false, recalculateHashes, progressLabel);

Log.info(Resources.getString("logReloadedItems", reloaded));

// Mark OTB as changed to enable Compile

if (reloaded > 0)

{

_items.invalidate();

sendClientInfo();

}

// Refresh the thing list preserving selection

var targetId:uint = selectedId > 0 ? selectedId : ThingTypeStorage.MIN_ITEM_ID;

sendThingList(Vector.<uint>([targetId]), ThingCategory.ITEM);

}

private function syncOtbItems(items:Array, syncType:Boolean, recalculateHashes:Boolean = false, progressLabel:String = null):uint

{

if (!items || items.length == 0)

return 0;

var total:uint = items.length;

var processed:uint = 0;

var spriteStorageForHash:SpriteStorage = recalculateHashes ? _sprites : null;

if (!progressLabel)

progressLabel = Resources.getString("reloadingItemAttributes");

sendCommand(new ProgressCommand(ProgressBarID.DEFAULT, 0, total, progressLabel));

for each (var serverItem:ServerItem in items)

{

var thing:ThingType = _things.getItemType(serverItem.clientId);

if (thing)

{

OtbSync.syncFromThingType(serverItem, thing, syncType, _version.value, spriteStorageForHash);

processed++;

}

if (processed % 500 == 0)

{

sendCommand(new ProgressCommand(ProgressBarID.DEFAULT, processed, total, progressLabel));

}

}

sendCommand(new ProgressCommand(ProgressBarID.DEFAULT, total, total, Resources.getString("done")));

return processed;

}

/**

private function syncOrCreateItem(thingId:uint, category:String):void

{

if (!otbLoaded || category != ThingCategory.ITEM)

return;

var thing:ThingType = _things.getThingType(thingId, category);

if (!thing)

return;

var synced:Boolean = _items.updateItemsFromThing(thing, _version.value, _sprites);

if (!synced && _settings.syncOtbOnAdd)

{

createMissingItemsCallback(thingId);

}

}

private function newThingCallback(category:String):void

{

if (!ThingCategory.getCategory(category))

{

throw new Error(Resources.getString("invalidCategory"));

}

// ============================================================================

// Add thing

var thing:ThingType = ThingType.create(0, category, _features.frameGroups, _settings.getDefaultDuration(category));

var result:ChangeResult = _things.addThing(thing, category);

if (!result.done)

{

Log.error(result.message);

return;

}

// ============================================================================

// Sync with OTB

syncOrCreateItem(thing.id, category);

// ============================================================================

// Send changes

sendClientInfo();

// Send thing to preview.

getThingCallback(thing.id, category);

setSelectedThingIds(Vector.<uint>([thing.id]), category);

// Send message to log.

var message:String = Resources.getString(

"logAdded",

toLocale(category),

thing.id);

Log.info(message);

}

private function updateThingCallback(thingData:ThingData, replaceSprites:Boolean):void

{

if (!thingData)

{