예제 #1
0
        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);
        }
예제 #2
0
 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);
         }
     }
 }
예제 #3
0
        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);
        }
예제 #4
0
        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!");
                    }
                }
            }
        }
예제 #5
0
        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);
            }
        }
예제 #6
0
        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"]);
            }
        }
예제 #7
0
        private static void _trace(string msg)
        {
            bool flag = DebugTrace.print != null;

            if (flag)
            {
                DebugTrace.print(msg);
            }
        }
예제 #8
0
        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();
            });
        }
예제 #9
0
        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);
        }
예제 #10
0
        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());
                }
            }
        }
예제 #11
0
        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);
                        }
                    }
                });
            }
        }
예제 #12
0
        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);
            }
        }
예제 #13
0
        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;
                }
            }
        }
예제 #14
0
        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);
        }
예제 #15
0
        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);
                }
            }
        }
예제 #16
0
        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);
                    }
                }
            }
        }
예제 #17
0
        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!");
                            }
                        }
                    }
                }
            }
        }
예제 #18
0
        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!");
                    }
                }
            }
        }
예제 #19
0
        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);
                    }
                }
            }
        }
예제 #20
0
        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);
        }
예제 #21
0
        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);
            });
        }
예제 #22
0
        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"
                        }));
                    }
                }
            }
        }
예제 #23
0
        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));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
예제 #24
0
        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);
                        }
                    }
                }
            }
        }
예제 #25
0
        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!");
                    }
                }
            }
        }
예제 #26
0
        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;
        }
예제 #27
0
 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);
 }