Example #1
0
    public void AssignAllSkill()
    {
        /*AssignSkill(0 , skill[0]);
        *  AssignSkill(1 , skill[1]);
        *  AssignSkill(2 , skill[2]);*/
        if (!player)
        {
            player = this.gameObject;
        }
        int        n         = 0;
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        while (n <= 2)
        {
            player.GetComponent <AttackTriggerC>().skill[n].manaCost       = dataSkill.skill[skill[n]].manaCost;
            player.GetComponent <AttackTriggerC>().skill[n].skillPrefab    = dataSkill.skill[skill[n]].skillPrefab;
            player.GetComponent <AttackTriggerC>().skill[n].skillAnimation = dataSkill.skill[skill[n]].skillAnimation;
            player.GetComponent <AttackTriggerC>().skill[n].icon           = dataSkill.skill[skill[n]].icon;
            //-------Assign Icon to Skill Button-----------
            if (skillButton[n])
            {
                skillButton[n].GetComponent <GUITexture>().texture           = dataSkill.skill[skill[n]].icon;
                skillButton[n].GetComponent <SkillButtonC>().originalTexture = dataSkill.skill[skill[n]].icon;
                //if(dataSkill.skill[skill[n]].iconDown){
                skillButton[n].GetComponent <SkillButtonC>().downTexture = dataSkill.skill[skill[n]].iconDown;
                //}
            }
            n++;
        }
    }
Example #2
0
    // Token: 0x06000458 RID: 1112 RVA: 0x0001FEC8 File Offset: 0x0001E2C8
    private void SkillShortcut(int windowID)
    {
        SkillDataC component = this.database.GetComponent <SkillDataC>();

        this.windowRect.width  = 360f;
        this.windowRect.height = 185f;
        if (GUI.Button(new Rect(310f, 2f, 30f, 30f), "X"))
        {
            this.OnOffMenu();
        }
        if (GUI.Button(new Rect(30f, 45f, 80f, 80f), component.skill[this.skill[0]].icon))
        {
            this.skillSelect   = 0;
            this.skillListPage = true;
            this.shortcutPage  = false;
        }
        GUI.Label(new Rect(70f, 145f, 20f, 20f), "1");
        if (GUI.Button(new Rect(130f, 45f, 80f, 80f), component.skill[this.skill[1]].icon))
        {
            this.skillSelect   = 1;
            this.skillListPage = true;
            this.shortcutPage  = false;
        }
        GUI.Label(new Rect(170f, 145f, 20f, 20f), "2");
        if (GUI.Button(new Rect(230f, 45f, 80f, 80f), component.skill[this.skill[2]].icon))
        {
            this.skillSelect   = 2;
            this.skillListPage = true;
            this.shortcutPage  = false;
        }
        GUI.Label(new Rect(270f, 145f, 20f, 20f), "3");
        GUI.DragWindow(new Rect(0f, 0f, 10000f, 10000f));
    }
Example #3
0
    public void AssignSkillByID(int slot, int skillId)
    {
        //Use With Canvas UI
        if (slot > GetComponent <AttackTriggerC>().skill.Length)
        {
            return;
        }
        if (GetComponent <AttackTriggerC>().skillCoolDown[slot] > 0 || GetComponent <AttackTriggerC>().isCasting)
        {
            print("This Skill is not Ready");
            return;
        }

        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        GetComponent <AttackTriggerC>().skill[slot].manaCost           = dataSkill.skill[skillId].manaCost;
        GetComponent <AttackTriggerC>().skill[slot].skillPrefab        = dataSkill.skill[skillId].skillPrefab;
        GetComponent <AttackTriggerC>().skill[slot].skillAnimation     = dataSkill.skill[skillId].skillAnimation;
        GetComponent <AttackTriggerC>().skill[slot].mecanimTriggerName = dataSkill.skill[skillId].mecanimTriggerName;

        GetComponent <AttackTriggerC>().skill[slot].icon       = dataSkill.skill[skillId].icon;
        GetComponent <AttackTriggerC>().skill[slot].iconSprite = dataSkill.skill[skillId].iconSprite;
        GetComponent <AttackTriggerC>().skill[slot].sendMsg    = dataSkill.skill[skillId].sendMsg;
        GetComponent <AttackTriggerC>().skill[slot].castEffect = dataSkill.skill[skillId].castEffect;

        GetComponent <AttackTriggerC>().skill[slot].castTime    = dataSkill.skill[skillId].castTime;
        GetComponent <AttackTriggerC>().skill[slot].skillDelay  = dataSkill.skill[skillId].skillDelay;
        GetComponent <AttackTriggerC>().skill[slot].whileAttack = dataSkill.skill[skillId].whileAttack;
        GetComponent <AttackTriggerC>().skill[slot].coolDown    = dataSkill.skill[skillId].coolDown;
        GetComponent <AttackTriggerC>().skill[slot].skillSpawn  = dataSkill.skill[skillId].skillSpawn;

        GetComponent <AttackTriggerC>().skill[slot].requireWeapon     = dataSkill.skill[skillId].requireWeapon;
        GetComponent <AttackTriggerC>().skill[slot].requireWeaponType = dataSkill.skill[skillId].requireWeaponType;

        GetComponent <AttackTriggerC>().skill[slot].soundEffect = dataSkill.skill[skillId].soundEffect;

        int mh = dataSkill.skill[skillId].multipleHit.Length;

        GetComponent <AttackTriggerC>().skill[slot].multipleHit = new SkillAdditionHit[mh];
        for (int m = 0; m < mh; m++)
        {
            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m] = new SkillAdditionHit();

            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m].skillPrefab        = dataSkill.skill[skillId].multipleHit[m].skillPrefab;
            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m].skillAnimation     = dataSkill.skill[skillId].multipleHit[m].skillAnimation;
            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m].mecanimTriggerName = dataSkill.skill[skillId].multipleHit[m].mecanimTriggerName;

            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m].castTime   = dataSkill.skill[skillId].multipleHit[m].castTime;
            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m].skillDelay = dataSkill.skill[skillId].multipleHit[m].skillDelay;

            GetComponent <AttackTriggerC>().skill[slot].multipleHit[m].soundEffect = dataSkill.skill[skillId].multipleHit[m].soundEffect;
        }

        skill[slot] = skillId;
        CheckSameSkill(skill[slot], slot);
    }
Example #4
0
    IEnumerator ShowLearnedSkill(int id)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        showSkillLearned = true;
        showSkillName    = dataSkill.skill[id].skillName;
        yield return(new WaitForSeconds(10.5f));

        showSkillLearned = false;
    }
Example #5
0
    // Token: 0x0600045A RID: 1114 RVA: 0x00020A08 File Offset: 0x0001EE08
    public void AssignSkill(int id, int sk)
    {
        SkillDataC component = this.database.GetComponent <SkillDataC>();

        this.player.GetComponent <AttackTriggerC>().manaCost[id]       = component.skill[this.skillListSlot[sk]].manaCost;
        this.player.GetComponent <AttackTriggerC>().skillPrefab[id]    = component.skill[this.skillListSlot[sk]].skillPrefab;
        this.player.GetComponent <AttackTriggerC>().skillAnimation[id] = component.skill[this.skillListSlot[sk]].skillAnimation;
        this.player.GetComponent <AttackTriggerC>().skillIcon[id]      = component.skill[this.skillListSlot[sk]].icon;
        this.skill[id] = this.skillListSlot[sk];
        MonoBehaviour.print(sk);
    }
Example #6
0
    //-----------------------

    public void AssignSkill(int id, int sk)
    {
        if (GetComponent <AttackTriggerC>().skillCoolDown[id] > 0 || GetComponent <AttackTriggerC>().isCasting)
        {
            print("This Skill is not Ready");
            return;
        }
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        GetComponent <AttackTriggerC>().skill[id].manaCost           = dataSkill.skill[skillListSlot[sk]].manaCost;
        GetComponent <AttackTriggerC>().skill[id].skillPrefab        = dataSkill.skill[skillListSlot[sk]].skillPrefab;
        GetComponent <AttackTriggerC>().skill[id].skillAnimation     = dataSkill.skill[skillListSlot[sk]].skillAnimation;
        GetComponent <AttackTriggerC>().skill[id].mecanimTriggerName = dataSkill.skill[skillListSlot[sk]].mecanimTriggerName;

        GetComponent <AttackTriggerC>().skill[id].icon       = dataSkill.skill[skillListSlot[sk]].icon;
        GetComponent <AttackTriggerC>().skill[id].iconSprite = dataSkill.skill[skillListSlot[sk]].iconSprite;
        GetComponent <AttackTriggerC>().skill[id].sendMsg    = dataSkill.skill[skillListSlot[sk]].sendMsg;
        GetComponent <AttackTriggerC>().skill[id].castEffect = dataSkill.skill[skillListSlot[sk]].castEffect;

        GetComponent <AttackTriggerC>().skill[id].castTime    = dataSkill.skill[skillListSlot[sk]].castTime;
        GetComponent <AttackTriggerC>().skill[id].skillDelay  = dataSkill.skill[skillListSlot[sk]].skillDelay;
        GetComponent <AttackTriggerC>().skill[id].whileAttack = dataSkill.skill[skillListSlot[sk]].whileAttack;
        GetComponent <AttackTriggerC>().skill[id].coolDown    = dataSkill.skill[skillListSlot[sk]].coolDown;
        GetComponent <AttackTriggerC>().skill[id].skillSpawn  = dataSkill.skill[skillListSlot[sk]].skillSpawn;

        GetComponent <AttackTriggerC>().skill[id].requireWeapon     = dataSkill.skill[skillListSlot[sk]].requireWeapon;
        GetComponent <AttackTriggerC>().skill[id].requireWeaponType = dataSkill.skill[skillListSlot[sk]].requireWeaponType;

        GetComponent <AttackTriggerC>().skill[id].soundEffect = dataSkill.skill[skillListSlot[sk]].soundEffect;

        int mh = dataSkill.skill[skillListSlot[sk]].multipleHit.Length;

        GetComponent <AttackTriggerC>().skill[id].multipleHit = new SkillAdditionHit[mh];
        for (int m = 0; m < mh; m++)
        {
            GetComponent <AttackTriggerC>().skill[id].multipleHit[m] = new SkillAdditionHit();

            GetComponent <AttackTriggerC>().skill[id].multipleHit[m].skillPrefab        = dataSkill.skill[skillListSlot[sk]].multipleHit[m].skillPrefab;
            GetComponent <AttackTriggerC>().skill[id].multipleHit[m].skillAnimation     = dataSkill.skill[skillListSlot[sk]].multipleHit[m].skillAnimation;
            GetComponent <AttackTriggerC>().skill[id].multipleHit[m].mecanimTriggerName = dataSkill.skill[skillListSlot[sk]].multipleHit[m].mecanimTriggerName;

            GetComponent <AttackTriggerC>().skill[id].multipleHit[m].castTime   = dataSkill.skill[skillListSlot[sk]].multipleHit[m].castTime;
            GetComponent <AttackTriggerC>().skill[id].multipleHit[m].skillDelay = dataSkill.skill[skillListSlot[sk]].multipleHit[m].skillDelay;

            GetComponent <AttackTriggerC>().skill[id].multipleHit[m].soundEffect = dataSkill.skill[skillListSlot[sk]].multipleHit[m].soundEffect;
        }

        skill[id] = skillListSlot[sk];
        CheckSameSkill(skill[id], id);
        print(sk);
    }
Example #7
0
    public void AssignAllSkill()
    {
        int        n         = 0;
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        while (n < skill.Length)
        {
            GetComponent <AttackTriggerC>().skill[n].manaCost           = dataSkill.skill[skill[n]].manaCost;
            GetComponent <AttackTriggerC>().skill[n].skillPrefab        = dataSkill.skill[skill[n]].skillPrefab;
            GetComponent <AttackTriggerC>().skill[n].skillAnimation     = dataSkill.skill[skill[n]].skillAnimation;
            GetComponent <AttackTriggerC>().skill[n].mecanimTriggerName = dataSkill.skill[skill[n]].mecanimTriggerName;

            GetComponent <AttackTriggerC>().skill[n].icon       = dataSkill.skill[skill[n]].icon;
            GetComponent <AttackTriggerC>().skill[n].iconSprite = dataSkill.skill[skill[n]].iconSprite;
            GetComponent <AttackTriggerC>().skill[n].sendMsg    = dataSkill.skill[skill[n]].sendMsg;
            GetComponent <AttackTriggerC>().skill[n].castEffect = dataSkill.skill[skill[n]].castEffect;

            GetComponent <AttackTriggerC>().skill[n].castTime    = dataSkill.skill[skill[n]].castTime;
            GetComponent <AttackTriggerC>().skill[n].skillDelay  = dataSkill.skill[skill[n]].skillDelay;
            GetComponent <AttackTriggerC>().skill[n].whileAttack = dataSkill.skill[skill[n]].whileAttack;
            GetComponent <AttackTriggerC>().skill[n].coolDown    = dataSkill.skill[skill[n]].coolDown;
            GetComponent <AttackTriggerC>().skill[n].skillSpawn  = dataSkill.skill[skill[n]].skillSpawn;

            GetComponent <AttackTriggerC>().skill[n].requireWeapon     = dataSkill.skill[skill[n]].requireWeapon;
            GetComponent <AttackTriggerC>().skill[n].requireWeaponType = dataSkill.skill[skill[n]].requireWeaponType;

            GetComponent <AttackTriggerC>().skill[n].soundEffect = dataSkill.skill[skill[n]].soundEffect;

            int mh = dataSkill.skill[skill[n]].multipleHit.Length;
            GetComponent <AttackTriggerC>().skill[n].multipleHit = new SkillAdditionHit[mh];
            for (int m = 0; m < mh; m++)
            {
                GetComponent <AttackTriggerC>().skill[n].multipleHit[m] = new SkillAdditionHit();

                GetComponent <AttackTriggerC>().skill[n].multipleHit[m].skillPrefab        = dataSkill.skill[skill[n]].multipleHit[m].skillPrefab;
                GetComponent <AttackTriggerC>().skill[n].multipleHit[m].skillAnimation     = dataSkill.skill[skill[n]].multipleHit[m].skillAnimation;
                GetComponent <AttackTriggerC>().skill[n].multipleHit[m].mecanimTriggerName = dataSkill.skill[skill[n]].multipleHit[m].mecanimTriggerName;

                GetComponent <AttackTriggerC>().skill[n].multipleHit[m].castTime   = dataSkill.skill[skill[n]].multipleHit[m].castTime;
                GetComponent <AttackTriggerC>().skill[n].multipleHit[m].skillDelay = dataSkill.skill[skill[n]].multipleHit[m].skillDelay;

                GetComponent <AttackTriggerC>().skill[n].multipleHit[m].soundEffect = dataSkill.skill[skill[n]].multipleHit[m].soundEffect;
            }
            n++;
        }
        if (GetComponent <UiMasterC>())
        {
            GetComponent <UiMasterC>().SetSkillShortCutIcons();
        }
    }
Example #8
0
    public void  AssignSkill(int id, int sk)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        player.GetComponent <AttackTriggerC>().manaCost[id]       = dataSkill.skill[skillListSlot[sk]].manaCost;
        player.GetComponent <AttackTriggerC>().skillPrefab[id]    = dataSkill.skill[skillListSlot[sk]].skillPrefab;
        player.GetComponent <AttackTriggerC>().skillAnimation[id] = dataSkill.skill[skillListSlot[sk]].skillAnimation;

        player.GetComponent <AttackTriggerC>().mainModel.GetComponent <Animation>()[dataSkill.skill[skillListSlot[sk]].skillAnimation.name].layer = 16;

        player.GetComponent <AttackTriggerC>().skillIcon[id] = dataSkill.skill[skillListSlot[sk]].icon;
        skill[id] = skillListSlot[sk];
        print(sk);
    }
Example #9
0
    void CheckSameSkill(int id, int slot)
    {
        //print (id + " + " + slot);
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();
        int        n         = 0;

        while (n < skill.Length)
        {
            if (skill[n] == id && n != slot)
            {
                GetComponent <AttackTriggerC>().skill[n].manaCost           = 0;
                GetComponent <AttackTriggerC>().skill[n].skillPrefab        = null;
                GetComponent <AttackTriggerC>().skill[n].skillAnimation     = dataSkill.skill[skill[0]].skillAnimation;
                GetComponent <AttackTriggerC>().skill[n].mecanimTriggerName = dataSkill.skill[skill[0]].mecanimTriggerName;

                GetComponent <AttackTriggerC>().skill[n].icon       = null;
                GetComponent <AttackTriggerC>().skill[n].iconSprite = dataSkill.skill[0].iconSprite;
                GetComponent <AttackTriggerC>().skill[n].sendMsg    = "";
                GetComponent <AttackTriggerC>().skill[n].castEffect = null;

                GetComponent <AttackTriggerC>().skill[n].castTime    = 0;
                GetComponent <AttackTriggerC>().skill[n].skillDelay  = 0;
                GetComponent <AttackTriggerC>().skill[n].whileAttack = dataSkill.skill[skill[0]].whileAttack;
                GetComponent <AttackTriggerC>().skill[n].coolDown    = 0;
                GetComponent <AttackTriggerC>().skill[n].skillSpawn  = dataSkill.skill[skill[0]].skillSpawn;

                GetComponent <AttackTriggerC>().skill[n].requireWeapon     = false;
                GetComponent <AttackTriggerC>().skill[n].requireWeaponType = 0;

                GetComponent <AttackTriggerC>().skill[n].soundEffect = null;

                if (GetComponent <AttackTriggerC>().skillCoolDown[n] > 0)
                {
                    GetComponent <AttackTriggerC>().skillCoolDown[slot] = GetComponent <AttackTriggerC>().skillCoolDown[n];
                }
                GetComponent <AttackTriggerC>().skillCoolDown[n] = 0;
                skill[n] = 0;
            }
            n++;
        }
        if (GetComponent <UiMasterC>())
        {
            GetComponent <UiMasterC>().SetSkillShortCutIcons();
        }
    }
Example #10
0
    // Token: 0x0600045B RID: 1115 RVA: 0x00020AD4 File Offset: 0x0001EED4
    public void AssignAllSkill()
    {
        if (!this.player)
        {
            this.player = base.gameObject;
        }
        int        i         = 0;
        SkillDataC component = this.database.GetComponent <SkillDataC>();

        while (i <= 2)
        {
            this.player.GetComponent <AttackTriggerC>().manaCost[i]       = component.skill[this.skill[i]].manaCost;
            this.player.GetComponent <AttackTriggerC>().skillPrefab[i]    = component.skill[this.skill[i]].skillPrefab;
            this.player.GetComponent <AttackTriggerC>().skillAnimation[i] = component.skill[this.skill[i]].skillAnimation;
            this.player.GetComponent <AttackTriggerC>().skillIcon[i]      = component.skill[this.skill[i]].icon;
            i++;
        }
    }
Example #11
0
    public void AssignSkillByID(int slot, int skillId)
    {
        //Use With Canvas UI
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        GetComponent <AttackTriggerC>().skill[slot].manaCost       = dataSkill.skill[skillId].manaCost;
        GetComponent <AttackTriggerC>().skill[slot].skillPrefab    = dataSkill.skill[skillId].skillPrefab;
        GetComponent <AttackTriggerC>().skill[slot].skillAnimation = dataSkill.skill[skillId].skillAnimation;

        GetComponent <AttackTriggerC>().skill[slot].icon       = dataSkill.skill[skillId].icon;
        GetComponent <AttackTriggerC>().skill[slot].sendMsg    = dataSkill.skill[skillId].sendMsg;
        GetComponent <AttackTriggerC>().skill[slot].castEffect = dataSkill.skill[skillId].castEffect;

        GetComponent <AttackTriggerC>().skill[slot].castTime    = dataSkill.skill[skillId].castTime;
        GetComponent <AttackTriggerC>().skill[slot].skillDelay  = dataSkill.skill[skillId].skillDelay;
        GetComponent <AttackTriggerC>().skill[slot].whileAttack = dataSkill.skill[skillId].whileAttack;

        skill[slot] = skillId;
    }
Example #12
0
    //-----------------------

    public void AssignSkill(int id, int sk)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        GetComponent <AttackTriggerC>().skill[id].manaCost       = dataSkill.skill[skillListSlot[sk]].manaCost;
        GetComponent <AttackTriggerC>().skill[id].skillPrefab    = dataSkill.skill[skillListSlot[sk]].skillPrefab;
        GetComponent <AttackTriggerC>().skill[id].skillAnimation = dataSkill.skill[skillListSlot[sk]].skillAnimation;

        GetComponent <AttackTriggerC>().skill[id].icon       = dataSkill.skill[skillListSlot[sk]].icon;
        GetComponent <AttackTriggerC>().skill[id].sendMsg    = dataSkill.skill[skillListSlot[sk]].sendMsg;
        GetComponent <AttackTriggerC>().skill[id].castEffect = dataSkill.skill[skillListSlot[sk]].castEffect;

        GetComponent <AttackTriggerC>().skill[id].castTime    = dataSkill.skill[skillListSlot[sk]].castTime;
        GetComponent <AttackTriggerC>().skill[id].skillDelay  = dataSkill.skill[skillListSlot[sk]].skillDelay;
        GetComponent <AttackTriggerC>().skill[id].whileAttack = dataSkill.skill[skillListSlot[sk]].whileAttack;

        skill[id] = skillListSlot[sk];
        print(sk);
    }
Example #13
0
    public void AssignSkill(int id, int sk)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        player.GetComponent <AttackTriggerC>().skill[id].manaCost       = dataSkill.skill[skillListSlot[sk]].manaCost;
        player.GetComponent <AttackTriggerC>().skill[id].skillPrefab    = dataSkill.skill[skillListSlot[sk]].skillPrefab;
        player.GetComponent <AttackTriggerC>().skill[id].skillAnimation = dataSkill.skill[skillListSlot[sk]].skillAnimation;
        player.GetComponent <AttackTriggerC>().skill[id].icon           = dataSkill.skill[skillListSlot[sk]].icon;
        skill[id] = skillListSlot[sk];
        //-------Assign Icon to Skill Button-----------
        if (skillButton[id])
        {
            skillButton[id].GetComponent <GUITexture>().texture           = dataSkill.skill[skillListSlot[sk]].icon;
            skillButton[id].GetComponent <SkillButtonC>().originalTexture = dataSkill.skill[skillListSlot[sk]].icon;
            //if(dataSkill.skill[skillListSlot[sk]].iconDown){
            skillButton[id].GetComponent <SkillButtonC>().downTexture = dataSkill.skill[skillListSlot[sk]].iconDown;
            //}
        }
        print(sk);
    }
Example #14
0
    public void  AssignAllSkill()
    {
        if (!player)
        {
            player = this.gameObject;
        }
        int        n         = 0;
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        while (n <= 2)
        {
            player.GetComponent <AttackTriggerC>().manaCost[n]       = dataSkill.skill[skill[n]].manaCost;
            player.GetComponent <AttackTriggerC>().skillPrefab[n]    = dataSkill.skill[skill[n]].skillPrefab;
            player.GetComponent <AttackTriggerC>().skillAnimation[n] = dataSkill.skill[skill[n]].skillAnimation;

            player.GetComponent <AttackTriggerC>().mainModel.GetComponent <Animation>()[dataSkill.skill[skill[n]].skillAnimation.name].layer = 16;

            player.GetComponent <AttackTriggerC>().skillIcon[n] = dataSkill.skill[skill[n]].icon;
            n++;
        }
    }
Example #15
0
    public void AssignAllSkill()
    {
        int        n         = 0;
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        while (n < skill.Length)
        {
            GetComponent <AttackTriggerC>().skill[n].manaCost       = dataSkill.skill[skill[n]].manaCost;
            GetComponent <AttackTriggerC>().skill[n].skillPrefab    = dataSkill.skill[skill[n]].skillPrefab;
            GetComponent <AttackTriggerC>().skill[n].skillAnimation = dataSkill.skill[skill[n]].skillAnimation;

            GetComponent <AttackTriggerC>().skill[n].icon       = dataSkill.skill[skill[n]].icon;
            GetComponent <AttackTriggerC>().skill[n].sendMsg    = dataSkill.skill[skill[n]].sendMsg;
            GetComponent <AttackTriggerC>().skill[n].castEffect = dataSkill.skill[skill[n]].castEffect;

            GetComponent <AttackTriggerC>().skill[n].castTime    = dataSkill.skill[skill[n]].castTime;
            GetComponent <AttackTriggerC>().skill[n].skillDelay  = dataSkill.skill[skill[n]].skillDelay;
            GetComponent <AttackTriggerC>().skill[n].whileAttack = dataSkill.skill[skill[n]].whileAttack;
            n++;
        }
    }
Example #16
0
    public void SkillShortcut(int windowID)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        windowRect.width  = 490;
        windowRect.height = 275;
        //Close Window Button
        if (GUI.Button(new Rect(400, 8, 65, 65), "X"))
        {
            OnOffMenu();
        }

        //Skill Shortcut
        if (GUI.Button(new Rect(40, 85, 120, 120), dataSkill.skill[skill[0]].icon))
        {
            skillSelect   = 0;
            skillListPage = true;
            shortcutPage  = false;
        }
        GUI.Label(new Rect(90, 210, 20, 20), "1");
        if (GUI.Button(new Rect(190, 85, 120, 120), dataSkill.skill[skill[1]].icon))
        {
            skillSelect   = 1;
            skillListPage = true;
            shortcutPage  = false;
        }
        GUI.Label(new Rect(245, 210, 20, 20), "2");
        if (GUI.Button(new Rect(340, 85, 120, 120), dataSkill.skill[skill[2]].icon))
        {
            skillSelect   = 2;
            skillListPage = true;
            shortcutPage  = false;
        }
        GUI.Label(new Rect(400, 210, 20, 20), "3");

        GUI.DragWindow(new Rect(0, 0, 10000, 10000));
    }
Example #17
0
    void SkillShortcut(int windowID)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        windowRect.width  = 360;
        windowRect.height = 185;
        //Close Window Button
        if (GUI.Button(new Rect(310, 2, 30, 30), "X"))
        {
            OnOffMenu();
        }

        //Skill Shortcut
        if (GUI.Button(new Rect(30, 45, 80, 80), dataSkill.skill[skill[0]].icon))
        {
            skillSelect   = 0;
            skillListPage = true;
            shortcutPage  = false;
        }
        GUI.Label(new Rect(70, 145, 20, 20), "1");
        if (GUI.Button(new Rect(130, 45, 80, 80), dataSkill.skill[skill[1]].icon))
        {
            skillSelect   = 1;
            skillListPage = true;
            shortcutPage  = false;
        }
        GUI.Label(new Rect(170, 145, 20, 20), "2");
        if (GUI.Button(new Rect(230, 45, 80, 80), dataSkill.skill[skill[2]].icon))
        {
            skillSelect   = 2;
            skillListPage = true;
            shortcutPage  = false;
        }
        GUI.Label(new Rect(270, 145, 20, 20), "3");

        GUI.DragWindow(new Rect(0, 0, 10000, 10000));
    }
Example #18
0
    void AllSkill(int windowID)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        windowRect.width  = 300;
        windowRect.height = 555;
        //Close Window Button
        if (GUI.Button(new Rect(260, 2, 30, 30), "X"))
        {
            OnOffMenu();
        }
        if (GUI.Button(new Rect(30, 60, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[0 + page]].icon, dataSkill.skill[skillListSlot[0 + page]].description)))
        {
            AssignSkill(skillSelect, 0 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 75, 140, 40), dataSkill.skill[skillListSlot[0 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 75, 140, 40), "MP : " + dataSkill.skill[skillListSlot[0 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 120, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[1 + page]].icon, dataSkill.skill[skillListSlot[1 + page]].description)))
        {
            AssignSkill(skillSelect, 1 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 135, 140, 40), dataSkill.skill[skillListSlot[1 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 135, 140, 40), "MP : " + dataSkill.skill[skillListSlot[1 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 180, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[2 + page]].icon, dataSkill.skill[skillListSlot[2 + page]].description)))
        {
            AssignSkill(skillSelect, 2 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 195, 140, 40), dataSkill.skill[skillListSlot[2 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 195, 140, 40), "MP : " + dataSkill.skill[skillListSlot[2 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 240, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[3 + page]].icon, dataSkill.skill[skillListSlot[3 + page]].description)))
        {
            AssignSkill(skillSelect, 3 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 255, 140, 40), dataSkill.skill[skillListSlot[3 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 255, 140, 40), "MP : " + dataSkill.skill[skillListSlot[3 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 300, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[4 + page]].icon, dataSkill.skill[skillListSlot[4 + page]].description)))
        {
            AssignSkill(skillSelect, 4 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 315, 140, 40), dataSkill.skill[skillListSlot[4 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 315, 140, 40), "MP : " + dataSkill.skill[skillListSlot[4 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 360, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[5 + page]].icon, dataSkill.skill[skillListSlot[5 + page]].description)))
        {
            AssignSkill(skillSelect, 5 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 375, 140, 40), dataSkill.skill[skillListSlot[5 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 375, 140, 40), "MP : " + dataSkill.skill[skillListSlot[5 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 420, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[6 + page]].icon, dataSkill.skill[skillListSlot[6 + page]].description)))
        {
            AssignSkill(skillSelect, 6 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 435, 140, 40), dataSkill.skill[skillListSlot[6 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 435, 140, 40), "MP : " + dataSkill.skill[skillListSlot[6 + page]].manaCost, textStyle);  //Show Skill's MP Cost
        //-----------------------------

        if (GUI.Button(new Rect(30, 480, 50, 50), new GUIContent(dataSkill.skill[skillListSlot[7 + page]].icon, dataSkill.skill[skillListSlot[7 + page]].description)))
        {
            AssignSkill(skillSelect, 7 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(95, 495, 140, 40), dataSkill.skill[skillListSlot[7 + page]].skillName, textStyle);            //Show Skill's Name
        GUI.Label(new Rect(220, 495, 140, 40), "MP : " + dataSkill.skill[skillListSlot[7 + page]].manaCost, textStyle);  //Show Skill's MP Cost

        if (GUI.Button(new Rect(220, 514, 25, 30), "1"))
        {
            page = 0;
        }
        if (GUI.Button(new Rect(250, 514, 25, 30), "2"))
        {
            page = pageMultiply;
        }

        GUI.Box(new Rect(20, 20, 240, 26), GUI.tooltip);
        GUI.DragWindow(new Rect(0, 0, 10000, 10000));
    }
Example #19
0
    public void AllSkill(int windowID)
    {
        SkillDataC dataSkill = database.GetComponent <SkillDataC>();

        windowRect.width  = 400;
        windowRect.height = 575;
        //Close Window Button
        if (GUI.Button(new Rect(310, 8, 70, 70), "X"))
        {
            OnOffMenu();
        }
        if (GUI.Button(new Rect(20, 60, 75, 75), dataSkill.skill[skillListSlot[0 + page]].icon))
        {
            AssignSkill(skillSelect, 0 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(110, 70, 140, 40), dataSkill.skill[skillListSlot[0 + page]].skillName, skillNameText);                 //Show Skill's Name
        GUI.Label(new Rect(110, 95, 140, 40), dataSkill.skill[skillListSlot[0 + page]].description, skillDescriptionText);        //Show Skill's Description
        GUI.Label(new Rect(310, 90, 140, 40), "MP : " + dataSkill.skill[skillListSlot[0 + page]].manaCost, skillDescriptionText); //Show Skill's MP Cost
        //-----------------------------
        if (GUI.Button(new Rect(20, 150, 75, 75), dataSkill.skill[skillListSlot[1 + page]].icon))
        {
            AssignSkill(skillSelect, 1 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(110, 160, 140, 40), dataSkill.skill[skillListSlot[1 + page]].skillName, skillNameText);                 //Show Skill's Name
        GUI.Label(new Rect(110, 185, 140, 40), dataSkill.skill[skillListSlot[1 + page]].description, skillDescriptionText);        //Show Skill's Description
        GUI.Label(new Rect(310, 180, 140, 40), "MP : " + dataSkill.skill[skillListSlot[1 + page]].manaCost, skillDescriptionText); //Show Skill's MP Cost
        //-----------------------------
        if (GUI.Button(new Rect(20, 240, 75, 75), dataSkill.skill[skillListSlot[2 + page]].icon))
        {
            AssignSkill(skillSelect, 2 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(110, 250, 140, 40), dataSkill.skill[skillListSlot[2 + page]].skillName, skillNameText);                 //Show Skill's Name
        GUI.Label(new Rect(110, 275, 140, 40), dataSkill.skill[skillListSlot[2 + page]].description, skillDescriptionText);        //Show Skill's Description
        GUI.Label(new Rect(310, 270, 140, 40), "MP : " + dataSkill.skill[skillListSlot[2 + page]].manaCost, skillDescriptionText); //Show Skill's MP Cost
        //-----------------------------
        if (GUI.Button(new Rect(20, 330, 75, 75), dataSkill.skill[skillListSlot[3 + page]].icon))
        {
            AssignSkill(skillSelect, 3 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(110, 340, 140, 40), dataSkill.skill[skillListSlot[3 + page]].skillName, skillNameText);                 //Show Skill's Name
        GUI.Label(new Rect(110, 365, 140, 40), dataSkill.skill[skillListSlot[3 + page]].description, skillDescriptionText);        //Show Skill's Description
        GUI.Label(new Rect(310, 360, 140, 40), "MP : " + dataSkill.skill[skillListSlot[3 + page]].manaCost, skillDescriptionText); //Show Skill's MP Cost
        //-----------------------------
        if (GUI.Button(new Rect(20, 420, 75, 75), dataSkill.skill[skillListSlot[4 + page]].icon))
        {
            AssignSkill(skillSelect, 4 + page);
            shortcutPage  = true;
            skillListPage = false;
        }
        GUI.Label(new Rect(110, 430, 140, 40), dataSkill.skill[skillListSlot[4 + page]].skillName, skillNameText);                 //Show Skill's Name
        GUI.Label(new Rect(110, 455, 140, 40), dataSkill.skill[skillListSlot[4 + page]].description, skillDescriptionText);        //Show Skill's Description
        GUI.Label(new Rect(310, 450, 140, 40), "MP : " + dataSkill.skill[skillListSlot[4 + page]].manaCost, skillDescriptionText); //Show Skill's MP Cost
        //-----------------------------


        if (GUI.Button(new Rect(150, 515, 50, 52), "1"))
        {
            page = 0;
        }
        if (GUI.Button(new Rect(220, 515, 50, 52), "2"))
        {
            page = pageMultiply;
        }
        if (GUI.Button(new Rect(290, 515, 50, 52), "3"))
        {
            page = pageMultiply * 2;
        }

        GUI.DragWindow(new Rect(0, 0, 10000, 10000));
    }
Example #20
0
    void  OnGUI()
    {
        SkillDataC dataItem = database.GetComponent <SkillDataC>();

        if (menu && shortcutPage)
        {
            GUI.Box(new Rect(180, 160, 360, 185), "Skill");
            //Close Window Button
            if (GUI.Button(new Rect(490, 162, 30, 30), "X"))
            {
                OnOffMenu();
            }

            //Skill Shortcut
            if (GUI.Button(new Rect(210, 205, 80, 80), dataItem.skill[skill[0]].icon))
            {
                skillSelect   = 0;
                skillListPage = true;
                shortcutPage  = false;
            }
            GUI.Label(new Rect(250, 305, 20, 20), "1");
            if (GUI.Button(new Rect(310, 205, 80, 80), dataItem.skill[skill[1]].icon))
            {
                skillSelect   = 1;
                skillListPage = true;
                shortcutPage  = false;
            }
            GUI.Label(new Rect(350, 305, 20, 20), "2");
            if (GUI.Button(new Rect(410, 205, 80, 80), dataItem.skill[skill[2]].icon))
            {
                skillSelect   = 2;
                skillListPage = true;
                shortcutPage  = false;
            }
            GUI.Label(new Rect(450, 305, 20, 20), "3");
        }
        //---------------Skill List----------------------------
        if (menu && skillListPage)
        {
            GUI.Box(new Rect(160, 160, 380, 385), "Skill");
            //Close Window Button
            if (GUI.Button(new Rect(500, 162, 30, 30), "X"))
            {
                OnOffMenu();
            }
            if (GUI.Button(new Rect(210, 215, 80, 80), dataItem.skill[skillListSlot[0]].icon))
            {
                AssignSkill(skillSelect, 0);
                shortcutPage  = true;
                skillListPage = false;
            }
            if (GUI.Button(new Rect(310, 215, 80, 80), dataItem.skill[skillListSlot[1]].icon))
            {
                AssignSkill(skillSelect, 1);
                shortcutPage  = true;
                skillListPage = false;
            }
            if (GUI.Button(new Rect(410, 215, 80, 80), dataItem.skill[skillListSlot[2]].icon))
            {
                AssignSkill(skillSelect, 2);
                shortcutPage  = true;
                skillListPage = false;
            }
            //-----------------
            if (GUI.Button(new Rect(210, 315, 80, 80), dataItem.skill[skillListSlot[3]].icon))
            {
                AssignSkill(skillSelect, 3);
                shortcutPage  = true;
                skillListPage = false;
            }
            if (GUI.Button(new Rect(310, 315, 80, 80), dataItem.skill[skillListSlot[4]].icon))
            {
                AssignSkill(skillSelect, 4);
                shortcutPage  = true;
                skillListPage = false;
            }
            if (GUI.Button(new Rect(410, 315, 80, 80), dataItem.skill[skillListSlot[5]].icon))
            {
                AssignSkill(skillSelect, 5);
                shortcutPage  = true;
                skillListPage = false;
            }
            //-----------------
            if (GUI.Button(new Rect(210, 415, 80, 80), dataItem.skill[skillListSlot[6]].icon))
            {
                AssignSkill(skillSelect, 6);
                shortcutPage  = true;
                skillListPage = false;
            }
            if (GUI.Button(new Rect(310, 415, 80, 80), dataItem.skill[skillListSlot[7]].icon))
            {
                AssignSkill(skillSelect, 7);
                shortcutPage  = true;
                skillListPage = false;
            }
            if (GUI.Button(new Rect(410, 415, 80, 80), dataItem.skill[skillListSlot[8]].icon))
            {
                AssignSkill(skillSelect, 8);
                shortcutPage  = true;
                skillListPage = false;
            }
        }
    }
Example #21
0
    // Token: 0x06000459 RID: 1113 RVA: 0x0002009C File Offset: 0x0001E49C
    private void AllSkill(int windowID)
    {
        SkillDataC component = this.database.GetComponent <SkillDataC>();

        this.windowRect.width  = 300f;
        this.windowRect.height = 555f;
        if (GUI.Button(new Rect(260f, 2f, 30f, 30f), "X"))
        {
            this.OnOffMenu();
        }
        if (GUI.Button(new Rect(30f, 60f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[this.page]].icon, component.skill[this.skillListSlot[this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 75f, 140f, 40f), component.skill[this.skillListSlot[this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 75f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 120f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[1 + this.page]].icon, component.skill[this.skillListSlot[1 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 1 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 135f, 140f, 40f), component.skill[this.skillListSlot[1 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 135f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[1 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 180f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[2 + this.page]].icon, component.skill[this.skillListSlot[2 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 2 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 195f, 140f, 40f), component.skill[this.skillListSlot[2 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 195f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[2 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 240f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[3 + this.page]].icon, component.skill[this.skillListSlot[3 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 3 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 255f, 140f, 40f), component.skill[this.skillListSlot[3 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 255f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[3 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 300f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[4 + this.page]].icon, component.skill[this.skillListSlot[4 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 4 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 315f, 140f, 40f), component.skill[this.skillListSlot[4 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 315f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[4 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 360f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[5 + this.page]].icon, component.skill[this.skillListSlot[5 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 5 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 375f, 140f, 40f), component.skill[this.skillListSlot[5 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 375f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[5 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 420f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[6 + this.page]].icon, component.skill[this.skillListSlot[6 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 6 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 435f, 140f, 40f), component.skill[this.skillListSlot[6 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 435f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[6 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(30f, 480f, 50f, 50f), new GUIContent(component.skill[this.skillListSlot[7 + this.page]].icon, component.skill[this.skillListSlot[7 + this.page]].description)))
        {
            this.AssignSkill(this.skillSelect, 7 + this.page);
            this.shortcutPage  = true;
            this.skillListPage = false;
        }
        GUI.Label(new Rect(95f, 495f, 140f, 40f), component.skill[this.skillListSlot[7 + this.page]].skillName, this.textStyle);
        GUI.Label(new Rect(220f, 495f, 140f, 40f), "MP : " + component.skill[this.skillListSlot[7 + this.page]].manaCost, this.textStyle);
        if (GUI.Button(new Rect(220f, 514f, 25f, 30f), "1"))
        {
            this.page = 0;
        }
        if (GUI.Button(new Rect(250f, 514f, 25f, 30f), "2"))
        {
            this.page = this.pageMultiply;
        }
        GUI.Box(new Rect(20f, 20f, 240f, 26f), GUI.tooltip);
        GUI.DragWindow(new Rect(0f, 0f, 10000f, 10000f));
    }