Example #1
0
        private object UpgradeSkill(params object[] objs)
        {
            PassiveSkillData skillVO = objs[0] as PassiveSkillData;

            skillItems[skillVO.SkillID].SkillData = skillVO;
            return(null);
        }
Example #2
0
        private void InitItem()
        {
            int  Career  = PlayerManager.GetInstance().MajorPlayer.Job - 1;//职业从1开始
            int  n       = 0;
            uint skillID = 0;

            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    if (i * 6 + j == postions[n])
                    {
                        skillID = skillIDList[Career][n];
                        TalentSkillItem item = NGUITools.AddChild <TalentSkillItem>(gameObject);
                        GameObject      go   = GameObject.Instantiate(addBtn.gameObject) as GameObject;
                        UIEventListener.Get(go).onClick += OnUpgradeSkill;
                        item.AddPointBtn(go);
                        item.gameObject.transform.localPosition = posList[n++];
                        skillItems.Add(skillID, item);
                        KPassiveSkill    skill     = KConfigFileManager.GetInstance().GetPassiveSkill(skillID, 1);
                        PassiveSkillData skillData = new PassiveSkillData();
                        skillData.Learned = true;
                        item.SkillData    = skillData;
                        if (n == 14)
                        {
                            i = 4;
                            break;
                        }
                    }
                }
            }
            GameObject.Destroy(addBtn.gameObject);
        }
Example #3
0
        private void UpateItem()
        {
            foreach (PassiveSkillData skillData in SkillLogic.GetInstance().TalentSkillDict.Values)
            {
                skillItems[skillData.SkillID].SkillData = skillData;
            }

            foreach (TalentSkillItem item in skillItems.Values)
            {
                KPassiveSkill        passiveSkillSetting = KConfigFileManager.GetInstance().GetPassiveSkill(item.SkillData.SkillID, item.SkillData.Level);
                List <KPassiveSkill> reqSkills           = passiveSkillSetting.GetReqSkillList();
                int count = reqSkills.Count;
                for (int i = 0; i < count; i++)
                {
                    KPassiveSkill    reqSkill   = reqSkills[i];
                    PassiveSkillData reqSkillVO = skillItems[reqSkill.SkillID].SkillData;
                    GameObject       arrow;
                    string           key = "arrow_" + (reqSkill.Index - 1) + "_" + (passiveSkillSetting.Index - 1);
                    //if(!arrowList.TryGetValue(key, out arrow))
                    //{
                    //    Debug.Log(key + "-----------");
                    //}
                    //if (reqSkillVO.Learned && reqSkillVO.currentSkill.Level >= reqSkill.Level)
                    //{
                    //    arrow.SetActive(true);
                    //}
                    //else
                    //{
                    //    arrow.SetActive(false);
                    //}
                }
            }
        }
Example #4
0
 public bool UnsavedChanges(FileStream file)
 {
     if (Player.SelectedIndex != PlayerData.FindIndex(ReadByte(file)))
     {
         return(true);
     }
     if (Class.SelectedIndex != BattlerClassData.FindIndex(ReadByte(file)))
     {
         return(true);
     }
     if (LevelInput.Text != ReadByte(file).ToString())
     {
         return(true);
     }
     if (ZFormation.SelectedIndex != ReadByte(file))
     {
         return(true);
     }
     if (XFormation.SelectedIndex != ReadByte(file))
     {
         return(true);
     }
     if (Item1.SelectedIndex != ItemData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (Item2.SelectedIndex != ItemData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (Item3.SelectedIndex != ItemData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (Item4.SelectedIndex != ItemData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (Weapon1.SelectedIndex != WeaponData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (Weapon2.SelectedIndex != WeaponData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (Weapon3.SelectedIndex != WeaponData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (PassiveSkill1.SelectedIndex != PassiveSkillData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     if (PassiveSkill2.SelectedIndex != PassiveSkillData.FindIndex(ReadShort(file)))
     {
         return(true);
     }
     return(false);
 }
Example #5
0
 private void ParsePassiveSkillTable(DataTable passiveSkillTable)
 {
     this.m_PassiveSkillDic = new Dictionary <int, PassiveSkillData>();
     foreach (DataRow row in passiveSkillTable.Rows)
     {
         PassiveSkillData data = new PassiveSkillData();
         this.ParseSkillDataBase(row, data);
         this.m_PassiveSkillDic.Add(data.ID, data);
     }
 }
 public override void ParameterizeAttributes()
 {
     SQLDB.ParameterizeAttribute("@EnemyID", EnemyData.SelectedInput(EnemyInput));
     SQLDB.ParameterizeAttribute("@Level", LevelInput.Text);
     SQLDB.ParameterizeAttribute("@GridPositionZ", GridPositionZInput.SelectedIndex);
     SQLDB.ParameterizeAttribute("@GridPositionX", GridPositionXInput.SelectedIndex);
     SQLDB.ParameterizeAttribute("@HPMultiplier", HPMultiplierInput.Text);
     SQLDB.ParameterizeAttribute("@PassiveSkill1", PassiveSkillData.SelectedInput(PassiveSkill1Input));
     SQLDB.ParameterizeAttribute("@PassiveSkill2", PassiveSkillData.SelectedInput(PassiveSkill2Input));
 }
Example #7
0
        static void ExcutePassiveSkill(this PassiveSkillComponent self, string skillId)
        {
            Unit source = self.GetParent <Unit>();

            if (!self.bufferDatas.ContainsKey(skillId))
            {
                self.bufferDatas[skillId] = new PassiveSkillBufferData();
            }
            SkillHelper.ExecuteSkillParams excuteSkillParams = new SkillHelper.ExecuteSkillParams();
            excuteSkillParams.skillId    = skillId;
            excuteSkillParams.source     = self.GetParent <Unit>();
            excuteSkillParams.skillLevel = 1;

            self.cancelToken = new CancellationTokenSource();
            excuteSkillParams.cancelToken = self.cancelToken;

            PassiveSkillData passiveSkillData = Game.Scene.GetComponent <SkillConfigComponent>().GetPassiveSkill(skillId);

            if (passiveSkillData.listenToEvent)
            {
                if (!self.bufferDatas[skillId].apply)
                {
                    self.bufferDatas[skillId].apply  = true;
                    self.bufferDatas[skillId].aEvent = new ListenPassiveSkillEvent(
                        (unitId) =>
                    {
                        if (unitId == source.Id)
                        {
                            if (SkillHelper.CheckIfSkillCanUse(skillId, source))
                            {
                                self.tokenSource = new ETCancellationTokenSource();

                                SkillHelper.ExecutePassiveSkill(excuteSkillParams);
                            }
                        }
                    }
                        );
                    Game.EventSystem.RegisterEvent(passiveSkillData.eventIdType, self.bufferDatas[skillId].aEvent);
                }
                return;
            }
            else
            {
                if (self.bufferDatas[skillId].apply)
                {
                    return;
                }
            }
            if (SkillHelper.CheckIfSkillCanUse(skillId, source))
            {
                self.tokenSource = new ETCancellationTokenSource();
                SkillHelper.ExecutePassiveSkill(excuteSkillParams);
                self.bufferDatas[skillId].apply = true;
            }
        }
Example #8
0
 void Show(PassiveSkillData passiveSkillData)
 {
     ResetWidgetInfo();
     NameLabel.SetText(LanguageTextManager.GetString(passiveSkillData.SkillName));
     DesLabel.SetText(LanguageTextManager.GetString(passiveSkillData.SkillDis));
     CreatObjectToNGUI.InstantiateObj(passiveSkillData.SkillIconPrefab, CreatItemIconTransform);
     if (MyParent.IsResetSkill)
     {
         TraceUtil.Log("显示技能刷新特效");
         CreatResetSkillEffect();
     }
 }
Example #9
0
 public void ShowEffect(PassiveSkillData skillData)
 {
     CreatIconTransform.ClearChild();
     if (skillData == null)
     {
         SkillDesLabel.SetText("");
     }
     else
     {
         CreatObjectToNGUI.InstantiateObj(skillData.SkillIconPrefab, CreatIconTransform);
         SkillDesLabel.SetText(string.Format("{0}:{1}", LanguageTextManager.GetString(skillData.SkillName), LanguageTextManager.GetString(skillData.SkillDis)));
     }
 }
Example #10
0
 public void init(Jewel jewel, PassiveSkillData skill, bool IsSuit, int type)
 {
     if (IsSuit)
     {
         Title.SetText(LanguageTextManager.GetString("IDS_I9_6"));
     }
     else
     {
         Title.SetText(LanguageTextManager.GetString("IDS_I9_5"));
     }
     CreatObjectToNGUI.InstantiateObj(skill.SkillIconPrefab, iconPoint);
     Content.SetText(NGUIColor.SetTxtColor(LanguageTextManager.GetString(skill.SkillName) + ":", (TextColor)type) + NGUIColor.SetTxtColor("lv" + skill.SkillLevel, TextColor.ChatYellow) + " " + LanguageTextManager.GetString(skill.SkillDis));
 }
 protected override void OnRead(SQLiteDataReader reader)
 {
     EnemyInput.SelectedIndex         = EnemyData.FindIndex(reader["EnemyID"]);
     LevelInput.Text                  = reader["Level"].ToString();
     GridPositionZInput.SelectedIndex = int.Parse(reader["GridPositionZ"].ToString());
     GridPositionXInput.SelectedIndex = int.Parse(reader["GridPositionX"].ToString());
     HPMultiplierInput.Text           = reader["HPMultiplier"].ToString();
     EnemySkills.Read();
     EnemyWeapons.Read();
     EnemyItems.Read();
     PassiveSkill1Input.SelectedIndex = PassiveSkillData.FindIndex(reader["PassiveSkill1"]);
     PassiveSkill2Input.SelectedIndex = PassiveSkillData.FindIndex(reader["PassiveSkill2"]);
 }
Example #12
0
 public void Read(FileStream file)
 {
     Player.SelectedIndex        = PlayerData.FindIndex(ReadByte(file));
     Class.SelectedIndex         = BattlerClassData.FindIndex(ReadByte(file));
     LevelInput.Text             = ReadByte(file).ToString();
     ZFormation.SelectedIndex    = ReadByte(file);
     XFormation.SelectedIndex    = ReadByte(file);
     Item1.SelectedIndex         = ItemData.FindIndex(ReadShort(file));
     Item2.SelectedIndex         = ItemData.FindIndex(ReadShort(file));
     Item3.SelectedIndex         = ItemData.FindIndex(ReadShort(file));
     Item4.SelectedIndex         = ItemData.FindIndex(ReadShort(file));
     Weapon1.SelectedIndex       = WeaponData.FindIndex(ReadShort(file));
     Weapon2.SelectedIndex       = WeaponData.FindIndex(ReadShort(file));
     Weapon3.SelectedIndex       = WeaponData.FindIndex(ReadShort(file));
     PassiveSkill1.SelectedIndex = PassiveSkillData.FindIndex(ReadShort(file));
     PassiveSkill2.SelectedIndex = PassiveSkillData.FindIndex(ReadShort(file));
 }
Example #13
0
//		public IEnumerator ShowSwallow2()
//		{
//			SwallowEff2.SetActive(true);
//			yield return new WaitForSeconds(1);
//			SwallowEff2.SetActive(false);
//		}
        public void  Init(ItemFielInfo itemFileInfo)
        {
            if (itemFileInfo != null)
            {
                HideOrShow(true);
                Jewel jewel = ItemDataManager.Instance.GetItemData(itemFileInfo.LocalItemData._goodID) as Jewel;
                JewelName.SetText(NGUIColor.SetTxtColor(LanguageTextManager.GetString(itemFileInfo.LocalItemData._szGoodsName), (TextColor)itemFileInfo.LocalItemData._ColorLevel));
                JewelPosition.SetText(ItemInfoTips_Jewel.getJewelPosion(jewel.StonePosition, "、"));
                JewelLevel.SetText(itemFileInfo.materiel.ESTORE_FIELD_LEVEL);
                IconPoint.ClearChild();
                CreatObjectToNGUI.InstantiateObj(jewel._picPrefab, IconPoint);
                if (itemFileInfo.materiel.ESTORE_FIELD_LEVEL < jewel.MaxLevel)
                {
                    Progress_text.gameObject.SetActive(true);
                    FullLevel.SetActive(false);

                    Progress_text.SetText(itemFileInfo.materiel.ESTORE_FIELD_EXP + "/" + jewel.StoneExp[itemFileInfo.materiel.ESTORE_FIELD_LEVEL - 1]);
                    Progress_slider.sliderValue = (float)itemFileInfo.materiel.ESTORE_FIELD_EXP / (float)jewel.StoneExp[itemFileInfo.materiel.ESTORE_FIELD_LEVEL - 1];
                }
                else
                {
                    Progress_text.gameObject.SetActive(false);
                    Progress_slider.sliderValue = 1;
                    FullLevel.SetActive(true);
                }
                //服务器bug器魂初始等级为0为了调试这里+1
                currentskill = JewelBesetManager.GetInstance().passiveSkillDataBase._dataTable.First(c => c.SkillID == jewel.PassiveSkill && c.SkillLevel == itemFileInfo.materiel.ESTORE_FIELD_LEVEL);
                CurrentAtt.Init(currentskill);
                if (itemFileInfo.materiel.ESTORE_FIELD_LEVEL < jewel.MaxLevel)
                {
                    NextrAtt.gameObject.SetActive(true);
                    nextSkill = JewelBesetManager.GetInstance().passiveSkillDataBase._dataTable.First(c => c.SkillID == jewel.PassiveSkill && c.SkillLevel == (itemFileInfo.materiel.ESTORE_FIELD_LEVEL + 1));
                    NextrAtt.Init(nextSkill);
                    NoneAtt.gameObject.SetActive(false);
                }
                else
                {
                    NextrAtt.gameObject.SetActive(false);
                    NoneAtt.gameObject.SetActive(true);
                }
            }
            else
            {
                HideOrShow(false);
            }
        }
Example #14
0
    private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets,
                                               string[] movedAssets, string[] movedFromPath)
    {
        if (CheckResModified(importedAssets) || CheckResModified(deletedAssets) || CheckResModified(movedAssets))
        {
            string     path = System.IO.Path.Combine(EW_RESOURCE_SKILL_CONFIG_FOLDER, "PlayerPassiveSkill.xml");
            TextReader tr   = new StreamReader(path);
            string     text = tr.ReadToEnd();

            if (text == null)
            {
                Debug.LogError("Bullet data file not exist");
                return;
            }
            else
            {
                XmlSpreadSheetReader.ReadSheet(text);
                XmlSpreadSheet sheet = XmlSpreadSheetReader.Output;
                string[]       keys  = XmlSpreadSheetReader.Keys;

                object[] levelIds = sheet[keys[0]];

                List <PassiveSkillData> tempList = new List <PassiveSkillData>();

                for (int i = 2; i < levelIds.Length; i++)
                {
                    PassiveSkillData data = new PassiveSkillData();

                    data.SkillID    = Convert.ToInt32(sheet["SkillID"][i]);
                    data.SkillLevel = Convert.ToInt32(sheet["SkillLevel"][i]);
                    data.MaxLevel   = Convert.ToInt32(sheet["MaxLevel"][i]);
                    data.SkillName  = Convert.ToString(sheet["SkillName"][i]);
                    data.SkillIcon  = Convert.ToString(sheet["SkillIcon"][i]);
                    data.SkillDis   = Convert.ToString(sheet["SkillDis"][i]);

                    string iconPath = System.IO.Path.Combine(SkillIconPrefabPath, data.SkillIcon + ".prefab");
                    data.SkillIconPrefab = AssetDatabase.LoadAssetAtPath(iconPath, typeof(GameObject)) as GameObject;

                    tempList.Add(data);
                }

                CreateBulletDataBase(tempList);
            }
        }
    }
Example #15
0
        private object UpgradeSkill(params object[] objs)
        {
            PassiveSkillData skillVO = objs[0] as PassiveSkillData;

            foreach (PassiveSkillItem item in skillItems)
            {
                if (item.SkillData.SkillID == skillVO.SkillID)
                {
                    item.SkillData = skillVO;
                    if (currentItem != null && currentItem == item)
                    {
                        UpdateReqItem();
                    }
                    break;
                }
            }
            return(null);
        }
Example #16
0
        /// <summary>
        /// Init the specified jewel and SkillLevel.
        /// </summary>
        /// <param name="jewel">Jewel.</param>
        /// <param name="SkillLevel">Skill level.</param>
        public void Init(ItemFielInfo itemFielInfo, bool isSuit)
        {
            ItemId = itemFielInfo.LocalItemData._goodID;
            jewel  = ItemDataManager.Instance.GetItemData(ItemId) as Jewel;

            if (isSuit)
            {
                Title.SetText("套装属性");
                skillId    = jewel._activePassiveSkill.skillID;
                skillLevel = jewel._activePassiveSkill.skillLevel;
            }
            else
            {
                Title.SetText("器魂属性");

                skillId = jewel.PassiveSkill;
                if (itemFielInfo.sSyncContainerGoods_SC.uidGoods != 0)
                {
                    skillLevel = itemFielInfo.materiel.ESTORE_FIELD_LEVEL;
                }
                else
                {
                    EquiptSlotType   type       = (EquiptSlotType)JewelBesetManager.GetInstance().Sc_Container.SelectItemFileInfo.sSyncContainerGoods_SC.nPlace;
                    List <JewelInfo> jewelInfos = PlayerDataManager.Instance.GetJewelInfo(type);
                    foreach (var item in jewelInfos)
                    {
                        if (item.JewelID == jewel._goodID)
                        {
                            skillLevel = item.JewelLevel;
                        }
                    }
                }
            }
            SkillLevel.SetText(string.Format(LanguageTextManager.GetString("IDS_I9_29"), skillLevel));
            if (skillLevel == 0)
            {
                skillLevel++;
            }
            passiveSkillData = _PassiveSkillDataBase._dataTable.First(c => (c.SkillID == skillId && c.SkillLevel == skillLevel));
            SkillName.SetText(LanguageTextManager.GetString(passiveSkillData.SkillName));
            AttributeContent.Init(passiveSkillData);
        }
Example #17
0
        public static void UpdateRolePetSkill(GameClient client)
        {
            List <PassiveSkillData> resultList = new List <PassiveSkillData>();

            List <GoodsData> petList = client.ClientData.DamonGoodsDataList;
            GoodsData        warPet  = client.ClientData.DamonGoodsDataList.Find(_g => _g.Using > 0);

            if (warPet != null)
            {
                List <PetSkillInfo> allSkillList = new List <PetSkillInfo>();
                List <PetSkillInfo> petSkillList = GetPetSkillInfo(warPet);
                var temp = from info in petSkillList
                           where info.PitIsOpen && info.SkillID > 0
                           select info;

                if (temp.Any())
                {
                    foreach (var t in temp)
                    {
                        SystemXmlItem systemMagic = null;
                        if (!GameManager.SystemMagicsMgr.SystemXmlItemDict.TryGetValue(t.SkillID, out systemMagic))
                        {
                            continue;
                        }

                        PassiveSkillData data = new PassiveSkillData();
                        data.skillId     = t.SkillID;
                        data.skillLevel  = t.Level;
                        data.triggerRate = (int)(systemMagic.GetDoubleValue("TriggerOdds") * 100);
                        data.triggerType = systemMagic.GetIntValue("TriggerType");
                        data.coolDown    = systemMagic.GetIntValue("CDTime");
                        data.triggerCD   = systemMagic.GetIntValue("TriggerCD");

                        resultList.Add(data);
                    }
                }
            }

            client.passiveSkillModule.UpdateSkillList(resultList);
            JingLingQiYuanManager.getInstance().RefreshProps(client);
        }
Example #18
0
        public static void RemoveSkill(this PassiveSkillComponent self, string skillId)
        {
            if (self.skillList.ContainsKey(skillId))
            {
                PassiveSkillData data = Game.Scene.GetComponent <SkillConfigComponent>().GetPassiveSkill(skillId);

                if (data.listenToEvent)
                {
                    if (self.bufferDatas.ContainsKey(data.skillId))
                    {
                        if (self.bufferDatas[data.skillId].apply)
                        {
                            self.bufferDatas[data.skillId].apply = false;
                            Game.EventSystem.RemoveEvent(data.eventIdType, self.bufferDatas[data.skillId].aEvent);
                        }
                    }
                }
                SkillHelper.OnPassiveSkillRemove(self.GetParent <Unit>(), skillId);
                self.skillList.Remove(skillId);
            }
        }
Example #19
0
        /// <summary>
        /// Init the specified jewel and SkillLevel.
        /// </summary>
        /// <param name="jewel">Jewel.</param>
        /// <param name="SkillLevel">Skill level.</param>
        public void Init(Jewel jewel, bool isSuit)
        {
            if (isSuit)
            {
                Title.SetText("套装属性");
                skillId    = jewel._activePassiveSkill.skillID;
                skillLevel = jewel._activePassiveSkill.skillLevel;
            }
            else
            {
                Title.SetText("器魂属性");

                skillId    = jewel.PassiveSkill;
                skillLevel = 1;
            }
            SkillLevel.SetText(string.Format(LanguageTextManager.GetString("IDS_I9_29"), skillLevel));
            if (skillLevel == 0)
            {
                skillLevel++;
            }
            passiveSkillData = _PassiveSkillDataBase._dataTable.First(c => (c.SkillID == skillId && c.SkillLevel == skillLevel));
            SkillName.SetText(LanguageTextManager.GetString(passiveSkillData.SkillName));
            AttributeContent.Init(passiveSkillData);
        }
Example #20
0
 public void Show(PassiveSkillData passiveSkillData)
 {
     ResetWidgetInfo();
     DesLabel.SetText(string.Format("{0} : {1}", LanguageTextManager.GetString(passiveSkillData.SkillName), LanguageTextManager.GetString(passiveSkillData.SkillDis)));
     CreatObjectToNGUI.InstantiateObj(passiveSkillData.SkillIconPrefab, CreatItemIconTransform);
 }
Example #21
0
 public void Init(PassiveSkillData skilldata)
 {
     CreatObjectToNGUI.InstantiateObj(skilldata.SkillIconPrefab, IconPoint);
     ContentLable.SetText(LanguageTextManager.GetString(skilldata.SkillDis));
 }
Example #22
0
        /// <summary>
        /// 初始装备信息栏,添加信息prefab
        /// </summary>
        /// <param name="itemFielInfo">Item fiel info.</param>
        public override void Init(ItemFielInfo itemFielInfo, bool isLeftPos, bool Cansale)
        {
            List <JewelInfo> jewelInfos = PlayerDataManager.Instance.GetJewelInfo((EquiptSlotType)int.Parse((itemFielInfo.LocalItemData as EquipmentData)._vectEquipLoc));

            m_AutoAddDragTool.ClearAll();
            EquipItemMainProperty mainPropertyObj = (Instantiate(MainPropertyPrefab) as GameObject).GetComponent <EquipItemMainProperty>();

            mainPropertyObj.gameObject.AddComponent <BoxCollider>().size = new Vector3(300, 200, 1);
            //EquipItemMainProperty mainPropertyObj = CreatObjectToNGUI.InstantiateObj(MainPropertyPrefab,Grid).GetComponent<EquipItemMainProperty>();
            //mainPropertyObj.transform.localPosition = Vector3.zero;
            mainPropertyObj.Init(itemFielInfo);
            AddObj(mainPropertyObj.gameObject);

            SingleItemTipsEffect mainAtbObj = (Instantiate(IsShowEquiptItem?MainAttribute_NormalPrefab:MainAttribute_CompairPrefab) as GameObject).GetComponent <SingleItemTipsEffect>();

            //SingleItemTipsEffect mainAtbObj = CreatObjectToNGUI.InstantiateObj(IsShowEquiptItem?MainAttribute_CompairPrefab:MainAttribute_NormalPrefab ,Grid).GetComponent<SingleItemTipsEffect>();
            mainAtbObj.Init(itemFielInfo, IsShowEquiptItem?SingleItemTipsEffect.EffectType.MainAttribute:SingleItemTipsEffect.EffectType.MainAttributeCompair);
            AddObj(mainAtbObj.gameObject);

            if (EquipItem.GetItemInfoDetail(itemFielInfo, EquipInfoType.Prop1MainAdd) != "+0")
            {
                SingleItemTipsEffect normalAdd = (Instantiate(MainAttribute_NormalPrefab) as GameObject).GetComponent <SingleItemTipsEffect>();
                //SingleItemTipsEffect normalAdd = CreatObjectToNGUI.InstantiateObj(MainAttribute_NormalPrefab ,Grid).GetComponent<SingleItemTipsEffect>();
                normalAdd.Init(itemFielInfo, SingleItemTipsEffect.EffectType.MainProAdd);
                AddObj(normalAdd.gameObject);
            }

            if (EquipItem.GetItemInfoDetail(itemFielInfo, EquipInfoType.Prop1StarAdd) != "+0")
            {
                SingleItemTipsEffect normalAdd = (Instantiate(MainAttribute_NormalPrefab) as GameObject).GetComponent <SingleItemTipsEffect>();
                //SingleItemTipsEffect normalAdd = CreatObjectToNGUI.InstantiateObj(MainAttribute_NormalPrefab ,Grid).GetComponent<SingleItemTipsEffect>();
                normalAdd.Init(itemFielInfo, SingleItemTipsEffect.EffectType.MainProAddForStar);
                AddObj(normalAdd.gameObject);
            }
            if (Cansale)
            {
                if (jewelInfos[0].JewelID != 0) //1号孔已镶嵌
                {
                    jewel1 = ItemDataManager.Instance.GetItemData(jewelInfos[0].JewelID) as Jewel;
                    skill  = _PassiveSkillDataBase._dataTable.First(c => c.SkillID == jewel1.PassiveSkill && c.SkillLevel == jewelInfos[0].JewelLevel);
                    EquipmentAtt_Jewel att = (Instantiate(MainAttribute_jewelPrefab) as GameObject).GetComponent <EquipmentAtt_Jewel>();
                    att.init(jewel1, skill, false, jewel1._ColorLevel);
                    AddObj(att.gameObject);
                }
                if (jewelInfos[1].JewelID != 0) //2号孔已镶嵌
                {
                    jewel2 = ItemDataManager.Instance.GetItemData(jewelInfos[1].JewelID) as Jewel;
                    skill  = _PassiveSkillDataBase._dataTable.First(c => c.SkillID == jewel2.PassiveSkill && c.SkillLevel == jewelInfos[1].JewelLevel);
                    EquipmentAtt_Jewel att = (Instantiate(MainAttribute_jewelPrefab) as GameObject).GetComponent <EquipmentAtt_Jewel>();
                    att.init(jewel2, skill, false, jewel2._ColorLevel);
                    AddObj(att.gameObject);
                }
                if (jewelInfos[0].JewelID != 0 && jewelInfos[1].JewelID != 0 && jewelInfos[0].JewelID != jewelInfos[1].JewelID)
                {
                    if (jewel1.StoneGrop != 0 && jewel1.StoneGrop == jewel2.StoneGrop)
                    {
                        skill = _PassiveSkillDataBase._dataTable.First(c => c.SkillID == jewel1._activePassiveSkill.skillID && c.SkillLevel == jewel1._activePassiveSkill.skillLevel);
                        EquipmentAtt_Jewel att = (Instantiate(MainAttribute_jewelPrefab) as GameObject).GetComponent <EquipmentAtt_Jewel>();
                        att.init(jewel2, skill, true, jewel2._ColorLevel);
                        AddObj(att.gameObject);
                    }
                }
            }
            GameObject desLabel = (Instantiate(DesPanelPrefab) as GameObject);

            desLabel.GetComponent <SingleButtonCallBack>().SetButtonText(LanguageTextManager.GetString(itemFielInfo.LocalItemData._szDesc));
            AddObj(desLabel);
            if (Cansale)
            {
                GameObject PriceLabel = (Instantiate(PricePanelPrefab) as GameObject);
                PriceLabel.GetComponent <ItemPricePanel>().SetPrice(itemFielInfo.LocalItemData._SaleCost + itemFielInfo.equipmentEntity.ITEM_FIELD_VISIBLE_COMM);
                AddObj(PriceLabel);
            }
            base.Init(itemFielInfo, isLeftPos, Cansale);
        }
Example #23
0
        PassiveSkillData GetPassiveData(int skillID, int level)
        {
            PassiveSkillData getData = PassiveSkillData._dataTable.FirstOrDefault(P => P.SkillID == skillID && P.SkillLevel == level);

            return(getData);
        }
Example #24
0
 private void ParsePassiveSkillTable(DataTable passiveSkillTable)
 {
     this.m_PassiveSkillDic = new Dictionary<int, PassiveSkillData>();
     foreach (DataRow row in passiveSkillTable.Rows)
     {
         PassiveSkillData data = new PassiveSkillData();
         this.ParseSkillDataBase(row, data);
         this.m_PassiveSkillDic.Add(data.ID, data);
     }
 }