static public int get_value6(IntPtr l)
 {
     try {
         TableConfig.SkillData self = (TableConfig.SkillData)checkSelf(l);
         pushValue(l, true);
         pushValue(l, self.value6);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int constructor(IntPtr l)
 {
     try {
         TableConfig.SkillData o;
         o = new TableConfig.SkillData();
         pushValue(l, true);
         pushValue(l, o);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int GetId(IntPtr l)
 {
     try {
         TableConfig.SkillData self = (TableConfig.SkillData)checkSelf(l);
         var ret = self.GetId();
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int set_value6(IntPtr l)
 {
     try {
         TableConfig.SkillData self = (TableConfig.SkillData)checkSelf(l);
         System.Int32          v;
         checkType(l, 2, out v);
         self.value6 = v;
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int set_vampire(IntPtr l)
 {
     try {
         TableConfig.SkillData self = (TableConfig.SkillData)checkSelf(l);
         System.Collections.Generic.List <System.Int32> v;
         checkType(l, 2, out v);
         self.vampire = v;
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int set_needTarget(IntPtr l)
 {
     try {
         TableConfig.SkillData self = (TableConfig.SkillData)checkSelf(l);
         System.Boolean        v;
         checkType(l, 2, out v);
         self.needTarget = v;
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int WriteToBinary(IntPtr l)
 {
     try {
         TableConfig.SkillData     self = (TableConfig.SkillData)checkSelf(l);
         GameFramework.BinaryTable a1;
         checkType(l, 2, out a1);
         self.WriteToBinary(a1);
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 static public int ReadFromBinary(IntPtr l)
 {
     try {
         TableConfig.SkillData     self = (TableConfig.SkillData)checkSelf(l);
         GameFramework.BinaryTable a1;
         checkType(l, 2, out a1);
         System.Int32 a2;
         checkType(l, 3, out a2);
         var ret = self.ReadFromBinary(a1, a2);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
        private static void JoinSkillDslResource()
        {
            foreach (var pair in TableConfig.SkillProvider.Instance.SkillMgr.GetData())
            {
                TableConfig.Skill skill = pair.Value as TableConfig.Skill;

                TableConfig.SkillData skillData = TableConfig.SkillDataProvider.Instance.GetSkillData(skill.id);
                if (null != skillData)
                {
                    skill.skillData = skillData;

                    if (skill.type == (int)SkillOrImpactType.Skill)
                    {
                        skill.damageData.Multiples = skillData.multiple;
                        skill.damageData.Damages   = skillData.damage;
                        skill.damageData.AddSc     = skillData.beaddsc;
                        skill.damageData.AddUc     = skillData.beadduc;
                        skill.damageData.Vampires  = skillData.vampire;

                        if (skillData.attr1 > 0 && skillData.value1 > 0)
                        {
                            skill.attrValues[skillData.attr1] = skillData.value1;
                        }
                        if (skillData.attr2 > 0 && skillData.value2 > 0)
                        {
                            skill.attrValues[skillData.attr2] = skillData.value2;
                        }
                        if (skillData.attr3 > 0 && skillData.value3 > 0)
                        {
                            skill.attrValues[skillData.attr3] = skillData.value3;
                        }
                        if (skillData.attr4 > 0 && skillData.value4 > 0)
                        {
                            skill.attrValues[skillData.attr4] = skillData.value4;
                        }
                        if (skillData.attr5 > 0 && skillData.value5 > 0)
                        {
                            skill.attrValues[skillData.attr5] = skillData.value5;
                        }
                        if (skillData.attr6 > 0 && skillData.value6 > 0)
                        {
                            skill.attrValues[skillData.attr6] = skillData.value6;
                        }
                        if (skillData.attr7 > 0 && skillData.value7 > 0)
                        {
                            skill.attrValues[skillData.attr7] = skillData.value7;
                        }
                        if (skillData.attr8 > 0 && skillData.value8 > 0)
                        {
                            skill.attrValues[skillData.attr8] = skillData.value8;
                        }
                    }
                }
                TableConfig.ImpactData impactData = TableConfig.ImpactDataProvider.Instance.GetImpactData(skill.id);
                if (null != impactData)
                {
                    skill.impactData = impactData;

                    if (skill.type == (int)SkillOrImpactType.Buff)
                    {
                        skill.damageData.Multiples = impactData.multiple;
                        skill.damageData.Damages   = impactData.damage;
                        skill.damageData.Vampires  = impactData.vampire;

                        if (impactData.attr1 > 0 && impactData.value1 > 0)
                        {
                            skill.attrValues[impactData.attr1] = impactData.value1;
                        }
                        if (impactData.attr2 > 0 && impactData.value2 > 0)
                        {
                            skill.attrValues[impactData.attr2] = impactData.value2;
                        }
                        if (impactData.attr3 > 0 && impactData.value3 > 0)
                        {
                            skill.attrValues[impactData.attr3] = impactData.value3;
                        }
                        if (impactData.attr4 > 0 && impactData.value4 > 0)
                        {
                            skill.attrValues[skillData.attr4] = impactData.value4;
                        }
                        if (impactData.attr5 > 0 && impactData.value5 > 0)
                        {
                            skill.attrValues[skillData.attr5] = impactData.value5;
                        }
                        if (impactData.attr6 > 0 && impactData.value6 > 0)
                        {
                            skill.attrValues[skillData.attr6] = impactData.value6;
                        }
                        if (impactData.attr7 > 0 && impactData.value7 > 0)
                        {
                            skill.attrValues[skillData.attr7] = impactData.value7;
                        }
                        if (impactData.attr8 > 0 && impactData.value8 > 0)
                        {
                            skill.attrValues[skillData.attr8] = impactData.value8;
                        }
                    }
                }
            }

            var resources = TableConfig.SkillResourcesProvider.Instance.SkillResourcesMgr.GetData();

            foreach (var resource in resources)
            {
                int               skillId = resource.skillId;
                string            key     = resource.key;
                string            res     = resource.resource;
                TableConfig.Skill skill   = TableConfig.SkillProvider.Instance.GetSkill(skillId);
                if (null != skill)
                {
                    if (skill.resources.ContainsKey(key))
                    {
                        //repeat
                    }
                    else
                    {
                        skill.resources.Add(key, res);
                    }
                }
            }
        }