Ejemplo n.º 1
0
    void Start()
    {
        m_button = new YGUISystem.GUIButton(transform.Find("Button").gameObject, ()=>{
            return true;
        });

        m_name = new YGUISystem.GUILable(transform.Find("Desc").gameObject);

        SetItemDesc();
    }
Ejemplo n.º 2
0
    public void Init(GameObject tab, ItemObject itemObj)
    {
        m_itemObjOfWarehouse = itemObj;
        m_priceButton0 = new GUIPriceGemButton(transform, "GUIPriceButton0", ()=>{return true;});

        m_evolutionText = new YGUISystem.GUILable(transform.Find("PictureButton/Icon/EvolutionText").gameObject);
        m_item = new YGUISystem.GUIButton(transform.Find("PictureButton").gameObject, m_priceButton0.EnableChecker);
        m_item.Icon.Lable.Text.text = itemObj.Item.Description();
        m_item.Icon.Image = itemObj.ItemIcon;

        m_maxGoldPrice = new YGUISystem.GUIButton(transform.Find("MaxPriceButton").gameObject, m_priceButton0.EnableChecker);
        m_maxGoldPrice.Button.gameObject.SetActive(false);

        m_maxGemPrice = new YGUISystem.GUIButton(transform.Find("MaxGemButton").gameObject, m_priceButton0.EnableChecker);
        m_maxGemPrice.Button.gameObject.SetActive(false);

        m_iconAnimator = transform.Find("PictureButton/Icon").GetComponent<Animator>();
        m_item.Lable.Text.text = RefData.Instance.RefTexts(itemObj.Item.RefItem.desc);
        m_checkImage = tab.transform.Find("Checked").gameObject;
    }
Ejemplo n.º 3
0
    void Start()
    {
        m_rewardPanel = transform.Find("RewardPanel").gameObject;
        m_rewardPanel.SetActive(false);

        m_rewardButton = new YGUISystem.GUIButton(m_rewardPanel.transform.Find("OKButton").gameObject, ()=>{return true;});

        m_gold = new YGUISystem.GUIImageStatic(transform.Find("GoldImage").gameObject, Warehouse.Instance.Gold.ItemIcon);
        m_goldMedal = new YGUISystem.GUIImageStatic(transform.Find("GoldMedalImage").gameObject, Warehouse.Instance.GoldMedal.ItemIcon);
        m_gem = new YGUISystem.GUIImageStatic(transform.Find("GemImage").gameObject, Warehouse.Instance.Gem.ItemIcon);

        m_icons[(int)SlotType.Gold] = Resources.Load("Sprites/Gold") as Texture;
        m_icons[(int)SlotType.Gem] = Resources.Load("Sprites/Gem") as Texture;
        m_icons[(int)SlotType.GoldMedal] = Resources.Load("Sprites/GoldMedal") as Texture;

        m_abilities.Add(new Ability(0.05f, SlotType.Gold, 1000));
        m_abilities.Add(new Ability(0.1f, SlotType.Gold, 500));
        m_abilities.Add(new Ability(0.3f, SlotType.Gold, 100));
        m_abilities.Add(new Ability(0.01f, SlotType.Gem, 10));
        m_abilities.Add(new Ability(0.1f, SlotType.Gem, 5));
        m_abilities.Add(new Ability(0.3f, SlotType.Gem, 1));
        m_abilities.Add(new Ability(0.2f, SlotType.GoldMedal, 10));
        m_abilities.Add(new Ability(0.3f, SlotType.GoldMedal, 5));
        m_abilities.Add(new Ability(0.5f, SlotType.GoldMedal, 1));

        for(int i = 0; i < m_statButtons.Length; ++i)
            m_statButtons[i] = new YGUISystem.GUIButton(transform.Find("StatButton"+i).gameObject, ()=>{return true;});

        m_rollButton = new YGUISystem.GUIPriceButton(transform.Find("RollingButton").gameObject, Const.StartPosYOfPriceButtonImage, ()=>{
            return m_rollable && m_rewardPanel.activeSelf == false;
        });
        m_rollButton.Prices = RefData.Instance.RefItems[Const.SlotMachineRollRefItemId].levelup.conds;

        transform.Find("RollingButton").gameObject.SetActive(true);

        RandomAbility(false);
    }
Ejemplo n.º 4
0
    void Start()
    {
        m_champ = GameObject.Find("Champ").GetComponent<Champ>();
        m_statusGUI = transform.parent.parent.Find("StatusGUI").GetComponent<ChampStatusGUI>();

        List<Ability> basicAbili = new List<Ability>();
        List<Ability> skillAbili = new List<Ability>();
        List<Ability> utilAbili = new List<Ability>();

        basicAbili.Add(new Ability(0.3f, "Damage",
        ()=>{
            m_backup.AlphaPhysicalAttackDamage+=3;
            int backup = m_champ.WeaponHolder.MainWeapon.GetDamage(m_backup);

            return m_champ.WeaponHolder.MainWeapon.GetDamage(m_champ.m_creatureProperty) + " -> " + "<color=yellow>" + (backup) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaPhysicalAttackDamage+=3;
            --m_champ.RemainStatPoint;
        }));
        /*
        m_abilities.Add(new Ability(0.3f, "Inc Defence",
        ()=>{
            m_backup.AlphaPhysicalDefencePoint+=3;
            return m_champ.m_creatureProperty.PhysicalDefencePoint + " -> " + "<color=yellow>" + (m_backup.PhysicalDefencePoint) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaPhysicalDefencePoint+=3;
            --m_champ.RemainStatPoint;
        }));
        */
        basicAbili.Add(new Ability(0.3f, "Health Max Up",
        ()=>{
            m_backup.AlphaMaxHP+=50;
            return m_champ.m_creatureProperty.MaxHP + " -> " + "<color=yellow>" + (m_backup.MaxHP) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaMaxHP+=50;
            //m_champ.m_creatureProperty.Heal((int)m_champ.m_creatureProperty.MaxHP);
            --m_champ.RemainStatPoint;
        }));
        /*
        basicAbili.Add(new Ability(0.3f, "SP Max Up",
                                        ()=>{
            m_backup.AlphaMaxSP+=30;
            return m_champ.m_creatureProperty.MaxSP + " -> " + "<color=yellow>" + (m_backup.MaxSP) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaMaxSP+=30;
            --m_champ.RemainStatPoint;
        }));

        basicAbili.Add(new Ability(0.3f, "SP Recovery Up",
                                        ()=>{
            m_backup.AlphaSPRecoveryPerSec+=1;
            return m_champ.m_creatureProperty.SPRecoveryPerSec + " -> " + "<color=yellow>" + (m_backup.SPRecoveryPerSec) + "/sec</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaSPRecoveryPerSec+=1;
            --m_champ.RemainStatPoint;
        }));
        */
        basicAbili.Add(new Ability(0.3f, "Move Speed Up",
                                        ()=>{
            m_backup.AlphaMoveSpeed+=1;
            return m_champ.m_creatureProperty.AlphaMoveSpeed + " -> " + "<color=yellow>" + (m_backup.AlphaMoveSpeed) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaMoveSpeed+=1;
            --m_champ.RemainStatPoint;
        },
        ()=>{
            return m_champ.m_creatureProperty.AlphaMoveSpeed < Const.MaxAlphaMoveSpeed;
        }
        ));

        basicAbili.Add(new Ability(0.3f, "Critical Pack",
        ()=>{
            m_backup.AlphaCriticalChance += 0.1f;
            m_backup.AlphaCriticalDamage += 0.5f;
            return "Chance:"+(m_champ.m_creatureProperty.CriticalChance*100) + " -> " + "<color=yellow>" + (m_backup.CriticalChance*100) + "%</color>" + "\n" +
                "Damage:"+(m_champ.m_creatureProperty.CriticalDamage*100) + " -> " + "<color=yellow>" + (m_backup.CriticalDamage*100) + "%</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaCriticalChance += 0.1f;
            m_champ.m_creatureProperty.AlphaCriticalDamage += 0.5f;
            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampFiregunRefItemId:
                return false;
            }

            return true;
        }
        ));

        /*
        m_abilities.Add(new Ability(0.1f, "Life Per Kill",
        ()=>{
            m_backup.AlphaLifeSteal += 1f;
            return (m_champ.m_creatureProperty.LifeSteal) + " -> " + "<color=yellow>" + (m_backup.LifeSteal) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.AlphaLifeSteal += 1f;
            --m_champ.RemainStatPoint;
        }));
        */

        /*
        basicAbili.Add(new Ability(0.01f, "Weapon Lv Up",
                                    ()=>{
            Weapon weapon = m_champ.WeaponHolder.MainWeapon;
            int backup = weapon.Level+1;
            int ori = weapon.Level;
            return "Lv:" + (ori) + " -> " + "<color=yellow>" + (backup) + "</color>";
        },
        ()=>{
            m_champ.WeaponHolder.MainWeapon.LevelUp();
            --m_champ.RemainStatPoint;
        }
        ));
        */
        skillAbili.Add(new Ability(0.3f, RefData.Instance.RefTexts(RefData.Instance.RefItems[Const.EmbersRefItemId].name),
                                    ()=>{
            Weapon weapon = m_champ.WeaponHolder.MainWeapon.GetSubWeapon();
            int backup = 1;
            int ori = 0;
            if (weapon != null)
            {
                backup = weapon.Level+1;
                ori = weapon.Level;
            }

            return "Lv:" + (ori) + " -> " + "<color=yellow>" + (backup) + "</color>";
                //"SP:" + Weapon.GetSP(RefData.Instance.RefItems[132], ori) + " -> " + "<color=yellow>" +Weapon.GetSP(RefData.Instance.RefItems[132], backup)+ "</color>";
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.MainWeapon.GetSubWeapon();
            if (weapon != null)
            {
                weapon.LevelUp();
            }
            else
            {
                m_champ.SetSubWeapon(m_champ.WeaponHolder.MainWeapon, new ItemWeaponData(Const.EmbersRefItemId), new RefMob.WeaponDesc());
            }

            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampGunRefItemId:
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampFiregunRefItemId:
            case Const.ChampBoomerangLauncherRefItemId:
                return false;
            }

            Weapon weapon = m_champ.WeaponHolder.MainWeapon.GetSubWeapon();
            if (weapon != null)
            {
                if (weapon.Level >= weapon.RefWeaponItem.maxLevel)
                    return false;
            }
            return true;
        }
        ));

        foreach (DamageDesc.BuffType buffType in System.Enum.GetValues(typeof(DamageDesc.BuffType)))
        {
            bool skip = false;
            switch(buffType)
            {
            case DamageDesc.BuffType.Count:
            case DamageDesc.BuffType.LevelUp:
            case DamageDesc.BuffType.Nothing:
            case DamageDesc.BuffType.Macho:
                skip = true;
                break;
            }

            if (skip == true)
                continue;

            string name = buffType.ToString() + " Chance";
            DamageDesc.BuffType capturedBuffType = buffType;

            utilAbili.Add(new Ability(0.3f, name,
                                        ()=>{
                float oriChance = m_champ.WeaponHolder.MainWeapon.WeaponStat.buffOnHitDesc.chance;
                float toChance = oriChance + 0.1f;
                return (oriChance*100) + " -> " + "<color=yellow>" + (toChance*100) + "%</color>";
            },
            ()=>{
                m_champ.WeaponHolder.MainWeapon.WeaponStat.buffOnHitDesc.chance += 0.1f;
                --m_champ.RemainStatPoint;
            },
            ()=>{

                return (m_champ.WeaponHolder.MainWeapon.WeaponStat.buffOnHitDesc.buffType == capturedBuffType &&
                        m_champ.WeaponHolder.MainWeapon.WeaponStat.buffOnHitDesc.chance < 100
                        );
            }
            ));
        }

        /*
        skillAbili.Add(new Ability(0.3f, "Fill " + (m_champ.WeaponHolder.MainWeapon.WeaponStat.skillId > 0 ? RefData.Instance.RefTexts(RefData.Instance.RefItems[m_champ.WeaponHolder.MainWeapon.WeaponStat.skillId].name) : ""),
                                   ()=>{
            int backup = m_champ.NuclearSkillStack+3;
            return (m_champ.NuclearSkillStack) + " -> " + "<color=yellow>" + (backup) + "</color>";
        },
        ()=>{
            m_champ.NuclearSkillStack += 3;
            --m_champ.RemainStatPoint;
        },
        ()=>{
            return m_champ.WeaponHolder.MainWeapon.WeaponStat.skillId > 0;
        }
        ));

        skillAbili.Add(new Ability(0.3f, "Fill Macho Skill",
                                   ()=>{
            int backup = m_champ.MachoSkillStack+3;
            return (m_champ.MachoSkillStack) + " -> " + "<color=yellow>" + (backup) + "</color>";
        },
        ()=>{
            m_champ.MachoSkillStack += 3;
            --m_champ.RemainStatPoint;
        }));
        */
        skillAbili.Add(new Ability(0.3f, RefData.Instance.RefTexts(RefData.Instance.RefItems[131].name),
                                    ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(131);
            int backup = 1;
            int ori = 0;
            if (weapon != null)
            {
                backup = weapon.Level+1;
                ori = weapon.Level;
            }

            return "Lv:" + (ori) + " -> " + "<color=yellow>" + (backup) + "</color>";
                //"SP:" + Weapon.GetSP(RefData.Instance.RefItems[131], ori) + " -> " + "<color=yellow>" +Weapon.GetSP(RefData.Instance.RefItems[131], backup)+ "</color>";
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(131);
            if (weapon != null)
            {
                weapon.LevelUp();
            }
            else
            {
                m_champ.EquipPassiveSkillWeapon(new ItemWeaponData(131), null);
            }

            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampGunRefItemId:
                Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(131);
                if (weapon != null)
                {
                    if (weapon.Level >= weapon.RefWeaponItem.maxLevel)
                        return false;
                }
                return true;
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampFiregunRefItemId:
            case Const.ChampGuidedRocketLauncherRefItemId:
            case Const.ChampRocketLauncherRefItemId:
            case Const.ChampBoomerangLauncherRefItemId:
                break;
            }

            return false;
        }
        ));

        skillAbili.Add(new Ability(0.3f, RefData.Instance.RefTexts(RefData.Instance.RefItems[134].name),
                                   ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(134);
            int backup = 1;
            int ori = 0;
            if (weapon != null)
            {
                backup = weapon.Level+1;
                ori = weapon.Level;
            }

            return "Lv:" + (ori) + " -> " + "<color=yellow>" + (backup) + "</color>";
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(134);
            if (weapon != null)
            {
                weapon.LevelUp();
            }
            else
            {
                m_champ.EquipPassiveSkillWeapon(new ItemWeaponData(134), null);
            }

            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampBoomerangLauncherRefItemId:
                Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(134);
                if (weapon != null)
                {
                    if (weapon.Level >= weapon.RefWeaponItem.maxLevel)
                        return false;
                }
                return true;
            case Const.ChampGunRefItemId:
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampFiregunRefItemId:
            case Const.ChampGuidedRocketLauncherRefItemId:
            case Const.ChampRocketLauncherRefItemId:
                break;
            }

            return false;
        }
        ));

        skillAbili.Add(new Ability(0.3f, RefData.Instance.RefTexts(RefData.Instance.RefItems[129].name),
                                   ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(129);
            int backup = 1;
            int ori = 0;
            if (weapon != null)
            {
                backup = weapon.Level+1;
                ori = weapon.Level;
            }

            return "Lv:" + (ori) + " -> " + "<color=yellow>" + (backup) + "</color>";
                //"SP:" + Weapon.GetSP(RefData.Instance.RefItems[129], ori) + " -> " + "<color=yellow>" +Weapon.GetSP(RefData.Instance.RefItems[129], backup)+ "</color>";
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(129);
            if (weapon != null)
            {
                weapon.LevelUp();
            }
            else
            {
                m_champ.EquipPassiveSkillWeapon(new ItemWeaponData(129), null);
            }

            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampLightningLauncherRefItemId:
                Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(129);
                if (weapon != null)
                {
                    if (weapon.Level >= weapon.RefWeaponItem.maxLevel)
                        return false;
                }
                return true;
            case Const.ChampFiregunRefItemId:
            case Const.ChampGunRefItemId:
            case Const.ChampBoomerangLauncherRefItemId:
            case Const.ChampGuidedRocketLauncherRefItemId:
            case Const.ChampRocketLauncherRefItemId:
                break;
            }

            return false;
        }
        ));

        skillAbili.Add(new Ability(0.3f, RefData.Instance.RefTexts(RefData.Instance.RefItems[135].name),
                                   ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(135);
            int backup = 1;
            int ori = 0;
            if (weapon != null)
            {
                backup = weapon.Level+1;
                ori = weapon.Level;
            }

            return "Lv:" + (ori) + " -> " + "<color=yellow>" + (backup) + "</color>";
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(135);
            if (weapon != null)
            {
                weapon.LevelUp();
            }
            else
            {
                m_champ.EquipPassiveSkillWeapon(new ItemWeaponData(135), null);
            }

            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampFiregunRefItemId:

                Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(135);
                if (weapon != null)
                {
                    if (weapon.Level >= weapon.RefWeaponItem.maxLevel)
                        return false;
                }
                return true;
            case Const.ChampGunRefItemId:
            case Const.ChampBoomerangLauncherRefItemId:
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampGuidedRocketLauncherRefItemId:
            case Const.ChampRocketLauncherRefItemId:
                return false;
            }

            return false;

        }
        ));
        /*
        skillAbili.Add(new Ability(0.3f, "Charge to Nuclear Skill",
                                   ()=>{
            return (m_champ.NuclearSkillStack) + " -> " + "<color=yellow>" + (m_champ.NuclearSkillStack+1) + "</color>" + "\n" +
                    "SP:" + Weapon.GetSP(RefData.Instance.RefItems[133], 1);
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetActiveWeapon(133);
            if (weapon != null)
            {
                //weapon.LevelUp();
            }
            else
            {
                m_champ.EquipActiveWeapon(new ItemWeaponData(133, null));
            }
            ++m_champ.NuclearSkillStack;
            --m_champ.RemainStatPoint;
        }));
        */
        skillAbili.Add(new Ability(0.3f, "Fill " + RefData.Instance.RefItems[130].name,
                                   ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(130);
            m_backup.Shield += 10;
            return (m_champ.m_creatureProperty.Shield) + " -> " + "<color=yellow>" + (m_backup.Shield) + "</color>";
                //"SP:" + Weapon.GetSP(RefData.Instance.RefItems[130], 1);
        },
        ()=>{
            Weapon weapon = m_champ.WeaponHolder.GetPassiveSkillWeapon(130);
            if (weapon != null)
            {
                weapon.LevelUp();
            }
            else
            {
                m_champ.EquipPassiveSkillWeapon(new ItemWeaponData(130), null);
            }

            --m_champ.RemainStatPoint;
        }));

        utilAbili.Add(new Ability(0.3f, "Splash Radius",
                                  ()=>{

            m_backup.SplashRadius+=1;

            return (m_champ.m_creatureProperty.SplashRadius) + " -> " + "<color=yellow>" + (m_backup.SplashRadius) + "m</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.SplashRadius+=1;

            --m_champ.RemainStatPoint;
        },
        ()=>{
            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampFiregunRefItemId:
            case Const.ChampGunRefItemId:
            case Const.ChampBoomerangLauncherRefItemId:
                return false;
            case Const.ChampGuidedRocketLauncherRefItemId:
            case Const.ChampRocketLauncherRefItemId:
                return true;
            }

            return false;
        }
        ));

        utilAbili.Add(new Ability(0.3f, "Flamethrower Length",
                                  ()=>{

            m_backup.BulletAlphaLength+=0.25f;

            return (m_champ.m_creatureProperty.BulletLength) + " -> " + "<color=yellow>" + (m_backup.BulletLength) + "m</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.BulletAlphaLength+=0.25f;

            --m_champ.RemainStatPoint;
        },
        ()=>{
            if (m_champ.m_creatureProperty.BulletLength >= 1f)
                return false;

            switch(m_champ.WeaponHolder.MainWeapon.RefWeaponItem.id)
            {
            case Const.ChampFiregunRefItemId:
                return true;
            case Const.ChampLightningLauncherRefItemId:
            case Const.ChampGunRefItemId:
            case Const.ChampBoomerangLauncherRefItemId:
            case Const.ChampGuidedRocketLauncherRefItemId:
            case Const.ChampRocketLauncherRefItemId:
                return false;
            }

            return false;
        }
        ));

        utilAbili.Add(new Ability(0.3f, "Followers On Summoning",
                                  ()=>{

            m_backup.CallableFollowers+=1;

            return (m_champ.m_creatureProperty.CallableFollowers) + " -> " + "<color=yellow>" + (m_backup.CallableFollowers) + "</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.CallableFollowers+=1;

            --m_champ.RemainStatPoint;
        },
        ()=>{
            for(int i = 0; i < m_champ.AccessoryItems.Length; ++i)
            {
                if (m_champ.AccessoryItems[i] != null &&
                    m_champ.AccessoryItems[i].Item.RefItem.type == ItemData.Type.Follower &&
                    m_champ.m_creatureProperty.CallableFollowers < Const.MaxCallableFollowers
                    )
                    return true;
            }
            return false;
        }
        ));

        utilAbili.Add(new Ability(0.3f, "Gain Extra XP",
                                  ()=>{
            m_backup.GainExtraExp += 0.5f;
            return (m_champ.m_creatureProperty.GainExtraExp*100) + " -> " + "<color=yellow>" + (m_backup.GainExtraExp*100) + "%</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.GainExtraExp += 0.5f;
            --m_champ.RemainStatPoint;
        }));

        utilAbili.Add(new Ability(0.3f, "Gain Extra Gold",
                                  ()=>{
            m_backup.GainExtraGold += 0.5f;
            return (m_champ.m_creatureProperty.GainExtraGold*100) + " -> " + "<color=yellow>" + (m_backup.GainExtraGold*100) + "%</color>";
        },
        ()=>{
            m_champ.m_creatureProperty.GainExtraGold += 0.5f;
            --m_champ.RemainStatPoint;
        }));

        m_abilities.Add(AbilityCategory.ChampStat, basicAbili);
        m_abilities.Add(AbilityCategory.Skill, skillAbili);
        m_abilities.Add(AbilityCategory.Weapon, utilAbili);

        for(int i = 0; i < m_statButtons.Length; ++i)
            m_statButtons[i] = new YGUISystem.GUIButton(transform.Find("StatButton"+i).gameObject, ()=>{return true;});

        m_remainPointText = new YGUISystem.GUILable(transform.Find("Text/RemainPointText").gameObject);

        m_rollButton = new YGUISystem.GUIPriceButton(transform.Find("RollingButton").gameObject, Const.StartPosYOfPriceButtonImage, ()=>{
            return m_champ.RemainStatPoint > 0;
        });
        m_rollButton.Prices = RefData.Instance.RefItems[Const.RandomAbilityRefItemId].levelup.conds;

        transform.Find("RollingButton").gameObject.SetActive(Cheat.EnableAbilityRollButton);
        #if UNITY_EDITOR
        if (Const.CHEAT_MODE)
        {
            transform.Find("RollingButton").gameObject.SetActive(true);
        }
        #endif

        RandomAbility(!AutoAssigned);

        AutoAssignedAbillity();
    }
Ejemplo n.º 5
0
 public TabDesc(int index, MultiLang.ID name, ItemData.Type[] itemTypes, YGUISystem.GUIButton tab)
 {
     m_index = index;
     m_tab = tab;
     m_checked = tab.Button.transform.Find("Checked").gameObject;
     m_tab.Lable.Text.text = RefData.Instance.RefTexts(name);
     m_itemTypes = itemTypes;
     m_tabImage = tab.Button.gameObject.GetComponent<Image>();
 }
Ejemplo n.º 6
0
    void Init()
    {
        GPlusPlatform.Instance.AnalyticsTrackEvent("InGame", "Shop", "OpenShop", 0);
        m_paidItems.Add("gem.1000", new PaidItem(100000));
        m_paidItems.Add("gem.3000", new PaidItem(350000));
        m_paidItems.Add("gem.5000", new PaidItem(600000));

        m_closeButton = new YGUISystem.GUIButton(transform.Find("CloseButton").gameObject, ()=>{return true;});
        m_closeButton.Lable.Text.text = RefData.Instance.RefTexts(MultiLang.ID.CheckingYourInventory);

        m_piadItemButtons[0] = new YGUISystem.GUIButton(transform.Find("PaidItemButton0").gameObject, ()=>{
            return _isInitialized && m_progressing == false;
        });
        m_piadItemButtons[0].Lable.Text.text = m_paidItems["gem.1000"].Gem.ToString();

        m_piadItemButtons[1] = new YGUISystem.GUIButton(transform.Find("PaidItemButton1").gameObject, ()=>{
            return _isInitialized && m_progressing == false;
        });
        m_piadItemButtons[1].Lable.Text.text = m_paidItems["gem.3000"].Gem.ToString();

        m_piadItemButtons[2] = new YGUISystem.GUIButton(transform.Find("PaidItemButton2").gameObject, ()=>{
            return _isInitialized && m_progressing == false;
        });
        m_piadItemButtons[2].Lable.Text.text = m_paidItems["gem.5000"].Gem.ToString();

        foreach(KeyValuePair<string, PaidItem> pair in m_paidItems)
        {
            OpenIAB.mapSku(pair.Key, OpenIAB_Android.STORE_GOOGLE, pair.Key);
        }

        var googlePublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyJoNHt3k2PMI0zVAgcQK6QARbGDJQ2KtuD+0JJuVqlaWqi5dv5Gn7zyhaTlwb9w7S65E9ZmnJDgmwhDIROSBDNFqcYxL9dYp8PDj7zhxyVz5fmgTZKMvXp9a2qo84mQ0RTlplhK32GMGCrlzGdh1cYu4Z07da6mEzBjTyGKss/E44QJNVfI982TznB7qXfIgMWp6ZAzLZOsc7CmzKd1qTyKYWu6iZl3BB3bHKRHK6vvHTyxHaf48mjwRAFrkaYESsq5oAm+hKTwR0vrN374mmGG/E5B8ZGI5xBNkmCV9bG2wc6Uqb++uf//T1hM5qcs8LvBlr2iOSGHucWo8mb+o6QIDAQAB";

        var options = new Options();
        options.checkInventoryTimeoutMs = Options.INVENTORY_CHECK_TIMEOUT_MS * 2;
        options.discoveryTimeoutMs = Options.DISCOVER_TIMEOUT_MS * 2;
        options.checkInventory = true;
        options.verifyMode = OptionsVerifyMode.VERIFY_ONLY_KNOWN;
        options.prefferedStoreNames = new string[] { OpenIAB_Android.STORE_GOOGLE };
        options.availableStoreNames = new string[] { OpenIAB_Android.STORE_GOOGLE };
        options.storeKeys = new Dictionary<string, string> { {OpenIAB_Android.STORE_GOOGLE, googlePublicKey} };
        options.storeSearchStrategy = SearchStrategy.INSTALLER_THEN_BEST_FIT;

        m_progressing = true;
        // Transmit options and start the service
        OpenIAB.init(options);
    }
Ejemplo n.º 7
0
    void Start()
    {
        m_level = new YGUISystem.GUILable(transform.Find("Level/Text").gameObject);
        m_gold = transform.Find("Gold/RawImage/Text").gameObject.GetComponent<ComboGUIShake>();
        m_goldMedal = transform.Find("GoldMedal/RawImage/Text").gameObject.GetComponent<ComboGUIShake>();
        m_mobKills = transform.Find("Kills/RawImage/Text").gameObject.GetComponent<ComboGUIShake>();
        m_gem = transform.Find("Gem/RawImage/Text").gameObject.GetComponent<ComboGUIShake>();
        m_dna = transform.Find("DNA/RawImage/Text").gameObject.GetComponent<ComboGUIShake>();

        m_autoEarnButton = new YGUISystem.GUIButton(transform.Find("Special/AutoEarnButton").gameObject, ()=>{
            m_autoEarnButton.Lable.Text.text = Warehouse.Instance.AutoEarnGold.ToString();
            return Warehouse.Instance.AutoEarnGold > 0;
        });

        assignSkillButton(0, Warehouse.Instance.FindItem(21), ()=>{
            return Warehouse.Instance.FindItem(21).Item.Use(m_champ);
        });

        assignSkillButton(1, Warehouse.Instance.FindItem(22), ()=>{
            if (Warehouse.Instance.FindItem(22).Item.Use(m_champ))
            {
                m_champ.Followers.ForEach((Creature follower)=>{
                    Warehouse.Instance.FindItem(22).Item.Use(follower);
                });
                return true;
            }
            return false;
        });

        assignSkillButton(2, Warehouse.Instance.FindItem(23), ()=>{
            return Warehouse.Instance.FindItem(23).Item.Use(m_champ);
        });

        assignSkillButton(3, Warehouse.Instance.FindItem(24), ()=>{
            if (Warehouse.Instance.FindItem(24).Item.Use(m_champ))
            {
                m_champ.Followers.ForEach((Creature follower)=>{
                    Warehouse.Instance.FindItem(24).Item.Use(follower);
                });
                return true;
            }
            return false;
        });

        assignSkillButton(4, Warehouse.Instance.FindItem(25), ()=>{
            return Warehouse.Instance.FindItem(25).Item.Use(m_champ);
        });

        m_guages[0] = new YGUISystem.GUIGuage(transform.Find("Guage/HP").gameObject,
            ()=>{return m_champ.m_creatureProperty.getHPRemainRatio();},
            ()=>{return Mathf.FloorToInt(m_champ.m_creatureProperty.HP).ToString() + " / " + Mathf.FloorToInt(m_champ.m_creatureProperty.MaxHP).ToString();
            }
        );

        m_guages[1] = new YGUISystem.GUIGuage(transform.Find("Guage/XP").gameObject,
            ()=>{return m_champ.m_creatureProperty.getExpRemainRatio();},
            ()=>{return Mathf.FloorToInt(m_champ.m_creatureProperty.Exp).ToString() + " / " + Mathf.FloorToInt(m_champ.m_creatureProperty.MaxExp).ToString();
            }
        );

        m_guages[2] = new YGUISystem.GUIGuage(transform.Find("Guage/SP").gameObject,
            ()=>{return m_champ.m_creatureProperty.getSPRemainRatio();},
            ()=>{return Mathf.FloorToInt(m_champ.m_creatureProperty.SP).ToString() + " / " + Mathf.FloorToInt(m_champ.m_creatureProperty.MaxSP).ToString();
            }
        );

        m_guages[3] = new YGUISystem.GUIGuage(transform.Find("Guage/Shield").gameObject,
                                              ()=>{return 1f;},
        ()=>{return m_champ.m_creatureProperty.Shield.ToString();
        }
        );
    }
Ejemplo n.º 8
0
    void Start()
    {
        m_button = new YGUISystem.GUIButton(transform.Find("Button").gameObject, ()=>{
            return true;
        });

        m_oldEvolution = new YGUISystem.GUILable(transform.Find("Button/Old/EvolutionText").gameObject);
        m_newEvolution = new YGUISystem.GUILable(transform.Find("Button/New/EvolutionText").gameObject);

        m_oldDamage = new YGUISystem.GUILable(transform.Find("Button/Old/DamageText").gameObject);
        m_newDamage = new YGUISystem.GUILable(transform.Find("Button/New/DamageText").gameObject);

        m_evolutionLable = new YGUISystem.GUILable(transform.Find("Button/EvolutionLable").gameObject);
        m_damageLable = new YGUISystem.GUILable(transform.Find("Button/DamageLable").gameObject);

        m_evolutionLable.Text.text = RefData.Instance.RefTexts(MultiLang.ID.EvolutionLevel);
        m_damageLable.Text.text = RefData.Instance.RefTexts(MultiLang.ID.BaseDamage);
    }