Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

client_Hale

2019-02-19 d86e989d563b1f7845f0fb04ebe1d160145a9a64

Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

 Core/GameEngine/Login/LaunchPostProcess.cs

@@ -2,7 +2,6 @@
using System.Collections.Generic;

using UnityEngine;

using Snxxz.UI;



using System;



[XLua.LuaCallCSharp]

@@ -11,14 +10,13 @@


    bool m_Completed = false;

    public bool completed { get { return m_Completed; } set { m_Completed = value; } }

    public float progress { get { return Mathf.Clamp01((Time.time - startTime) * 0.1f + ConfigInitiator.progress * 0.7f); } }



    float startTime = 0f;

    DateTime startTime;



    public void Begin()

    {

        completed = false;

        startTime = Time.time;

        startTime = DateTime.Now;

        ConfigInitiator.Init();

    }



@@ -26,6 +24,8 @@
    {

        if (!completed && ConfigInitiator.done)

        {

            DebugEx.LogFormat("解析配置表耗时：{0}", (DateTime.Now - startTime).TotalMilliseconds);



            try

            {

                InGameDownLoad.Instance.ParseRewardConfig();

@@ -43,8 +43,6 @@
                {

                    AssetDeCompressTask.Delete7zFiles(ResourcesPath.Instance.ExternalStorePath);

                }



                DebugEx.LogFormat("解析配置表耗时：{0}", Time.time - startTime);

            }

            catch (Exception ex)

            {


 Lua/Gen/LaunchPostProcessWrap.cs

@@ -21,13 +21,12 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(LaunchPostProcess);
            Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 1);
            Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Begin", _m_Begin);
            
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "completed", _g_get_completed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "progress", _g_get_progress);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "completed", _s_set_completed);
            
@@ -113,20 +112,6 @@
            
                LaunchPostProcess gen_to_be_invoked = (LaunchPostProcess)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.completed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_progress(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                LaunchPostProcess gen_to_be_invoked = (LaunchPostProcess)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.progress);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

 Lua/Gen/SkillClassifingConfigWrap.cs

New file
@@ -0,0 +1,357 @@
#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class SkillClassifingConfigWrap 
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(SkillClassifingConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 0);
			
			
			
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkillID", _g_get_SkillID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkillTypeID", _g_get_SkillTypeID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "UseType", _g_get_UseType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "FuncType", _g_get_FuncType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkillLV", _g_get_SkillLV);
            
			
			
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 6, 1, 0);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Get", _m_Get_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetKeys", _m_GetKeys_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetValues", _m_GetValues_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Has", _m_Has_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Init", _m_Init_xlua_st_);
            
			
            
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "inited", _g_get_inited);
            
			
			
            Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                if(LuaAPI.lua_gettop(L) == 1)
                {
					
                    SkillClassifingConfig gen_ret = new SkillClassifingConfig();
                    translator.Push(L, gen_ret);
                    
                    return 1;
                }
                if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING))
                {
                    string _input = LuaAPI.lua_tostring(L, 2);
					
                    SkillClassifingConfig gen_ret = new SkillClassifingConfig(_input);
                    translator.Push(L, gen_ret);
                    
                    return 1;
                }
				
            }
            catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return LuaAPI.luaL_error(L, "invalid arguments to SkillClassifingConfig constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Get_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        SkillClassifingConfig gen_ret = SkillClassifingConfig.Get( _id );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
                {
                    string _id = LuaAPI.lua_tostring(L, 1);
                    
                        SkillClassifingConfig gen_ret = SkillClassifingConfig.Get( _id );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to SkillClassifingConfig.Get!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetKeys_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        System.Collections.Generic.List<string> gen_ret = SkillClassifingConfig.GetKeys(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetValues_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        System.Collections.Generic.List<SkillClassifingConfig> gen_ret = SkillClassifingConfig.GetValues(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Has_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        bool gen_ret = SkillClassifingConfig.Has( _id );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
                {
                    string _id = LuaAPI.lua_tostring(L, 1);
                    
                        bool gen_ret = SkillClassifingConfig.Has( _id );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to SkillClassifingConfig.Has!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Init_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) 
                {
                    bool _sync = LuaAPI.lua_toboolean(L, 1);
                    
                    SkillClassifingConfig.Init( _sync );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 0) 
                {
                    
                    SkillClassifingConfig.Init(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to SkillClassifingConfig.Init!");
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_inited(RealStatePtr L)
        {
            try {
            
                LuaAPI.lua_pushboolean(L, SkillClassifingConfig.inited);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SkillID(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                SkillClassifingConfig gen_to_be_invoked = (SkillClassifingConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SkillID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SkillTypeID(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                SkillClassifingConfig gen_to_be_invoked = (SkillClassifingConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SkillTypeID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_UseType(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                SkillClassifingConfig gen_to_be_invoked = (SkillClassifingConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.UseType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_FuncType(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                SkillClassifingConfig gen_to_be_invoked = (SkillClassifingConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.FuncType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SkillLV(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                SkillClassifingConfig gen_to_be_invoked = (SkillClassifingConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SkillLV);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
		
		
		
		
    }
}

 Lua/Gen/SkillClassifingConfigWrap.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: c58500c7d37be664d8432324eea49a6f
timeCreated: 1550565918
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Lua/Gen/SkillConfigWrap.cs

@@ -21,9 +21,8 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(SkillConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 1, 74, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 74, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnConfigParseCompleted", _m_OnConfigParseCompleted);
            
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkillID", _g_get_SkillID);
@@ -106,12 +105,13 @@
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 11, 1, 0);
            Utils.BeginClassRegister(type, L, __CreateInstance, 12, 1, 0);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Get", _m_Get_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetKeys", _m_GetKeys_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetValues", _m_GetValues_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Has", _m_Has_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Init", _m_Init_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SkillClassifingInit", _m_SkillClassifingInit_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkillWithOccpyAndType", _m_GetSkillWithOccpyAndType_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkills", _m_GetSkills_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkillActive", _m_GetSkillActive_xlua_st_);
@@ -338,19 +338,16 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnConfigParseCompleted(RealStatePtr L)
        static int _m_SkillClassifingInit_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                SkillConfig gen_to_be_invoked = (SkillConfig)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    SkillConfig.SkillClassifingInit(  );
                    
                    
                    

 Lua/Gen/XLuaGenAutoRegister.cs

@@ -544,6 +544,9 @@
            translator.DelayWrapLoader(typeof(SignInConfig), SignInConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SkillClassifingConfig), SkillClassifingConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SkillConfig), SkillConfigWrap.__Register);
        
        
@@ -642,13 +645,13 @@
        
            translator.DelayWrapLoader(typeof(WingRefineAttrConfig), WingRefineAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WingRefineExpConfig), WingRefineExpConfigWrap.__Register);
        
        }
        
        static void wrapInit4(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(WingRefineExpConfig), WingRefineExpConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WorldBossConfig), WorldBossConfigWrap.__Register);
        
@@ -799,13 +802,13 @@
        
            translator.DelayWrapLoader(typeof(UnityEngine.Behaviour), UnityEngineBehaviourWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Transform), UnityEngineTransformWrap.__Register);
        
        }
        
        static void wrapInit5(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(UnityEngine.Transform), UnityEngineTransformWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Resources), UnityEngineResourcesWrap.__Register);
        
@@ -956,13 +959,13 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DungeonAssistModel), SnxxzUIDungeonAssistModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.Dungeon), SnxxzUIDungeonWrap.__Register);
        
        }
        
        static void wrapInit6(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.Dungeon), SnxxzUIDungeonWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DungeonLiquidModel), SnxxzUIDungeonLiquidModelWrap.__Register);
        
@@ -1113,13 +1116,13 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BatchUseModel), SnxxzUIBatchUseModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.KingTreasureShowModel), SnxxzUIKingTreasureShowModelWrap.__Register);
        
        }
        
        static void wrapInit7(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.KingTreasureShowModel), SnxxzUIKingTreasureShowModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(KnapSackEventMgr), KnapSackEventMgrWrap.__Register);
        
@@ -1270,13 +1273,13 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MagicianModel), SnxxzUIMagicianModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RoleModel), SnxxzUIRoleModelWrap.__Register);
        
        }
        
        static void wrapInit8(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RoleModel), SnxxzUIRoleModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RolePointModel), SnxxzUIRolePointModelWrap.__Register);
        
@@ -1427,14 +1430,14 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.LevelGiftModel), SnxxzUILevelGiftModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MultipleExpModel), SnxxzUIMultipleExpModelWrap.__Register);
        
        }
        
        static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MultipleExpModel), SnxxzUIMultipleExpModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MultipleRealmPointModel), SnxxzUIMultipleRealmPointModelWrap.__Register);
        
        

 Lua/Gen/link.xml

@@ -181,6 +181,7 @@
        <type fullname="SceneReplaceConfig" preserve="all"/>
        <type fullname="SceneShadowConfig" preserve="all"/>
        <type fullname="SignInConfig" preserve="all"/>
        <type fullname="SkillClassifingConfig" preserve="all"/>
        <type fullname="SkillConfig" preserve="all"/>
        <type fullname="SkillFrameAnimationConfig" preserve="all"/>
        <type fullname="StoreConfig" preserve="all"/>