Example #1
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();
    }
Example #2
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);
    }
 public GUIPriceGemButton(Transform transform, string buttonPath, System.Func<bool>			enableChecker)
 {
     m_priceButton = new YGUISystem.GUIPriceButton(transform.Find(buttonPath).gameObject, Const.StartPosYOfPriceButtonImage, enableChecker);
     m_gemButton = new YGUISystem.GUIPriceButton(transform.Find(buttonPath + "/GemButton").gameObject, Const.StartPosYOfGemPriceButtonImage, enableChecker);
 }