public bool uncompress()
{
bool result;
try
{
InflaterInputStream inflaterInputStream = new InflaterInputStream(new MemoryStream(this.m_data));
DynamicArray <byte> dynamicArray = new DynamicArray <byte>();
byte[] array = new byte[2048];
while (true)
{
int num = inflaterInputStream.Read(array, 0, array.Length);
bool flag = num > 0;
if (!flag)
{
break;
}
dynamicArray.pushBack(array, num);
}
inflaterInputStream.Close();
base.clear();
this.m_data = dynamicArray.data;
this.m_size = dynamicArray.length;
this.m_capcity = dynamicArray.capcity;
}
catch (Exception)
{
DebugTrace.print("Failed to uncompress ByteArray");
result = false;
return(result);
}
result = true;
return(result);
}
protected void _formatLangPackConf(Variant conf)
{
foreach (Variant current in conf["group"]._arr)
{
bool flag = !current.ContainsKey("id");
if (flag)
{
DebugTrace.print("ss");
}
bool flag2 = this.m_lPakMap.ContainsKey(current["id"]._str);
StringTable stringTable;
if (flag2)
{
stringTable = this.m_lPakMap[current["id"]._str];
}
else
{
stringTable = null;
}
bool flag3 = stringTable == null;
if (flag3)
{
stringTable = new StringTable();
this.m_lPakMap[current["id"]._str] = stringTable;
}
bool flag4 = current.ContainsKey("p");
if (flag4)
{
stringTable.loadStrings(current["p"]._arr);
}
}
}
public static void add(Define.DebugTrace type, string info)
{
string str = "[none]:";
bool flag = type == Define.DebugTrace.DTT_SYS;
if (flag)
{
str = "[sys]:";
}
else
{
bool flag2 = type == Define.DebugTrace.DTT_ERR;
if (flag2)
{
str = "[err]:";
}
else
{
bool flag3 = type == Define.DebugTrace.DTT_DTL;
if (flag3)
{
str = "[dtl]:";
}
}
}
DebugTrace._trace(str + info);
}
public override void loadImpl(bool bSync)
{
base.loadImpl(bSync);
bool flag = this.m_path == null || this.m_path == "";
if (!flag)
{
bool flag2 = this.m_ready || this.m_loading;
if (!flag2)
{
try
{
if (bSync)
{
Debug.Log("warnning::sync Sk renderTexture " + this.m_path);
this.m_renderTexture = new RenderTexture(1024, 720, 18);
this.m_loaded = true;
bool flag3 = this.m_renderTexture != null && this.m_renderTexture.width != 0 && this.m_renderTexture.height != 0;
if (flag3)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}
}
catch (Exception var_4_DF)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, " AssetRenderTexture Load file[" + this.m_path + "] err!");
}
}
}
}
public virtual void onRPC(uint cmdID, string cmdName, Variant par)
{
bool flag = cmdID != 9u;
if (flag)
{
DebugTrace.add(Define.DebugTrace.DTT_DTL, string.Concat(new object[]
{
"cvcon_onrpc with cmd[",
cmdID,
"][",
cmdName.Replace("\0", ""),
"]"
}));
DebugTrace.dumpObj(par);
}
bool flag2 = this.type == 1;
if (flag2)
{
bool flag3 = !SessionFuncMgr.instance.onRpc(cmdID, par);
if (flag3)
{
this.onRPCMsgProcesser(cmdID, cmdName, par);
}
}
else
{
this.onRPCMsgProcesser(cmdID, cmdName, par);
}
}
private void _type_package_cb_fn(Variant pkg_data, ByteArray tmp)
{
bool flag = ConnectionImpl.s_bShowNetLog;
if (flag)
{
Debug.Log("底层 type接收到消息包 -- ID " + pkg_data.dump());
}
bool flag2 = pkg_data["cmd"]._uint == 2u;
if (flag2)
{
this._isLogedin = (pkg_data["data"]["res"]._int == 1);
bool isLogedin = this._isLogedin;
if (isLogedin)
{
this._server_tm_diff_ms = (long)((ulong)(pkg_data["data"]["time"]._uint * 1000u) - (ulong)CCTime.getCurTimestampMS());
this._server_tm_diff_s = (long)((ulong)pkg_data["data"]["time"]._uint - (ulong)((long)CCTime.getCurTimestamp()));
this._cb.onLogin(pkg_data["data"]);
}
else
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Login failed: " + pkg_data["data"]["res"]._int);
}
}
else
{
this._cb.onTPKG(pkg_data["cmd"]._uint, pkg_data["data"]);
}
}
private static void _trace(string msg)
{
bool flag = DebugTrace.print != null;
if (flag)
{
DebugTrace.print(msg);
}
}
public void loadLanguagePacks(List <string> fileAry, Action onFin)
{
batchLoader <Action <string, Action> > batchLoader = new batchLoader <Action <string, Action> >(fileAry, new Action <string, Action>(this.loadLanguagePack));
batchLoader.loadNext(delegate(List <string> assetsLoaded, List <string> assetsFailed)
{
bool flag = assetsFailed.Count > 0;
if (flag)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "loadLanguagePacks load files[" + assetsFailed.ToString() + "] failed");
}
onFin();
});
}
public Variant getAvatarConf(string chaid)
{
bool flag = !this.m_avaConf["chaAvatar"].ContainsKey(chaid);
Variant result;
if (flag)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Could not find avarta config: [chaid=" + chaid + "]");
result = null;
}
else
{
result = this.m_avaConf["chaAvatar"][chaid];
}
return(result);
}
public static void dumpObj(object obj)
{
bool flag = obj is Variant;
if (flag)
{
DebugTrace.print((obj as Variant).dump());
}
else
{
bool flag2 = obj is ByteArray;
if (flag2)
{
DebugTrace.print((obj as ByteArray).dump());
}
}
}
public void loadExtendConfig(string file, Action <Variant> onFin)
{
bool flag = file.IndexOf('.') < 0;
if (flag)
{
file += ".xml";
}
ConfigLoadingData loadingData = new ConfigLoadingData();
bool flag2 = this.m_loadingExtendConfigMap.ContainsKey(file);
if (flag2)
{
loadingData = this.m_loadingExtendConfigMap[file];
loadingData.onFinCBs.Add(onFin);
}
else
{
loadingData.url = file;
loadingData.onFinCBs.Add(onFin);
this.m_loadingExtendConfigMap[file] = loadingData;
os.sys.parseXMLFromFile(file, delegate(Variant extendConf1)
{
bool flag3 = extendConf1 != null;
if (flag3)
{
this.m_loadingExtendConfigMap.Remove(loadingData.url);
foreach (Action <Variant> current in loadingData.onFinCBs)
{
current(extendConf1);
}
}
else
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Load Extend config file[" + file + "] error! msg:" + file);
this.m_loadingExtendConfigMap.Remove(loadingData.url);
Variant obj = new Variant();
foreach (Action <Variant> current2 in loadingData.onFinCBs)
{
current2(obj);
}
}
});
}
}
public virtual void onTPKG(uint cmdID, Variant par)
{
DebugTrace.add(Define.DebugTrace.DTT_DTL, "OnTPKG with cmd[" + cmdID + "]");
DebugTrace.dumpObj(par);
bool flag = this.type == 1;
if (flag)
{
bool flag2 = !SessionFuncMgr.instance.onTpkg(cmdID, par);
if (flag2)
{
this.onTPKGMsgProcesser(cmdID, par);
}
}
else
{
this.onTPKGMsgProcesser(cmdID, par);
}
}
public override void loadImpl(bool bSync)
{
base.loadImpl(bSync);
bool flag = this.m_path == null || this.m_path == "";
if (!flag)
{
bool flag2 = this.m_ready || this.m_loaded;
if (!flag2)
{
FileStream input = new FileStream(base.path, FileMode.Open, FileAccess.Read);
BinaryReader binaryReader = new BinaryReader(input);
try
{
char c = binaryReader.ReadChar();
char c2 = binaryReader.ReadChar();
char c3 = binaryReader.ReadChar();
char c4 = binaryReader.ReadChar();
int num = (int)binaryReader.ReadInt16();
this.m_pixelWidth = (int)binaryReader.ReadInt16();
this.m_pixelHeight = (int)binaryReader.ReadInt16();
this.m_proportion = binaryReader.ReadSingle();
this.m_heightMin = binaryReader.ReadSingle();
this.m_heightMax = binaryReader.ReadSingle();
this.m_produc = this.m_pixelWidth * this.m_pixelHeight;
this.m_byt = new byte[this.m_produc];
binaryReader.Read(this.byt, 0, this.m_produc);
}
catch (EndOfStreamException ex)
{
DebugTrace.print(ex.Message);
}
bool flag3 = string.Concat(this.m_pixelWidth) != null && string.Concat(this.m_pixelHeight) != null && string.Concat(this.m_heightMin) != null && string.Concat(this.m_heightMax) != null && string.Concat(this.m_proportion) != null && this.m_byt != null;
if (flag3)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this.m_loaded = true;
}
}
}
public Variant getAvatarConf(string chaid, string avaID)
{
bool flag = !this.m_avaConf["chaAvatar"].ContainsKey(chaid);
Variant result;
if (flag)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, string.Concat(new string[]
{
"Could not find avarta config: [chaid=",
chaid,
"] [avaid=",
avaID,
"]"
}));
result = null;
}
else
{
Variant variant = this.m_avaConf["chaAvatar"][chaid];
bool flag2 = !variant["ava"].ContainsKey(avaID);
if (flag2)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, string.Concat(new string[]
{
"Could not find avarta config: [chaid=",
chaid,
"] [avaid=",
avaID,
"]"
}));
result = null;
}
else
{
result = variant["ava"][avaID];
}
}
return(result);
}
public virtual void onTPKGMsgProcesser(uint cmdID, Variant par)
{
MsgProcesser msgProcesser = this._netMgr.createTpkgProcesser(cmdID, this, par);
bool flag = msgProcesser == null;
if (flag)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "tpkg msg id[" + cmdID + "] without processer");
}
else
{
bool immiProc = msgProcesser.immiProc;
if (immiProc)
{
msgProcesser.Process();
msgProcesser.Dispose();
this._netMgr.deleteMSGProcesser(msgProcesser);
}
else
{
this._MsgVec.Add(msgProcesser);
}
}
}
public override void loadImpl(bool bSync)
{
base.loadImpl(bSync);
bool flag = this.m_path == null || this.m_path == "";
if (!flag)
{
bool flag2 = this.m_ready || this.m_loading;
if (!flag2)
{
try
{
if (bSync)
{
Debug.Log("sync::Asset Audio " + this.m_path);
this.m_audioClip = Resources.Load <AudioClip>(this.m_path);
bool flag3 = this.m_audioClip != null;
if (flag3)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
this.m_length = this.m_audioClip.length;
this.m_loaded = true;
}
this._dispatchOnFins();
}
else
{
this.m_loading = true;
this.m_ready = false;
this.m_loaded = false;
new URLReqImpl
{
dataFormat = "assetbundle",
url = (this.m_path.IndexOf(".snd") < 0) ? (this.m_path + ".snd") : this.m_path
}.load(delegate(IURLReq r, object data)
{
this.m_audioClip = (data as AudioClip);
this.m_loading = false;
this.m_loaded = true;
bool flag4 = this.m_audioClip != null;
if (flag4)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
this.m_length = this.m_audioClip.length;
this.m_loaded = true;
}
this._dispatchOnFins();
}, delegate(IURLReq r, float progress)
{
bool flag4 = this.m_onProgs != null;
if (flag4)
{
this.m_onProgs(this, progress);
}
}, delegate(IURLReq r, string err)
{
this._dispatchOnFails(err);
this.m_loading = false;
this.m_loaded = true;
this.m_ready = false;
});
}
}
catch
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Failed to Load Audio: " + this.m_path);
}
}
}
}
public void load(Variant conf)
{
bool flag = conf == null;
if (!flag)
{
bool flag2 = conf.ContainsKey("part");
if (flag2)
{
this.m_part = conf["part"]._str;
}
bool flag3 = conf.ContainsKey("attachto");
if (flag3)
{
this.m_attachTo = conf["attachto"]._str;
string text = null;
bool flag4 = conf.ContainsKey("customMtrl");
if (flag4)
{
text = conf["customMtrl"]._str;
}
else
{
bool flag5 = conf.ContainsKey("mtrl");
if (flag5)
{
text = conf["mtrl"]._str;
}
}
bool flag6 = text != null;
if (flag6)
{
Variant materialConf = GraphManager.singleton.getMaterialConf(text);
bool flag7 = materialConf != null;
if (flag7)
{
this.m_mtrl = new GRShader();
this.m_mtrl.load(materialConf);
}
else
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Material [" + conf["mtrl"]._str + "] is missed!");
}
}
bool flag8 = conf.ContainsKey("cid");
if (flag8)
{
Variant characterConf = GraphManager.singleton.getCharacterConf(conf["cid"]._str);
bool flag9 = characterConf == null;
if (flag9)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "applyAvatar attachto cid[" + conf["cid"]._str + "] config not exist");
}
else
{
this.m_entity = (this.m_world.createEntity(Define.GREntityType.CHARACTER) as GREntity3D);
bool flag10 = this.m_mtrl != null;
if (flag10)
{
this.m_entity.load(characterConf, this.m_mtrl.graphMaterial, null);
}
else
{
this.m_entity.load(characterConf, null, null);
}
}
}
else
{
bool flag11 = conf.ContainsKey("eid");
if (flag11)
{
Variant entityConf = GraphManager.singleton.getEntityConf(conf["eid"]._str);
bool flag12 = entityConf == null;
if (flag12)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "applyAvatar attachto entid[" + conf["eid"]._str + "] config not exist");
}
else
{
this.m_entity = (this.m_world.createEntity(Define.GREntityType.STATIC_MESH) as GREntity3D);
bool flag13 = this.m_mtrl != null;
if (flag13)
{
this.m_entity.load(entityConf, this.m_mtrl.graphMaterial, null);
}
else
{
this.m_entity.load(entityConf, null, null);
}
}
}
}
}
else
{
bool flag14 = conf.ContainsKey("mountto");
if (flag14)
{
this.m_mountTo = conf["mountto"];
Variant characterConf2 = GraphManager.singleton.getCharacterConf(conf["cid"]);
bool flag15 = characterConf2 == null;
if (flag15)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "applyAvatar mountto cid[" + conf["cid"]._str + "] config not exist");
}
else
{
this.m_entity = (this.m_world.createEntity(Define.GREntityType.CHARACTER) as GREntity3D);
this.m_entity.load(characterConf2, null, null);
}
}
else
{
bool flag16 = conf.ContainsKey("file");
if (flag16)
{
this.m_asset = os.asset.getAsset <IAssetSkAniMesh>(conf["file"]._str);
}
else
{
this.m_asset = null;
}
bool flag17 = conf.ContainsKey("obj");
if (flag17)
{
this.m_obj = conf["obj"]._str;
}
else
{
this.m_obj = conf["part"]._str;
}
string text2 = null;
bool flag18 = conf.ContainsKey("customMtrl");
if (flag18)
{
text2 = conf["customMtrl"]._str;
}
else
{
bool flag19 = conf.ContainsKey("mtrl");
if (flag19)
{
text2 = conf["mtrl"]._str;
}
}
bool flag20 = text2 != null;
if (flag20)
{
Variant materialConf2 = GraphManager.singleton.getMaterialConf(text2);
bool flag21 = materialConf2 != null;
if (flag21)
{
this.m_mtrl = new GRShader();
this.m_mtrl.load(materialConf2);
}
else
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Material [" + conf["mtrl"]._str + "] is missed!");
}
}
}
}
}
}
public override void loadImpl(bool bSync)
{
base.loadImpl(bSync);
bool flag = this.m_path == null || this.m_path == "";
if (flag)
{
this.m_loaded = true;
this.m_loading = false;
this.m_ready = false;
this._dispatchOnFails("Url is null!");
}
else
{
bool flag2 = this.m_ready || this.m_loading;
if (!flag2)
{
try
{
if (bSync)
{
Debug.Log("warnning::sync Sk Bitmap " + this.m_path);
try
{
this.m_sprite = Resources.Load <Sprite>(this.m_path);
}
catch
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "path is " + this.m_path + " type is error");
}
this.m_loaded = true;
bool flag3 = this.m_sprite != null && this.m_sprite.texture.width != 0 && this.m_sprite.texture.height != 0;
if (flag3)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}
else
{
this.m_loading = true;
this.m_ready = false;
this.m_loaded = false;
new URLReqImpl
{
dataFormat = "assetbundle",
url = (this.m_path.IndexOf(".pic") < 0) ? (this.m_path + ".pic") : this.m_path
}.load(delegate(IURLReq r, object data)
{
try
{
this.m_sprite = (data as Sprite);
}
catch
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "path is " + this.m_path + " type is error");
}
this.m_loading = false;
this.m_loaded = true;
bool flag4 = this.m_sprite != null && this.m_sprite.texture.width != 0 && this.m_sprite.texture.height != 0;
if (flag4)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}, delegate(IURLReq r, float progress)
{
bool flag4 = this.m_onProgs != null;
if (flag4)
{
this.m_onProgs(this, progress);
}
}, delegate(IURLReq r, string err)
{
this._dispatchOnFails(err);
this.m_loading = false;
this.m_loaded = true;
this.m_ready = false;
});
}
}
catch (Exception)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, " AssetBitmap Load file[" + this.m_path + "] err!");
}
}
}
}
public override void loadImpl(bool bSync)
{
bool flag = this.m_path == null || this.m_path == "";
if (!flag)
{
bool flag2 = this.m_ready || this.m_loading;
if (!flag2)
{
base.loadImpl(bSync);
this.dispose();
try
{
if (bSync)
{
Debug.Log("warnning::sync Mesh " + this.m_path);
this.m_loading = true;
this.m_assetObj = Resources.Load <GameObject>(this.m_path);
this.m_loading = false;
this.m_loaded = true;
bool flag3 = this.m_assetObj != null;
if (flag3)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}
else
{
this.m_loading = true;
this.m_ready = false;
this.m_loaded = false;
new URLReqImpl
{
dataFormat = "assetbundle",
url = (this.m_path.IndexOf(".res") < 0) ? (this.m_path + ".res") : this.m_path
}.load(delegate(IURLReq r, object data)
{
this.m_assetObj = (data as GameObject);
this.m_loading = false;
this.m_loaded = true;
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
this._dispatchOnFins();
}, delegate(IURLReq r, float progress)
{
bool flag4 = this.m_onProgs != null;
if (flag4)
{
this.m_onProgs(this, progress);
}
}, delegate(IURLReq r, string err)
{
this.m_loading = false;
this.m_loaded = true;
this.m_ready = false;
this._dispatchOnFails(err);
});
}
}
catch
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Failed to Load Mesh: " + this.m_path);
}
}
}
}
public Variant parseXML(byte[] bytes, string path)
{
Variant variant = null;
bool flag = bytes[0] == 78 && bytes[1] == 105 && bytes[2] == 99;
Variant result;
if (flag)
{
byte[] array = new byte[bytes.Length - 14];
for (int i = 14; i < bytes.Length; i++)
{
array[i - 14] = bytes[i];
}
ByteArray byteArray = new ByteArray(array);
byteArray.uncompress();
variant = this._UnpackFullTypePackage(byteArray);
}
else
{
MemoryStream memoryStream = new MemoryStream(bytes);
XmlReader xmlReader = XmlReader.Create(memoryStream, new XmlReaderSettings
{
IgnoreComments = true,
IgnoreProcessingInstructions = true,
IgnoreWhitespace = true,
ValidationType = ValidationType.None,
ValidationFlags = XmlSchemaValidationFlags.None,
ProhibitDtd = true,
ConformanceLevel = ConformanceLevel.Document
});
Stack <Variant> stack = new Stack <Variant>();
try
{
while (xmlReader.Read())
{
bool flag2 = xmlReader.NodeType == XmlNodeType.Element;
if (flag2)
{
Variant variant2 = Variant.alloc();
bool flag3 = stack.Count > 0;
if (flag3)
{
Variant variant3 = stack.Peek();
bool flag4 = !variant3.ContainsKey(xmlReader.Name);
if (flag4)
{
variant3[xmlReader.Name] = Variant.alloc();
}
variant3[xmlReader.Name].pushBack(variant2);
}
else
{
variant = variant2;
}
bool flag5 = !xmlReader.IsEmptyElement;
if (flag5)
{
stack.Push(variant2);
}
while (xmlReader.MoveToNextAttribute())
{
variant2[xmlReader.Name] = new Variant(xmlReader.Value);
}
}
else
{
bool flag6 = xmlReader.NodeType == XmlNodeType.EndElement;
if (flag6)
{
stack.Pop();
}
}
}
}
catch (Exception var_19_1CC)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, string.Concat(new object[]
{
"[Parse XML error] File: ",
path,
" Line: ",
xmlReader.Settings.LineNumberOffset,
" Col: ",
xmlReader.Settings.LinePositionOffset
}));
result = null;
return(result);
}
xmlReader.Close();
memoryStream.Close();
}
result = variant;
return(result);
}
public void loadConfigs(string mainConfFile, Action onFin)
{
bool flag = mainConfFile.IndexOf('.') < 0;
if (flag)
{
mainConfFile += ".xml";
}
os.sys.parseXMLFromFile(mainConfFile, delegate(Variant mainConf1)
{
bool flag2 = mainConf1 != null;
if (flag2)
{
List <string> toLoadNames = new List <string>();
List <string> list = new List <string>();
foreach (string current in mainConf1.Keys)
{
Variant variant = mainConf1[current][0];
bool flag3 = variant.ContainsKey("file");
if (flag3)
{
toLoadNames.Add(current);
list.Add(variant["file"]._str);
}
else
{
bool flag4 = this.m_confFormatFuncMap.ContainsKey(current);
if (flag4)
{
this.m_ccm = Define.Ccm_status.FORMAT_CONF;
this._setValue(this.m_ccm);
Action <Variant> action = this.m_confFormatFuncMap[current];
action(variant);
}
this.m_configs[current] = variant;
this.m_configLoaded++;
}
}
this.m_ccm = Define.Ccm_status.LOADING_CONF;
this._setValue(this.m_ccm);
for (int i = 0; i < toLoadNames.Count; i++)
{
string key = toLoadNames[i];
string url = list[i];
os.sys.parseXMLFromFile(url, delegate(Variant confObj1)
{
bool flag5 = confObj1 != null;
if (flag5)
{
bool flag6 = this.m_confFormatFuncMap.ContainsKey(key);
if (flag6)
{
this.m_ccm = Define.Ccm_status.FORMAT_CONF;
this._setValue(this.m_ccm);
Action <Variant> action2 = this.m_confFormatFuncMap[key];
action2(confObj1);
}
this.m_configs[key] = confObj1;
this.m_configLoaded++;
}
else
{
string text = "Config Manager load config file[" + url + "] error! msg:" + key;
DebugTrace.add(Define.DebugTrace.DTT_ERR, text);
this.m_errMsg = this.m_errMsg + text + "\n";
this.m_configFailed++;
}
bool flag7 = this.m_configLoaded + this.m_configFailed == toLoadNames.Count;
if (flag7)
{
this.m_ccm = Define.Ccm_status.LOADED;
this._setValue(this.m_ccm);
this.m_curProcessConf = null;
onFin();
}
});
}
}
else
{
this.m_errMsg = "Config Manager load main config file[] error! msg:" + mainConfFile;
DebugTrace.add(Define.DebugTrace.DTT_ERR, this.m_errMsg);
this.m_ccm = Define.Ccm_status.ERR;
this._setValue(this.m_ccm);
onFin();
}
this.m_ccm = Define.Ccm_status.LOADING_MAINFILE;
this._setValue(this.m_ccm);
});
}
public override void loadImpl(bool bSync)
{
base.loadImpl(bSync);
bool flag = this.m_path == null || this.m_path == "";
if (!flag)
{
bool flag2 = this.m_ready || this.m_loading;
if (!flag2)
{
this.m_anim = null;
try
{
if (bSync)
{
Debug.Log("warnning::sync Sk Anim " + this.m_path);
this.m_anim = (UnityEngine.Object.Instantiate(Resources.Load <AnimationClip>(this.m_path)) as AnimationClip);
this.m_loaded = true;
bool flag3 = this.m_anim != null;
if (flag3)
{
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}
else
{
this.m_loading = true;
this.m_ready = false;
this.m_loaded = false;
new URLReqImpl
{
dataFormat = "assetbundle",
url = (this.m_path.IndexOf(".anim") < 0) ? (this.m_path + ".anim") : this.m_path
}.load(delegate(IURLReq r, object data)
{
this.m_anim = (data as AnimationClip);
this.m_loading = false;
this.m_loaded = true;
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
this._dispatchOnFins();
}, delegate(IURLReq r, float progress)
{
bool flag4 = this.m_onProgs != null;
if (flag4)
{
this.m_onProgs(this, progress);
}
}, delegate(IURLReq r, string err)
{
this._dispatchOnFails(err);
this.m_loading = false;
this.m_loaded = true;
this.m_ready = false;
});
}
}
catch (Exception ex)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, string.Concat(new string[]
{
"e = ",
ex.Message,
" m_path = ",
this.m_path,
" is error"
}));
}
}
}
}
public void load(Variant conf)
{
bool flag = conf == null;
if (!flag)
{
this.m_id = conf["id"]._str;
bool flag2 = conf.ContainsKey("method");
if (flag2)
{
Variant variant = conf["method"][0];
bool flag3 = variant.ContainsKey("file");
if (flag3)
{
this.m_material.asset = os.asset.getAsset <IAssetShader>(variant["file"]._str);
}
foreach (string current in variant.Keys)
{
bool flag4 = current.IndexOf("_") == 0;
if (flag4)
{
string str = variant[current]._str;
bool flag5 = str.IndexOf('/') >= 0 || str.IndexOf('\\') >= 0;
if (flag5)
{
this.m_material.setTexture(current, str);
}
else
{
bool flag6 = str.IndexOf("(") >= 0;
if (flag6)
{
string text = str.Substring(str.IndexOf('(') + 1);
text = text.Substring(0, text.IndexOf(')'));
string[] array = text.Split(new char[]
{
','
});
bool flag7 = array.Length == 3;
if (flag7)
{
this.m_material.setProperty(current, float.Parse(array[0]) / 255f, float.Parse(array[1]) / 255f, float.Parse(array[2]) / 255f, 0f);
}
else
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "Illegal color property in material config: " + current + " : " + text);
}
}
else
{
bool flag8 = str.IndexOf(",") >= 0;
if (flag8)
{
string[] array2 = str.Split(new char[]
{
','
});
bool flag9 = array2.Length == 3;
if (flag9)
{
this.m_material.setProperty(current, float.Parse(array2[0]), float.Parse(array2[1]), float.Parse(array2[2]), 0f);
}
else
{
bool flag10 = array2.Length == 4;
if (flag10)
{
this.m_material.setProperty(current, float.Parse(array2[0]), float.Parse(array2[1]), float.Parse(array2[2]), float.Parse(array2[3]));
}
}
}
else
{
this.m_material.setProperty(current, float.Parse(str));
}
}
}
}
}
}
}
}
public override void onPreRender()
{
bool flag = this.m_u3dObj == null;
if (!flag)
{
bool flag2 = this.m_assetLoading.Count == 0;
if (!flag2)
{
bool flag3 = this.m_tmpList.Count > 0;
if (flag3)
{
this.m_tmpList.Clear();
}
foreach (IAsset current in this.m_assetLoading.Keys)
{
bool isReady = current.isReady;
if (isReady)
{
bool flag4 = current == this.m_asset;
if (flag4)
{
try
{
this.m_animatorObj = (UnityEngine.Object.Instantiate(this.m_asset.assetObj) as GameObject);
}
catch (Exception var_9_B0)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, "The GameObject is null");
}
bool flag5 = this.m_animatorObj == null;
if (flag5)
{
return;
}
SkAniMeshBehaviour skAniMeshBehaviour = this.m_animatorObj.AddComponent <SkAniMeshBehaviour>();
skAniMeshBehaviour.obj = this;
this.m_animator = this.m_animatorObj.GetComponent <Animation>();
bool flag6 = this.m_animator == null;
if (flag6)
{
this.m_animator = this.m_animatorObj.AddComponent <Animation>();
}
this.m_animator.cullingType = AnimationCullingType.AlwaysAnimate;
osImpl.linkU3dObj(this.m_u3dObj, this.m_animatorObj);
this._syncPlayState(false);
Dictionary <IGraphObject3D, string> dictionary = new Dictionary <IGraphObject3D, string>(this.m_attach);
foreach (IGraphObject3D current2 in dictionary.Keys)
{
this.attachObject(this.m_attach[current2], current2);
}
this.m_tmpList.Add(current);
}
else
{
bool flag7 = current is IAssetSkAnimation;
if (flag7)
{
bool flag8 = this.m_animator != null;
if (flag8)
{
AssetSkAnimationImpl assetSkAnimationImpl = current as AssetSkAnimationImpl;
this._syncPlayState(false);
this.m_tmpList.Add(current);
}
}
else
{
bool flag9 = current is IAssetSkAniMesh;
if (flag9)
{
bool flag10 = this.m_animatorObj != null;
if (flag10)
{
AssetSkAniMeshImpl assetSkAniMeshImpl = current as AssetSkAniMeshImpl;
List <string> list = new List <string>();
foreach (string current3 in this.m_skinMap.Keys)
{
bool flag11 = current3.IndexOf(assetSkAniMeshImpl.path) == 0 && this.m_skinMap[current3] == null;
if (flag11)
{
list.Add(current3);
}
}
foreach (string current4 in list)
{
bool flag12 = current4.IndexOf(assetSkAniMeshImpl.path) == 0 && this.m_skinMap[current4] == null;
if (flag12)
{
ShaderImpl shaderImpl = this.m_skinMtrlMap.ContainsKey(current4) ? this.m_skinMtrlMap[current4] : null;
Transform transform = null;
string name = current4.Substring(current4.IndexOf('$') + 1);
try
{
transform = assetSkAniMeshImpl.assetObj.transform.FindChild(name);
}
catch (Exception var_30_347)
{
}
bool flag13 = transform;
if (flag13)
{
GameObject gameObject = transform.gameObject;
GameObject gameObject2 = UnityEngine.Object.Instantiate(gameObject) as GameObject;
osImpl.linkU3dObj(this.m_animatorObj, gameObject2);
this.m_skinMap[current4] = gameObject2;
bool flag14 = gameObject.transform.GetComponent <SkinnedMeshRenderer>() != null;
SkinnedMeshRenderer[] array;
SkinnedMeshRenderer[] array2;
if (flag14)
{
array = new SkinnedMeshRenderer[]
{
gameObject.transform.GetComponent <SkinnedMeshRenderer>()
};
array2 = new SkinnedMeshRenderer[]
{
gameObject2.transform.GetComponent <SkinnedMeshRenderer>()
};
}
else
{
array = gameObject.transform.GetComponentsInChildren <SkinnedMeshRenderer>();
array2 = gameObject2.transform.GetComponentsInChildren <SkinnedMeshRenderer>();
}
for (int i = 0; i < array.Length; i++)
{
SkinnedMeshRenderer skinnedMeshRenderer = array[i];
SkinnedMeshRenderer skinnedMeshRenderer2 = array2[i];
bool flag15 = shaderImpl != null;
if (flag15)
{
bool flag16 = shaderImpl.u3dMaterial != null;
if (flag16)
{
skinnedMeshRenderer2.material = shaderImpl.u3dMaterial;
}
else
{
shaderImpl.apply(skinnedMeshRenderer2.material);
}
}
bool flag17 = skinnedMeshRenderer.rootBone != null;
if (flag17)
{
bool flag18 = this._getBone(skinnedMeshRenderer.rootBone.name) != null;
if (flag18)
{
skinnedMeshRenderer2.rootBone = this._getBone(skinnedMeshRenderer.rootBone.name).transform;
}
}
List <Transform> list2 = new List <Transform>();
Transform[] componentsInChildren = base.u3dObject.GetComponentsInChildren <Transform>();
for (int j = 0; j < skinnedMeshRenderer.bones.Length; j++)
{
for (int k = 0; k < componentsInChildren.Length; k++)
{
bool flag19 = componentsInChildren[k].name == skinnedMeshRenderer.bones[j].name;
if (flag19)
{
list2.Add(componentsInChildren[k]);
break;
}
}
}
skinnedMeshRenderer2.bones = list2.ToArray();
}
}
}
}
}
this.m_tmpList.Add(current);
}
}
}
}
}
bool flag20 = this.m_tmpList.Count > 0;
if (flag20)
{
foreach (IAsset current5 in this.m_tmpList)
{
this.m_assetLoading.Remove(current5);
}
}
}
}
}
public override void loadImpl(bool bSync)
{
base.loadImpl(bSync);
bool flag = this.m_path == "" || this.m_path == null;
if (!flag)
{
bool flag2 = this.m_ready || this.m_loaded;
if (!flag2)
{
try
{
if (bSync)
{
this.m_tem = Resources.LoadAll(this.m_path);
for (int i = 0; i < this.m_tem.Length; i++)
{
bool flag3 = this.m_tem[i].GetType().ToString() == "UnityEngine.Sprite";
if (flag3)
{
this.m_sprite.Add(this.m_tem[i] as Sprite);
}
}
this.m_loaded = true;
for (int j = 0; j < this.m_sprite.Count; j++)
{
bool flag4 = this.m_sprite[j] == null || this.m_sprite[j].texture == null || this.m_sprite[j].texture.width == 0 || this.m_sprite[j].texture.height == 0;
if (flag4)
{
break;
}
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}
else
{
this.m_loading = true;
this.m_ready = false;
this.m_loaded = false;
new URLReqImpl
{
dataFormat = "assetbundle",
url = (this.m_path.IndexOf(".anipic") < 0) ? (this.m_path + ".anipic") : this.m_path
}.load(delegate(IURLReq r, object data)
{
this.m_tem = (data as UnityEngine.Object[]);
for (int k = 0; k < this.m_tem.Length; k++)
{
bool flag5 = this.m_tem[k].GetType().ToString() == "UnityEngine.Sprite";
if (flag5)
{
this.m_sprite.Add(this.m_tem[k] as Sprite);
}
}
this.m_loading = false;
this.m_loaded = true;
for (int l = 0; l < this.m_sprite.Count; l++)
{
bool flag6 = this.m_sprite[l] == null || this.m_sprite[l].texture == null || this.m_sprite[l].texture.width == 0 || this.m_sprite[l].texture.height == 0;
if (flag6)
{
break;
}
this.m_ready = true;
(os.asset as AssetManagerImpl).readyAsset(this);
}
this._dispatchOnFins();
}, delegate(IURLReq r, float progress)
{
bool flag5 = this.m_onProgs != null;
if (flag5)
{
this.m_onProgs(this, progress);
}
}, delegate(IURLReq r, string err)
{
this._dispatchOnFails(err);
this.m_loading = false;
this.m_loaded = true;
this.m_ready = false;
});
}
}
catch (Exception)
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, " AssetBitmap Load file[" + this.m_path + "] err!");
}
}
}
}
protected void _formatAvatarConfOld(Variant conf)
{
bool flag = conf.ContainsKey("chaAni");
if (flag)
{
conf["chaAni"] = conf["chaAni"].convertToDct("id");
foreach (Variant current in conf["chaAni"].Values)
{
bool flag2 = !current.ContainsKey("ani");
if (flag2)
{
current["ani"] = new Variant();
current["ani"].setToDct();
}
else
{
current["ani"] = current["ani"].convertToDct("name");
Variant variant = current["ani"];
foreach (Variant current2 in variant.Values)
{
bool flag3 = variant.ContainsKey("preload") && variant["preload"]._bool && variant.ContainsKey("file");
if (flag3)
{
IAsset asset = os.asset.getAsset <IAssetSkAnimation>(variant["file"]._str);
asset.autoDisposeTime = -1f;
asset.load();
}
}
}
}
}
else
{
conf["chaAni"] = new Variant();
conf["chaAni"].setToDct();
}
bool flag4 = conf.ContainsKey("cha");
if (flag4)
{
for (int i = 0; i < conf["cha"].Count; i++)
{
Variant variant2 = conf["cha"][i];
bool flag5 = variant2.ContainsKey("preload") && variant2["preload"]._bool && variant2.ContainsKey("file");
if (flag5)
{
IAsset asset2 = os.asset.getAsset <IAssetSkAniMesh>(variant2["file"]._str);
asset2.autoDisposeTime = -1f;
asset2.load();
}
bool flag6 = variant2.ContainsKey("ani");
if (flag6)
{
Variant variant3 = conf["chaAni"][variant2["ani"]._str];
bool flag7 = variant3 != null;
if (flag7)
{
variant2["ani"] = variant3["ani"];
variant2["defani"] = variant3["defani"];
bool flag8 = variant3.ContainsKey("defori");
if (flag8)
{
variant2["defori"] = variant3["defori"];
}
}
else
{
DebugTrace.add(Define.DebugTrace.DTT_ERR, string.Concat(new string[]
{
"cha config[",
variant2["id"],
"] ani[",
variant2["ani"],
"] config not exist"
}));
variant2["ani"] = new Variant();
variant2["ani"]["ani"] = new Variant();
variant2["ani"]["ani"].setToArray();
}
}
}
conf["cha"] = conf["cha"].convertToDct("id");
}
else
{
conf["cha"] = new Variant();
conf["cha"].setToDct();
}
bool flag9 = conf.ContainsKey("ent");
if (flag9)
{
conf["ent"] = conf["ent"].convertToDct("id");
}
else
{
conf["ent"] = new Variant();
conf["ent"].setToDct();
}
bool flag10 = conf.ContainsKey("chaAvatar");
if (flag10)
{
Variant variant4 = conf["chaAvatar"];
for (int j = 0; j < variant4.Count; j++)
{
Variant variant5 = variant4[j];
variant5["ava"] = variant5["ava"].convertToDct("id");
}
Variant variant6 = new Variant();
for (int k = 0; k < variant4.Count; k++)
{
Variant variant7 = variant4[k];
bool flag11 = -1 != variant7["chaid"]._str.IndexOf(",");
string[] array;
if (flag11)
{
array = variant7["chaid"]._str.Split(new char[]
{
','
});
}
else
{
array = new string[]
{
variant7["chaid"]._str
};
}
string[] array2 = array;
for (int l = 0; l < array2.Length; l++)
{
string key = array2[l];
variant6[key] = variant7;
}
}
conf["chaAvatar"] = variant6;
}
else
{
conf["chaAvatar"] = new Variant();
conf["chaAvatar"].setToDct();
}
bool flag12 = conf.ContainsKey("avapart");
if (flag12)
{
conf["avapart"] = conf["avapart"].convertToDct("part");
}
else
{
conf["avapart"] = new Variant();
conf["chaAvatar"].setToDct();
}
bool flag13 = conf.ContainsKey("cbapart");
if (flag13)
{
conf["cbapart"] = conf["cbapart"].convertToDct("id");
}
else
{
conf["cbapart"] = new Variant();
conf["cbapart"].setToDct();
}
bool flag14 = conf.ContainsKey("shadow");
if (flag14)
{
conf["shadow"] = conf["shadow"].convertToDct("id");
}
else
{
conf["shadow"] = new Variant();
conf["shadow"].setToDct();
}
this.m_avaConf = conf;
}
private bool _get_protocal_desc(uint protocal_version)
{
DebugTrace.add(Define.DebugTrace.DTT_SYS, "request protocal info from server");
this.PSendTPKG(1u, new Variant(0));
return(true);
}
