dRaC

# - COMMANDS
command_Race:
    type: command
    name: race
    usage: /race
    script:
        - define arg1:<context.args.[1]||null>
        - define arg2:<context.args.[2]||null>
        - define arg3:<context.args.[3]||!>
        - if <yaml[race_config].list_keys[].contains[<[arg1].to_titlecase>]>:
            - narrate " "
            - narrate "<&8>-------------------"
            - narrate "<&a><&l>    - <[arg1].to_titlecase> -"
            - narrate "<&8>-------------------"
            - foreach <yaml[race_config].list_keys[<[arg1].to_titlecase>.buffs]> as:buff:
                - define val:<yaml[race_config].read[<[arg1].to_titlecase>.buffs.<[buff]>]>
                - choose <[buff]>:
                    - case Health:
                        - narrate "<&e>Increases health by up to <[val].*[40]>"
                    - case Mana:
                        - narrate "<&e>Increases mana by up to <[val].*[40]>"
                    - case Armor:
                        - narrate "<&e>Increases armor by up to <[val].*[40]>"
                    - case Damage:
                        - narrate "<&e>Increases damage by up to <[val].*[40]>%"
                    - case MagicDamage:
                        - narrate "<&e>Increases magic damage by up to <[val].*[40]>%"
                    - case SwordDamage:
                        - narrate "<&e>Increases sword damage by up to <[val].*[40]>%"
                    - case AxeDamage:
                        - narrate "<&e>Increases axe damage by up to <[val].*[40]>%"
                    - case BowDamage:
                        - narrate "<&e>Increases bow damage by up to <[val].*[40]>%"
                    - case LongRangeDamage:
                        - narrate "<&e>Increases long range damage by up to <[val].*[40]>%"
                    - case Critical:
                        - narrate "<&e>Increases critical chance by up to <[val].*[40]>%"
                    - case Poison:
                        - narrate "<&e>Increases chance to poison by up to <[val].*[40]>%"
                    - case Bleed:
                        - narrate "<&e>Increases chance to bleed by up to <[val].*[40]>%"
                    - case Backstab:
                        - narrate "<&e>Increases backstab damage by up to <[val].*[40]>%"
                    - case Speed:
                        - narrate "<&e>Increases speed by up to <[val].*[40]>"
                    - case Dodge:
                        - narrate "<&e>Increases dodge by up to <[val].*[40]>%"
                    - case Parry:
                        - narrate "<&e>Increases parry by up to <[val].*[40]>%"
                    - case Lifesteal
                        - narrate "<&e>Increases lifesteal by up to <[val].*[40]>%"
                    - case Luck
                        - narrate "<&e>Increases luck by up to <[val].*[40]>"
                    - case Regen:
                        - narrate "<&e>Increases regen by up to <[val].*[40]>%"
                    - case HpRegen:
                        - narrate "<&e>Increases health regen by up to <[val].*[40]>%"
                    - case ManaRegen:
                        - narrate "<&e>Increases mana regen by up to <[val].*[40]>%"
                    - case RegenAura:
                        - narrate "<&e>Increases regen of allies by up to <[val].*[40]>%"
                    - case HpRegenAura:
                        - narrate "<&e>Increases health regen of allies by up to <[val].*[40]>%"
                    - case ManaRegenAura:
                        - narrate "<&e>Increases mana regen of allies by up to <[val].*[40]>%"
                    - case Hover:
                        - narrate "<&e>Allows you to hover"
                    - case UnderwaterBreathing:
                        - narrate "<&e>Allows you to breathe underwater"
            - narrate "<&a>----Sub-Races----"
            - foreach <yaml[race_config].list_keys[<[arg1].to_titlecase>.subraces]> as:subrace:
                - narrate "<&6><[subrace]>"
            - narrate "<&8>-------------------"
            - narrate "<&e>Type /race (subracename) to view more info on a subrace"
            - stop
        - else:
            - foreach <yaml[race_config].list_keys[]> as:race:
                - if <yaml[race_config].list_keys[<[race]>.subraces].contains[<[arg1].to_titlecase>]||false>:
                    - narrate " "
                    - narrate "<&8>-------------------"
                    - narrate "<&a><&l>    - <[arg1].to_titlecase> -"
                    - narrate "<&8>-------------------"
                    - foreach <yaml[race_config].list_keys[<[race]>.subraces.<[arg1].to_titlecase>.buffs]> as:buff:
                        - define val:<yaml[race_config].read[<[race]>.subraces.<[arg1].to_titlecase>.buffs.<[buff]>]>
                        - choose <[buff]>:
                            - case Health:
                                - narrate "<&e>Increases health by up to <[val].*[40]>"
                            - case Mana:
                                - narrate "<&e>Increases mana by up to <[val].*[40]>"
                            - case Armor:
                                - narrate "<&e>Increases armor by up to <[val].*[40]>"
                            - case Damage:
                                - narrate "<&e>Increases damage by up to <[val].*[40]>%"
                            - case MagicDamage:
                                - narrate "<&e>Increases magic damage by up to <[val].*[40]>%"
                            - case SwordDamage:
                                - narrate "<&e>Increases sword damage by up to <[val].*[40]>%"
                            - case AxeDamage:
                                - narrate "<&e>Increases axe damage by up to <[val].*[40]>%"
                            - case BowDamage:
                                - narrate "<&e>Increases bow damage by up to <[val].*[40]>%"
                            - case LongRangeDamage:
                                - narrate "<&e>Increases long range damage by up to <[val].*[40]>%"
                            - case Critical:
                                - narrate "<&e>Increases critical chance by up to <[val].*[40]>%"
                            - case Poison:
                                - narrate "<&e>Increases chance to poison by up to <[val].*[40]>%"
                            - case Bleed:
                                - narrate "<&e>Increases chance to bleed by up to <[val].*[40]>%"
                            - case Backstab:
                                - narrate "<&e>Increases backstab damage by up to <[val].*[40]>%"
                            - case Speed:
                                - narrate "<&e>Increases speed by up to <[val].*[40]>"
                            - case Dodge:
                                - narrate "<&e>Increases dodge by up to <[val].*[40]>%"
                            - case Parry:
                                - narrate "<&e>Increases parry by up to <[val].*[40]>%"
                            - case Lifesteal
                                - narrate "<&e>Increases lifesteal by up to <[val].*[40]>%"
                            - case Luck
                                - narrate "<&e>Increases luck by up to <[val].*[40]>"
                            - case Regen:
                                - narrate "<&e>Increases regen by up to <[val].*[40]>%"
                            - case HpRegen:
                                - narrate "<&e>Increases health regen by up to <[val].*[40]>%"
                            - case ManaRegen:
                                - narrate "<&e>Increases mana regen by up to <[val].*[40]>%"
                            - case RegenAura:
                                - narrate "<&e>Increases regen of allies by up to <[val].*[40]>%"
                            - case HpRegenAura:
                                - narrate "<&e>Increases health regen of allies by up to <[val].*[40]>%"
                            - case ManaRegenAura:
                                - narrate "<&e>Increases mana regen of allies by up to <[val].*[40]>%"
                            - case Hover:
                                - narrate "<&e>Allows you to hover"
                            - case UnderwaterBreathing:
                                - narrate "<&e>Allows you to breathe underwater"
                    - narrate "<&8>-------------------"
                    - stop
        - choose <[arg1]>:
            - case null:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>- Race Commands -"
                - narrate "<&8>-------------------"
                - narrate "<&e>/race<&8>- <&7>Race commands"
                - narrate "<&e>/race help<&8>- <&7>Explains races"
                - narrate "<&e>/race list <&8>- <&7>Displays a list of races"
                - narrate "<&e>/race (name) <&8>- <&7>Gives info on a race"
                - narrate "<&e>/race change (name) <&8>- <&7>Changes race"
                - narrate "<&e>/race info <&8>- <&7>Gives info on your current race"
                - narrate "<&e>/race stats <&8>- <&7>Displays stats"
                - narrate "<&e>/stats <&8>- <&7>Displays all stats"
                - narrate "<&e>/subrace <&8>- <&7>Subrace commands"
                - narrate "<&8>-------------------"
                - stop
            - case help:
                - narrate " "
                - narrate "<&e>- Races give you stats that increase as you level"
                - narrate "<&e>- Gain experience from mob kills and"
                - narrate "<&e>  played time"
                - stop
            - case list:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>   - Races -"
                - narrate "<&8>-------------------"
                - foreach <yaml[race_config].list_keys[]> as:race_name:
                    - narrate "<&6><&l><[race_name]>"
                - narrate "<&8>-------------------"
                - narrate "<&e>/race (name) to view more info on a race"
                - stop
            - case info:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Race Info -"
                - narrate "<&8>-------------------"
                - narrate "<&6><&l>Race:    <&e><yaml[<player.uuid>].read[races.race]>"
                - narrate "<&6><&l>Level:   <&e><yaml[<player.uuid>].read[races.level]>"
                - narrate "<&6><&l>Xp:      <&e><yaml[<player.uuid>].read[races.xp]>/<el@10000.*[<yaml[<player.uuid>].read[races.level]>]>"
                - narrate "<&8>---------"
                - narrate "<&6><&l>SubRace: <&e><yaml[<player.uuid>].read[races.subrace]>"
                - narrate "<&6><&l>Level:   <&e><yaml[<player.uuid>].read[races.sublevel]>"
                - narrate "<&6><&l>Xp:      <&e><yaml[<player.uuid>].read[races.subxp]>/<el@10000.*[<yaml[<player.uuid>].read[races.sublevel]>]>"
                - narrate "<&8>-------------------"
                - stop
            - case stats:
                - define race:<yaml[<player.uuid>].read[races.race]>
                - define level:<yaml[<player.uuid>].read[races.level]>
                - if <[race]> == Default:
                    - narrate "<&c>You have no race"
                    - stop
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Race Stats -"
                - narrate "<&8>-------------------"
                - foreach <yaml[race_config].list_keys[<[race]>.buffs]||null> as:stat:
                    - define val:<yaml[race_config].read[<[race]>.buffs.<[stat]>].*[<[level]>]>
                    - choose <[stat]>:
                        - case Health:
                            - narrate "<&e>Increased <&6>health<&e> - <[val]>"
                        - case Mana:
                            - narrate "<&e>Increased <&6>mana<&e> - <[val]>"
                        - case Armor:
                            - narrate "<&e>Increased <&6>armor<&e> - <[val]>"
                        - case Damage:
                            - narrate "<&e>Increased <&6>damage<&e> - <[val]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increased <&6>magic damage<&e> - <[val]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increased <&6>sword damage<&e> - <[val]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increased <&6>axe damage<&e> - <[val]>%"
                        - case BowDamage:
                            - narrate "<&e>Increased <&6>bow damage<&e> - <[val]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increased <&6>long range damage<&e> - <[val]>%"
                        - case Critical:
                            - narrate "<&e>Increased <&6>critical<&e> chance - <[val]>%"
                        - case Poison:
                            - narrate "<&e>Increased <&6>chance to poison<&e> - <[val]>%"
                        - case Bleed:
                            - narrate "<&e>Increased <&6>chance to bleed<&e> - <[val]>%"
                        - case Backstab:
                            - narrate "<&e>Increased <&6>backstab damage<&e> - <[val]>%"
                        - case Speed:
                            - narrate "<&e>Increased <&6>speed<&e> - <[val]>"
                        - case Dodge:
                            - narrate "<&e>Increased <&6>dodge<&e> - <[val]>%"
                        - case Parry:
                            - narrate "<&e>Increased <&6>parry<&e> - <[val]>%"
                        - case Lifesteal
                            - narrate "<&e>Increased <&6>lifesteal<&e> - <[val]>%"
                        - case Luck
                            - narrate "<&e>Increased <&6>luck<&e> - <[val]>"
                        - case Regen:
                            - narrate "<&e>Increased <&6>regen<&e> - <[val]>%"
                        - case HpRegen:
                            - narrate "<&e>Increased <&6>health regen<&e> - <[val]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increased <&6>mana regen<&e> - <[val]>%"
                        - case RegenAura:
                            - narrate "<&e>Increased <&6>regen<&e> of allies - <[val]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increased <&6>health regen<&e> of allies - <[val]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases <&6>mana regen<&e> of allies - <[val]>%"
                        - case Hover:
                            - narrate "<&e>Can hover"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Can breathe underwater"
                - narrate "<&8>-------------------"
                - stop
            - case change:
                - if <yaml[race_config].list_keys[].contains[<[arg2].to_titlecase>]> && <yaml[<player.uuid>].read[races.race]> != <[arg2].to_titlecase>:
                    - narrate "<&e>You change to <[arg2].to_titlecase>"
                    - if <yaml[<player.uuid>].read[races.subrace]> != Default:
                        - run instantly function_ClearSubraceBuffs
                        - define subrace:Default
                        - define last_subrace:<yaml[<player.uuid>].read[races.subrace]>
                        - define sublevel:1
                        - define last_sublevel:<yaml[<player.uuid>].read[races.sublevel]||1>
                        - define subxp:0
                        - define last_subxp:<yaml[<player.uuid>].read[races.subxp]||0>
                        - yaml id:<player.uuid> set races.subrace:<[subrace]>
                        - yaml id:<player.uuid> set races.last_subrace:<[last_subrace]>
                        - yaml id:<player.uuid> set races.sublevel:<[sublevel]>
                        - yaml id:<player.uuid> set races.last_sublevel:<[last_sublevel]>
                        - yaml id:<player.uuid> set races.subxp:<[subxp]>
                        - yaml id:<player.uuid> set races.last_subxp:<[last_subxp]>
                        - yaml id:<player.uuid> set races.<[last_subrace]>_level:<[last_sublevel]>
                        - yaml id:<player.uuid> set races.<[last_subrace]>_xp:<[last_subxp]>

                    - if <yaml[<player.uuid>].read[races.race]> != default
                        - run instantly function_ClearRaceBuffs
                    - define race:<[arg2].to_titlecase>
                    - define last_race:<yaml[<player.uuid>].read[races.race]>
                    - define level:<yaml[<player.uuid>].read[races.<[race]>_level]||1>
                    - define last_level:<yaml[<player.uuid>].read[races.level]||1>
                    - define xp:<yaml[<player.uuid>].read[races.<[race]>_xp]||0>
                    - define last_xp:<yaml[<player.uuid>].read[races.xp]||0>
                    - define race_buffs:<yaml[race_config].list_keys[<[race]>.buffs]>
                    - define last_race_buffs:<yaml[race_config].list_keys[<[last_race]>.buffs]||null>
                    - yaml id:<player.uuid> set races.race:<[race]>
                    - yaml id:<player.uuid> set races.last_race:<[last_race]>
                    - yaml id:<player.uuid> set races.level:<[level]>
                    - yaml id:<player.uuid> set races.last_level:<[last_level]>
                    - yaml id:<player.uuid> set races.xp:<[xp]>
                    - yaml id:<player.uuid> set races.last_xp:<[last_xp]>
                    - yaml id:<player.uuid> set races.<[last_race]>_level:<[last_level]>
                    - yaml id:<player.uuid> set races.<[last_race]>_xp:<[last_xp]>
                    - run instantly function_UpdateRaceBuffs
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
                    - stop

                - else if <yaml[race_config].list_keys[<yaml[<player.uuid>].read[races.race]>.subraces].contains[<[arg2].to_titlecase>]||false> && <yaml[<player.uuid>].read[races.subrace]> != <[arg2].to_titlecase>:
                    - narrate "<&e>You change to <[arg2].to_titlecase>"
                    - if <yaml[<player.uuid>].read[races.subrace]> != Default:
                        - run instantly function_ClearSubraceBuffs
                    - define race:<yaml[<player.uuid>].read[races.race]>
                    - define subrace:<[arg2].to_titlecase>
                    - define last_subrace:<yaml[<player.uuid>].read[races.subrace]>
                    - define sublevel:<yaml[<player.uuid>].read[races.<[subrace]>_level]||1>
                    - define last_sublevel:<yaml[<player.uuid>].read[races.sublevel]||1>
                    - define subxp:<yaml[<player.uuid>].read[races.<[subrace]>_xp]||0>
                    - define last_subxp:<yaml[<player.uuid>].read[races.subxp]||0>
                    - define subrace_buffs:<yaml[race_config].list_keys[<[race]>.subraces.<[subrace]>.buffs]>
                    - yaml id:<player.uuid> set races.subrace:<[subrace]>
                    - yaml id:<player.uuid> set races.last_subrace:<[last_subrace]>
                    - yaml id:<player.uuid> set races.sublevel:<[sublevel]>
                    - yaml id:<player.uuid> set races.last_sublevel:<[last_sublevel]>
                    - yaml id:<player.uuid> set races.subxp:<[subxp]>
                    - yaml id:<player.uuid> set races.last_subxp:<[last_subxp]>
                    - yaml id:<player.uuid> set races.<[last_subrace]>_level:<[last_subrace]>
                    - yaml id:<player.uuid> set races.<[last_subrace]>_xp:<[last_subxp]>
                    - run instantly function_UpdateSubraceBuffs
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
                    - stop
                - narrate "<&c>You cannot change race to <[arg2].to_titlecase>"
                - stop
        - narrate "<&c>Invalid race command"

command_Subrace:
    type: command
    name: subrace
    usage: /subrace
    script:
        - define arg1:<context.args.[1]||null>
        - define arg2:<context.args.[2]||null>
        - foreach <yaml[race_config].list_keys[]> as:race:
            - if <yaml[race_config].list_keys[<[race]>.subraces].contains[<[arg1].to_titlecase>]||false>:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>    - <[arg1].to_titlecase> -"
                - narrate "<&8>-------------------"
                - foreach <yaml[race_config].list_keys[<[race]>.subraces.<[arg1].to_titlecase>.buffs]> as:buff:
                    - define val:<yaml[race_config].read[<[race]>.subraces.<[arg1].to_titlecase>.buffs.<[buff]>]>
                    - choose <[buff]>:
                        - case Health:
                            - narrate "<&e>Increases health by up to <[val].*[40]>"
                        - case Mana:
                            - narrate "<&e>Increases mana by up to <[val].*[40]>"
                        - case Armor:
                            - narrate "<&e>Increases armor by up to <[val].*[40]>"
                        - case Damage:
                            - narrate "<&e>Increases damage by up to <[val].*[40]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increases magic damage by up to <[val].*[40]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increases sword damage by up to <[val].*[40]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increases axe damage by up to <[val].*[40]>%"
                        - case BowDamage:
                            - narrate "<&e>Increases bow damage by up to <[val].*[40]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increases long range damage by up to <[val].*[40]>%"
                        - case Critical:
                            - narrate "<&e>Increases critical chance by up to <[val].*[40]>%"
                        - case Poison:
                            - narrate "<&e>Increases chance to poison by up to <[val].*[40]>%"
                        - case Bleed:
                            - narrate "<&e>Increases chance to bleed by up to <[val].*[40]>%"
                        - case Backstab:
                            - narrate "<&e>Increases backstab damage by up to <[val].*[40]>%"
                        - case Speed:
                            - narrate "<&e>Increases speed by up to <[val].*[40]>"
                        - case Dodge:
                            - narrate "<&e>Increases dodge by up to <[val].*[40]>%"
                        - case Parry:
                            - narrate "<&e>Increases parry by up to <[val].*[40]>%"
                        - case Lifesteal
                            - narrate "<&e>Increases lifesteal by up to <[val].*[40]>%"
                        - case Luck
                            - narrate "<&e>Increases luck by up to <[val].*[40]>"
                        - case Regen:
                            - narrate "<&e>Increases regen by up to <[val].*[40]>%"
                        - case HpRegen:
                            - narrate "<&e>Increases health regen by up to <[val].*[40]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increases mana regen by up to <[val].*[40]>%"
                        - case RegenAura:
                            - narrate "<&e>Increases regen of allies by up to <[val].*[40]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increases health regen of allies by up to <[val].*[40]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases mana regen of allies by up to <[val].*[40]>%"
                        - case Hover:
                            - narrate "<&e>Allows you to hover"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Allows you to breathe underwater"
                - narrate "<&8>-------------------"
                - stop
        - choose <[arg1]>:
            - case null:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>- Subrace Commands -"
                - narrate "<&8>-------------------"
                - narrate "<&e>/subrace<&8>- <&7>Subrace commands"
                - narrate "<&e>/subrace help<&8>- <&7>Explains subraces"
                - narrate "<&e>/subrace list <&8>- <&7>Displays a list of subraces"
                - narrate "<&e>/subrace (name) <&8>- <&7>Gives info on a subrace"
                - narrate "<&e>/subrace change (name) <&8>- <&7>Changes subrace"
                - narrate "<&e>/subrace info <&8>- <&7>Gives info on your current subrace"
                - narrate "<&e>/subrace stats <&8>- <&7>Displays subrace stats"
                - narrate "<&e>/stats <&8>- <&7>Displays all stats"
                - narrate "<&8>-------------------"
                - stop
            - case help:
                - narrate " "
                - narrate "<&e>- Subraces give you stats that increase as you level"
                - narrate "<&e>- Gain experience from mob kills and"
                - narrate "<&e>  played time"
                - stop
            - case list:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Subaces -"
                - narrate "<&8>-------------------"
                - foreach <yaml[race_config].list_keys[]> as:race:
                    - narrate "<&a><&l><[race]>"
                    - foreach <yaml[race_config].list_keys[<[race]>.subraces]> as:subrace:
                        - narrate "  <&6><[subrace]>"
                - narrate "<&8>-------------------"
                - narrate "<&e>Type /race (name) to view more info on a race"
                - narrate "<&e>Type /subrace (name) to view more info on a subrace"
                - stop
            - case info:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Race Info -"
                - narrate "<&8>-------------------"
                - narrate "<&6><&l>Race:  <&e><yaml[<player.uuid>].read[races.race]>"
                - narrate "<&6><&l>Level: <&e><yaml[<player.uuid>].read[races.level]>"
                - narrate "<&6><&l>Xp:    <&e><yaml[<player.uuid>].read[races.xp]>/<el@10000.*[<yaml[<player.uuid>].read[races.level]>]>"
                - narrate "<&8>---------"
                - narrate "<&6><&l>SubRace: <&e><yaml[<player.uuid>].read[races.subrace]>"
                - narrate "<&6><&l>Level:   <&e><yaml[<player.uuid>].read[races.sublevel]>"
                - narrate "<&6><&l>Xp:      <&e><yaml[<player.uuid>].read[races.subxp]>/<el@10000.*[<yaml[<player.uuid>].read[races.sublevel]>]>"
                - narrate "<&8>-------------------"
                - stop
            - case stats:
                - define race:<yaml[<player.uuid>].read[races.race]>
                - define subrace:<yaml[<player.uuid>].read[races.subrace]>
                - define sublevel:<yaml[<player.uuid>].read[races.sublevel]>
                - if <[subrace]> == Default:
                    - narrate "<&c>You have no subrace"
                    - stop
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l> - Subrace Stats -"
                - narrate "<&8>-------------------"
                - foreach <yaml[race_config].list_keys[<[race]>.subraces.<[subrace]>.buffs]> as:stat:
                    - define val:<yaml[race_config].read[<[race]>.subraces.<[subrace]>.buffs.<[stat]>].*[<[sublevel]>]>
                    - choose <[stat]>:
                        - case Health:
                            - narrate "<&e>Increased <&6>health<&e> - <[val]>"
                        - case Mana:
                            - narrate "<&e>Increased <&6>mana<&e> - <[val]>"
                        - case Armor:
                            - narrate "<&e>Increased <&6>armor<&e> - <[val]>"
                        - case Damage:
                            - narrate "<&e>Increased <&6>damage<&e> - <[val]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increased <&6>magic damage<&e> - <[val]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increased <&6>sword damage<&e> - <[val]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increased <&6>axe damage<&e> - <[val]>%"
                        - case BowDamage:
                            - narrate "<&e>Increased <&6>bow damage<&e> - <[val]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increased <&6>long range damage<&e> - <[val]>%"
                        - case Critical:
                            - narrate "<&e>Increased <&6>critical<&e> chance - <[val]>%"
                        - case Poison:
                            - narrate "<&e>Increased <&6>chance to poison<&e> - <[val]>%"
                        - case Bleed:
                            - narrate "<&e>Increased <&6>chance to bleed<&e> - <[val]>%"
                        - case Backstab:
                            - narrate "<&e>Increased <&6>backstab damage<&e> - <[val]>%"
                        - case Speed:
                            - narrate "<&e>Increased <&6>speed<&e> - <[val]>"
                        - case Dodge:
                            - narrate "<&e>Increased <&6>dodge<&e> - <[val]>%"
                        - case Parry:
                            - narrate "<&e>Increased <&6>parry<&e> - <[val]>%"
                        - case Lifesteal
                            - narrate "<&e>Increased <&6>lifesteal<&e> - <[val]>%"
                        - case Luck
                            - narrate "<&e>Increased <&6>luck<&e> - <[val]>"
                        - case Regen:
                            - narrate "<&e>Increased <&6>regen<&e> - <[val]>%"
                        - case HpRegen:
                            - narrate "<&e>Increased <&6>health regen<&e> - <[val]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increased <&6>mana regen<&e> - <[val]>%"
                        - case RegenAura:
                            - narrate "<&e>Increased <&6>regen<&e> of allies - <[val]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increased <&6>health regen<&e> of allies - <[val]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases <&6>mana regen<&e> of allies - <[val]>%"
                        - case Hover:
                            - narrate "<&e>Can hover"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Can breathe underwater"
                - narrate "<&8>-------------------"
                - stop
            - case change:
                - if <yaml[race_config].list_keys[<yaml[<player.uuid>].read[races.race]>.subraces].contains[<[arg2].to_titlecase>]||false> && <yaml[<player.uuid>].read[races.subrace]> != <[arg2].to_titlecase>:
                    - narrate "<&e>You change to <[arg2].to_titlecase>"
                    - if <yaml[<player.uuid>].read[races.subrace]> != Default:
                        - run instantly function_ClearSubraceBuffs
                    - define race:<yaml[<player.uuid>].read[races.race]>
                    - define subrace:<[arg2].to_titlecase>
                    - define last_subrace:<yaml[<player.uuid>].read[races.subrace]>
                    - define sublevel:<yaml[<player.uuid>].read[races.<[subrace]>_level]||1>
                    - define last_sublevel:<yaml[<player.uuid>].read[races.sublevel]||1>
                    - define subxp:<yaml[<player.uuid>].read[races.<[subrace]>_xp]||0>
                    - define last_subxp:<yaml[<player.uuid>].read[races.subxp]||0>
                    - define subrace_buffs:<yaml[race_config].list_keys[<[race]>.subraces.<[subrace]>.buffs]>
                    #- define last_subrace_buffs:<yaml[race_config].list_keys[<[race]>.subraces.<[last_subrace]>.buffs]||null>
                    - yaml id:<player.uuid> set races.subrace:<[subrace]>
                    - yaml id:<player.uuid> set races.last_subrace:<[last_subrace]>
                    - yaml id:<player.uuid> set races.sublevel:<[sublevel]>
                    - yaml id:<player.uuid> set races.last_sublevel:<[last_sublevel]>
                    - yaml id:<player.uuid> set races.subxp:<[subxp]>
                    - yaml id:<player.uuid> set races.last_subxp:<[last_subxp]>
                    - yaml id:<player.uuid> set races.<[last_subrace]>_level:<[last_sublevel]>
                    - yaml id:<player.uuid> set races.<[last_subrace]>_xp:<[last_subxp]>
                    - run instantly function_UpdateSubraceBuffs
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
                    - stop
                - narrate "<&c>You cannot change subrace to <[arg2].to_titlecase>"
                - stop
        - narrate "<&c>Invalid subrace command"

command_Class:
    type: command
    name: class
    usage: /class
    script:
        - define arg1:<context.args.[1]||null>
        - define arg2:<context.args.[2]||null>
        - define arg3:<context.args.[3]||null>
        - if <yaml[class_config].list_keys[].contains[<[arg1].to_titlecase>]>:
            - narrate " "
            - narrate "<&8>-------------------"
            - narrate "<&a><&l>    - <[arg1].to_titlecase> -"
            - narrate "<&8>-------------------"
            - foreach <yaml[class_config].list_keys[<[arg1].to_titlecase>.buffs]> as:buff:
                - define val:<yaml[class_config].read[<[arg1].to_titlecase>.buffs.<[buff]>]>
                - choose <[buff]>:
                    - case Health:
                        - narrate "<&e>Increases health by up to <[val].*[40]>"
                    - case Mana:
                        - narrate "<&e>Increases mana by up to <[val].*[40]>"
                    - case Armor:
                        - narrate "<&e>Increases armor by up to <[val].*[40]>"
                    - case Damage:
                        - narrate "<&e>Increases damage by up to <[val].*[40]>%"
                    - case MagicDamage:
                        - narrate "<&e>Increases magic damage by up to <[val].*[40]>%"
                    - case SwordDamage:
                        - narrate "<&e>Increases sword damage by up to <[val].*[40]>%"
                    - case AxeDamage:
                        - narrate "<&e>Increases axe damage by up to <[val].*[40]>%"
                    - case BowDamage:
                        - narrate "<&e>Increases bow damage by up to <[val].*[40]>%"
                    - case LongRangeDamage:
                        - narrate "<&e>Increases long range damage by up to <[val].*[40]>%"
                    - case Critical:
                        - narrate "<&e>Increases critical chance by up to <[val].*[40]>%"
                    - case Poison:
                        - narrate "<&e>Increases chance to poison by up to <[val].*[40]>%"
                    - case Bleed:
                        - narrate "<&e>Increases chance to bleed by up to <[val].*[40]>%"
                    - case Backstab:
                        - narrate "<&e>Increases backstab damage by up to <[val].*[40]>%"
                    - case Speed:
                        - narrate "<&e>Increases speed by up to <[val].*[40]>"
                    - case Dodge:
                        - narrate "<&e>Increases dodge by up to <[val].*[40]>%"
                    - case Parry:
                        - narrate "<&e>Increases parry by up to <[val].*[40]>%"
                    - case Lifesteal
                        - narrate "<&e>Increases lifesteal by up to <[val].*[40]>%"
                    - case Luck
                        - narrate "<&e>Increases luck by up to <[val].*[40]>"
                    - case Regen:
                        - narrate "<&e>Increases regen by up to <[val].*[40]>%"
                    - case HpRegen:
                        - narrate "<&e>Increases health regen by up to <[val].*[40]>%"
                    - case ManaRegen:
                        - narrate "<&e>Increases mana regen by up to <[val].*[40]>%"
                    - case RegenAura:
                        - narrate "<&e>Increases regen of allies by up to <[val].*[40]>%"
                    - case HpRegenAura:
                        - narrate "<&e>Increases health regen of allies by up to <[val].*[40]>%"
                    - case ManaRegenAura:
                        - narrate "<&e>Increases mana regen of allies by up to <[val].*[40]>%"
                    - case Hover:
                        - narrate "<&e>Allows you to hover"
                    - case UnderwaterBreathing:
                        - narrate "<&e>Allows you to breathe underwater"
            - narrate "<&8>----<&a>Sub-Classes<&8>----"
            - foreach <yaml[class_config].list_keys[<[arg1].to_titlecase>.subclasses]> as:subclass:
                - narrate "<&6><[subclass]>"
            - narrate "<&8>-------------------"
            - narrate "<&e>Type /subclass (name) to view more info on a subclass"
            - stop
        - else:
            - foreach <yaml[class_config].list_keys[]> as:class:
                - if <yaml[class_config].list_keys[<[class]>.subclasses].contains[<[arg1].to_titlecase>]>:
                    - narrate " "
                    - narrate "<&8>-------------------"
                    - narrate "<&a><&l>    - <[arg1].to_titlecase> -"
                    - narrate "<&8>-------------------"
                    - foreach <yaml[class_config].list_keys[<[class]>.subclasses.<[arg1].to_titlecase>.buffs]> as:buff:
                        - define val:<yaml[class_config].read[<[class]>.subclasses.<[arg1].to_titlecase>.buffs.<[buff]>]>
                        - choose <[buff]>:
                            - case Health:
                                - narrate "<&e>Increases health by up to <[val].*[40]>"
                            - case Mana:
                                - narrate "<&e>Increases mana by up to <[val].*[40]>"
                            - case Armor:
                                - narrate "<&e>Increases armor by up to <[val].*[40]>"
                            - case Damage:
                                - narrate "<&e>Increases damage by up to <[val].*[40]>%"
                            - case MagicDamage:
                                - narrate "<&e>Increases magic damage by up to <[val].*[40]>%"
                            - case SwordDamage:
                                - narrate "<&e>Increases sword damage by up to <[val].*[40]>%"
                            - case AxeDamage:
                                - narrate "<&e>Increases axe damage by up to <[val].*[40]>%"
                            - case BowDamage:
                                - narrate "<&e>Increases bow damage by up to <[val].*[40]>%"
                            - case LongRangeDamage:
                                - narrate "<&e>Increases long range damage by up to <[val].*[40]>%"
                            - case Critical:
                                - narrate "<&e>Increases critical chance by up to <[val].*[40]>%"
                            - case Poison:
                                - narrate "<&e>Increases chance to poison by up to <[val].*[40]>%"
                            - case Bleed:
                                - narrate "<&e>Increases chance to bleed by up to <[val].*[40]>%"
                            - case Backstab:
                                - narrate "<&e>Increases backstab damage by up to <[val].*[40]>%"
                            - case Speed:
                                - narrate "<&e>Increases speed by up to <[val].*[40]>"
                            - case Dodge:
                                - narrate "<&e>Increases dodge by up to <[val].*[40]>%"
                            - case Parry:
                                - narrate "<&e>Increases parry by up to <[val].*[40]>%"
                            - case Lifesteal
                                - narrate "<&e>Increases lifesteal by up to <[val].*[40]>%"
                            - case Luck
                                - narrate "<&e>Increases luck by up to <[val].*[40]>"
                            - case Regen:
                                - narrate "<&e>Increases regen by up to <[val].*[40]>%"
                            - case HpRegen:
                                - narrate "<&e>Increases health regen by up to <[val].*[40]>%"
                            - case ManaRegen:
                                - narrate "<&e>Increases mana regen by up to <[val].*[40]>%"
                            - case RegenAura:
                                - narrate "<&e>Increases regen of allies by up to <[val].*[40]>%"
                            - case HpRegenAura:
                                - narrate "<&e>Increases health regen of allies by up to <[val].*[40]>%"
                            - case ManaRegenAura:
                                - narrate "<&e>Increases mana regen of allies by up to <[val].*[40]>%"
                            - case Hover:
                                - narrate "<&e>Allows you to hover"
                            - case UnderwaterBreathing:
                                - narrate "<&e>Allows you to breathe underwater"
                    #- narrate "<&8>------<&a>Abilities<&8>-------"
                    #- foreach <yaml[class_config].list_keys[<[class]>.subclasses.<[arg1].to_titlecase>.abilities]||<yaml[class_config].read[<[class]>.subclasses.<[arg1].to_titlecase>.abilities]>> as:ability:
                    #    - narrate "<&6><[ability]>"
                    #- narrate "<&8>-------------------"
                    #- narrate "<&e>Use /ability (name) for more info"
                    - stop
        - choose <[arg1]>:
            - case null:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>- Class Commands -"
                - narrate "<&8>-------------------"
                - narrate "<&e>/class<&8>- <&7>Class commands"
                - narrate "<&e>/class help<&8>- <&7>Explains classes"
                - narrate "<&e>/class list <&8>- <&7>Displays a list of classes"
                - narrate "<&e>/class (name) <&8>- <&7>Gives info on a class"
                - narrate "<&e>/class change (name) <&8>- <&7>Changes class"
                - narrate "<&e>/class info <&8>- <&7>Displays info on your current classes"
                - narrate "<&e>/class stats <&8>- <&7>Displays class stats"
                - narrate "<&e>/subclass <&8>- <&7>Subclass commands"
                - narrate "<&8>-------------------"
                - stop
            - case help:
                - narrate " "
                - narrate "<&e>- Classes give you stats that increase as you level"
                - narrate "<&e>- Gain experience from mob kills"
                - stop
            - case list:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>   - Classes -"
                - narrate "<&8>-------------------"
                - foreach <yaml[class_config].list_keys[]> as:class_name:
                    - narrate "<&6><&l><[class_name]>"
                - narrate "<&8>-------------------"
                - narrate "<&e>Type /class (name) to view more info on a class"
                - stop
            - case info:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Class Info -"
                - narrate "<&8>-------------------"
                - narrate "<&6><&l>Class:    <&e><yaml[<player.uuid>].read[classes.class]>"
                - narrate "<&6><&l>Level:    <&e><yaml[<player.uuid>].read[classes.level]>"
                - narrate "<&6><&l>Xp:       <&e><yaml[<player.uuid>].read[classes.xp]>/<el@10000.*[<yaml[<player.uuid>].read[classes.level]>]>"
                - narrate "<&8>---------"
                - narrate "<&6><&l>Subclass: <&e><yaml[<player.uuid>].read[classes.subclass]>"
                - narrate "<&6><&l>Level:     <&e><yaml[<player.uuid>].read[classes.sublevel]>"
                - narrate "<&6><&l>Xp:        <&e><yaml[<player.uuid>].read[classes.subxp]>/<el@10000.*[<yaml[<player.uuid>].read[classes.sublevel]>]>"
                - narrate "<&8>-------------------"
                - stop
            - case stats:
                - define class:<yaml[<player.uuid>].read[classes.class]>
                - define level:<yaml[<player.uuid>].read[classes.level]>
                - if <[class]> == Default:
                    - narrate "<&c>You have no class"
                    - stop
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Class Stats -"
                - narrate "<&8>-------------------"
                - foreach <yaml[class_config].list_keys[<[class]>.buffs]||null> as:stat:
                    - define val:<yaml[class_config].read[<[class]>.buffs.<[stat]>].*[<[level]>]>
                    - choose <[stat]>:
                        - case Health:
                            - narrate "<&e>Increased <&6>health<&e> - <[val]>"
                        - case Mana:
                            - narrate "<&e>Increased <&6>mana<&e> - <[val]>"
                        - case Armor:
                            - narrate "<&e>Increased <&6>armor<&e> - <[val]>"
                        - case Damage:
                            - narrate "<&e>Increased <&6>damage<&e> - <[val]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increased <&6>magic damage<&e> - <[val]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increased <&6>sword damage<&e> - <[val]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increased <&6>axe damage<&e> - <[val]>%"
                        - case BowDamage:
                            - narrate "<&e>Increased <&6>bow damage<&e> - <[val]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increased <&6>long range damage<&e> - <[val]>%"
                        - case Critical:
                            - narrate "<&e>Increased <&6>critical<&e> chance - <[val]>%"
                        - case Poison:
                            - narrate "<&e>Increased <&6>chance to poison<&e> - <[val]>%"
                        - case Bleed:
                            - narrate "<&e>Increased <&6>chance to bleed<&e> - <[val]>%"
                        - case Backstab:
                            - narrate "<&e>Increased <&6>backstab damage<&e> - <[val]>%"
                        - case Speed:
                            - narrate "<&e>Increased <&6>speed<&e> - <[val]>"
                        - case Dodge:
                            - narrate "<&e>Increased <&6>dodge<&e> - <[val]>%"
                        - case Parry:
                            - narrate "<&e>Increased <&6>parry<&e> - <[val]>%"
                        - case Lifesteal
                            - narrate "<&e>Increased <&6>lifesteal<&e> - <[val]>%"
                        - case Luck
                            - narrate "<&e>Increased <&6>luck<&e> - <[val]>"
                        - case Regen:
                            - narrate "<&e>Increased <&6>regen<&e> - <[val]>%"
                        - case HpRegen:
                            - narrate "<&e>Increased <&6>health regen<&e> - <[val]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increased <&6>mana regen<&e> - <[val]>%"
                        - case RegenAura:
                            - narrate "<&e>Increased <&6>regen<&e> of allies - <[val]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increased <&6>health regen<&e> of allies - <[val]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases <&6>mana regen<&e> of allies - <[val]>%"
                        - case Hover:
                            - narrate "<&e>Can hover"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Can breathe underwater"
                - narrate "<&8>-------------------"
                - stop
            - case change:
                - if <yaml[class_config].list_keys[].contains[<[arg2].to_titlecase>]> && <yaml[<player.uuid>].read[classes.class]> != <[arg2].to_titlecase>:
                    - narrate "<&e>You change to <[arg2].to_titlecase>"
                    - if <yaml[<player.uuid>].read[classes.subclass]> != Default:
                        - run instantly function_ClearSubclassBuffs
                        - define subclass:Default
                        - define last_subclass:<yaml[<player.uuid>].read[classes.subclass]>
                        - define sublevel:1
                        - define last_sublevel:<yaml[<player.uuid>].read[classes.sublevel]||1>
                        - define subxp:<yaml[<player.uuid>].read[classes.<[subclass]>_xp]||0>
                        - define last_subxp:<yaml[<player.uuid>].read[classes.<[last_subclass]>_xp]||0>
                        - yaml id:<player.uuid> set classes.subclass:<[subclass]>
                        - yaml id:<player.uuid> set classes.last_subclass:<[last_subclass]>
                        - yaml id:<player.uuid> set classes.sublevel:<[sublevel]>
                        - yaml id:<player.uuid> set classes.last_sublevel:<[last_sublevel]>
                        - yaml id:<player.uuid> set classes.subxp:<[subxp]>
                        - yaml id:<player.uuid> set classes.last_subxp:<[last_subxp]>
                        - yaml id:<player.uuid> set classes.<[last_subclass]>_level:<[last_sublevel]>
                        - yaml id:<player.uuid> set classes.<[last_subclass]>_xp:<[last_subxp]>

                    - if <yaml[<player.uuid>].read[classes.class]> != default
                        - run instantly function_ClearClassBuffs
                    - define class:<[arg2].to_titlecase>
                    - define last_class:<yaml[<player.uuid>].read[classes.class]>
                    - define level:<yaml[<player.uuid>].read[classes.<[class]>_level]||1>
                    - define last_level:<yaml[<player.uuid>].read[classes.level]||1>
                    - define xp:<yaml[<player.uuid>].read[classes.<[class]>_xp]||0>
                    - define last_xp:<yaml[<player.uuid>].read[classes.<[last_class]>_xp]||0>
                    - define class_buffs:<yaml[class_config].list_keys[<[class]>.buffs]>
                    - yaml id:<player.uuid> set classes.class:<[class]>
                    - yaml id:<player.uuid> set classes.last_class:<[last_class]>
                    - yaml id:<player.uuid> set classes.level:<[level]>
                    - yaml id:<player.uuid> set classes.last_level:<[last_level]>
                    - yaml id:<player.uuid> set classes.xp:<[xp]>
                    - yaml id:<player.uuid> set classes.last_xp:<[last_xp]>
                    - yaml id:<player.uuid> set classes.<[last_class]>_level:<[last_level]>
                    - yaml id:<player.uuid> set classes.<[last_class]>_xp:<[last_xp]>
                    - run instantly function_updateclassbuffs
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
                    - stop

                - else if <yaml[class_config].list_keys[<yaml[<player.uuid>].read[classes.class]>.subclasses].contains[<[arg2].to_titlecase>]||false> && <yaml[<player.uuid>].read[classes.subclass]> != <[arg2].to_titlecase>:
                    - narrate "<&e>You change to <[arg2].to_titlecase>"
                    - if <yaml[<player.uuid>].read[classes.subclass]> != Default:
                        - run instantly function_ClearSubclassBuffs
                        - yaml id:<player.uuid> set classes.abilities:!
                    - define class:<yaml[<player.uuid>].read[classes.class]>
                    - define subclass:<[arg2].to_titlecase>
                    - define last_subclass:<yaml[<player.uuid>].read[classes.subclass]>
                    - define sublevel:<yaml[<player.uuid>].read[classes.<[subclass]>_level]||1>
                    - define last_sublevel:<yaml[<player.uuid>].read[classes.sublevel]||1>
                    - define subxp:<yaml[<player.uuid>].read[classes.<[subclass]>_xp]||0>
                    - define last_subxp:<yaml[<player.uuid>].read[classes.<[last_subclass]>_xp]||0>
                    - define subclass_buffs:<yaml[class_config].list_keys[<[class]>.subclasses.<[subclass]>.buffs]>
                    - flag player ability:0
                    - yaml id:<player.uuid> set classes.subclass:<[subclass]>
                    - yaml id:<player.uuid> set classes.last_subclass:<[last_subclass]>
                    - yaml id:<player.uuid> set classes.sublevel:<[sublevel]>
                    - yaml id:<player.uuid> set classes.last_sublevel:<[last_sublevel]>
                    - yaml id:<player.uuid> set classes.subxp:<[subxp]>
                    - yaml id:<player.uuid> set classes.last_subxp:<[last_subxp]>
                    - yaml id:<player.uuid> set classes.<[last_subclass]>_level:<[last_sublevel]>
                    - yaml id:<player.uuid> set classes.<[last_subclass]>_xp:<[last_subxp]>
                    #- yaml id:<player.uuid> set classes.abilities:<yaml[class_config].read[<[class]>.subclasses.<[subclass]>.abilities]>
                    - run instantly function_UpdateSubclassBuffs
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
                    - stop
                - narrate "<&c>You cannot change class to <[arg2].to_titlecase>"
        - narrate "<&c>Invalid class command"

command_Subclass:
    type: command
    name: subclass
    usage: /subclass
    script:
        - define arg1:<context.args.[1]||null>
        - define arg2:<context.args.[2]||null>
        - foreach <yaml[class_config].list_keys[]> as:class:
            - if <yaml[class_config].list_keys[<[class]>.subclasses].contains[<[arg1].to_titlecase>]||false>:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>    - <[arg1].to_titlecase> -"
                - narrate "<&8>-------------------"
                - foreach <yaml[class_config].list_keys[<[class]>.subclasses.<[arg1].to_titlecase>.buffs]> as:buff:
                    - define val:<yaml[class_config].read[<[class]>.subclasses.<[arg1].to_titlecase>.buffs.<[buff]>]>
                    - choose <[buff]>:
                        - case Health:
                            - narrate "<&e>Increases health by up to <[val].*[40]>"
                        - case Mana:
                            - narrate "<&e>Increases mana by up to <[val].*[40]>"
                        - case Armor:
                            - narrate "<&e>Increases armor by up to <[val].*[40]>"
                        - case Damage:
                            - narrate "<&e>Increases damage by up to <[val].*[40]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increases magic damage by up to <[val].*[40]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increases sword damage by up to <[val].*[40]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increases axe damage by up to <[val].*[40]>%"
                        - case BowDamage:
                            - narrate "<&e>Increases bow damage by up to <[val].*[40]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increases long range damage by up to <[val].*[40]>%"
                        - case Critical:
                            - narrate "<&e>Increases critical chance by up to <[val].*[40]>%"
                        - case Poison:
                            - narrate "<&e>Increases chance to poison by up to <[val].*[40]>%"
                        - case Bleed:
                            - narrate "<&e>Increases chance to bleed by up to <[val].*[40]>%"
                        - case Backstab:
                            - narrate "<&e>Increases backstab damage by up to <[val].*[40]>%"
                        - case Speed:
                            - narrate "<&e>Increases speed by up to <[val].*[40]>"
                        - case Dodge:
                            - narrate "<&e>Increases dodge by up to <[val].*[40]>%"
                        - case Parry:
                            - narrate "<&e>Increases parry by up to <[val].*[40]>%"
                        - case Lifesteal
                            - narrate "<&e>Increases lifesteal by up to <[val].*[40]>%"
                        - case Luck
                            - narrate "<&e>Increases luck by up to <[val].*[40]>"
                        - case Regen:
                            - narrate "<&e>Increases regen by up to <[val].*[40]>%"
                        - case HpRegen:
                            - narrate "<&e>Increases health regen by up to <[val].*[40]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increases mana regen by up to <[val].*[40]>%"
                        - case RegenAura:
                            - narrate "<&e>Increases regen of allies by up to <[val].*[40]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increases health regen of allies by up to <[val].*[40]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases mana regen of allies by up to <[val].*[40]>%"
                        - case Hover:
                            - narrate "<&e>Allows you to hover"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Allows you to breathe underwater"
                #- narrate "<&8>------<&a>Abilities<&8>-------"
                #- foreach <yaml[class_config].list_keys[<[class]>.subclasses.<[arg1].to_titlecase>.abilities]||<yaml[class_config].read[<[class]>.subclasses.<[arg1].to_titlecase>.abilities]>> as:ability:
                #    - narrate "<&6><[ability]>"
                #    - narrate "<&8>-------------------"
                #    - narrate "<&e>Use /ability (name) for more info"
                - stop
        - choose <[arg1]>:
            - case null:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>- Subclass Commands -"
                - narrate "<&8>-------------------"
                - narrate "<&e>/subclass<&8>- <&7>Subclass commands"
                - narrate "<&e>/subclass help<&8>- <&7>Explains subclasses"
                - narrate "<&e>/subclass list <&8>- <&7>Displays a list of subclasses"
                - narrate "<&e>/subclass (name) <&8>- <&7>Gives info on a subclass"
                - narrate "<&e>/subclass change (name) <&8>- <&7>Changes subclass"
                - narrate "<&e>/subclass info <&8>- <&7>Gives info on your current subclass"
                - narrate "<&e>/subclass stats <&8>- <&7>Displays subclass stats"
                - narrate "<&e>/stats <&8>- <&7>Displays all stats"
                - narrate "<&8>-------------------"
                - stop
            - case help:
                - narrate " "
                - narrate "<&e>- Subclasses give you stats that increase as you level"
                - narrate "<&e>- Gain experience from mob kills"
                - stop
            - case list:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Subclasses -"
                - narrate "<&8>-------------------"
                - foreach <yaml[class_config].list_keys[]> as:class:
                    - narrate "<&a><&l><[class]>"
                    - foreach <yaml[class_config].list_keys[<[class]>.subclasses]> as:subclass:
                        - narrate "  <&6><[subclass]>"
                - narrate "<&8>-------------------"
                - narrate "<&e>Type /class (name) to view more info on a class"
                - narrate "<&e>Type /subclass (name) to view more info on a subclass"
                - stop
            - case info:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Class Info -"
                - narrate "<&8>-------------------"
                - narrate "<&6><&l>class:  <&e><yaml[<player.uuid>].read[classes.class]>"
                - narrate "<&6><&l>Level: <&e><yaml[<player.uuid>].read[classes.level]>"
                - narrate "<&6><&l>Xp:    <&e><yaml[<player.uuid>].read[classes.xp]>/<el@10000.*[<yaml[<player.uuid>].read[classes.level]>]>"
                - narrate "<&8>---------"
                - narrate "<&6><&l>Subclass: <&e><yaml[<player.uuid>].read[classes.subclass]>"
                - narrate "<&6><&l>Level:   <&e><yaml[<player.uuid>].read[classes.sublevel]>"
                - narrate "<&6><&l>Xp:      <&e><yaml[<player.uuid>].read[classes.subxp]>/<el@10000.*[<yaml[<player.uuid>].read[classes.sublevel]>]>"
                - narrate "<&8>-------------------"
                - stop
            - case stats:
                - define class:<yaml[<player.uuid>].read[classes.class]>
                - define subclass:<yaml[<player.uuid>].read[classes.subclass]>
                - define sublevel:<yaml[<player.uuid>].read[classes.sublevel]>
                - if <[subclass]> == Default:
                    - narrate "<&c>You have no subclass"
                    - stop
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l> - Subclass Stats -"
                - narrate "<&8>-------------------"
                - foreach <yaml[class_config].list_keys[<[class]>.subclasses.<[subclass]>.buffs]> as:stat:
                    - define val:<yaml[class_config].read[<[class]>.subclasses.<[subclass]>.buffs.<[stat]>].*[<[sublevel]>]>
                    - choose <[stat]>:
                        - case Health:
                            - narrate "<&e>Increased <&6>health<&e> - <[val]>"
                        - case Mana:
                            - narrate "<&e>Increased <&6>mana<&e> - <[val]>"
                        - case Armor:
                            - narrate "<&e>Increased <&6>armor<&e> - <[val]>"
                        - case Damage:
                            - narrate "<&e>Increased <&6>damage<&e> - <[val]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increased <&6>magic damage<&e> - <[val]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increased <&6>sword damage<&e> - <[val]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increased <&6>axe damage<&e> - <[val]>%"
                        - case BowDamage:
                            - narrate "<&e>Increased <&6>bow damage<&e> - <[val]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increased <&6>long range damage<&e> - <[val]>%"
                        - case Critical:
                            - narrate "<&e>Increased <&6>critical<&e> chance - <[val]>%"
                        - case Poison:
                            - narrate "<&e>Increased <&6>chance to poison<&e> - <[val]>%"
                        - case Bleed:
                            - narrate "<&e>Increased <&6>chance to bleed<&e> - <[val]>%"
                        - case Backstab:
                            - narrate "<&e>Increased <&6>backstab damage<&e> - <[val]>%"
                        - case Speed:
                            - narrate "<&e>Increased <&6>speed<&e> - <[val]>"
                        - case Dodge:
                            - narrate "<&e>Increased <&6>dodge<&e> - <[val]>%"
                        - case Parry:
                            - narrate "<&e>Increased <&6>parry<&e> - <[val]>%"
                        - case Lifesteal
                            - narrate "<&e>Increased <&6>lifesteal<&e> - <[val]>%"
                        - case Luck
                            - narrate "<&e>Increased <&6>luck<&e> - <[val]>"
                        - case Regen:
                            - narrate "<&e>Increased <&6>regen<&e> - <[val]>%"
                        - case HpRegen:
                            - narrate "<&e>Increased <&6>health regen<&e> - <[val]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increased <&6>mana regen<&e> - <[val]>%"
                        - case RegenAura:
                            - narrate "<&e>Increased <&6>regen<&e> of allies - <[val]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increased <&6>health regen<&e> of allies - <[val]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases <&6>mana regen<&e> of allies - <[val]>%"
                        - case Hover:
                            - narrate "<&e>Can hover"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Can breathe underwater"
                - narrate "<&8>-------------------"
                - stop
            - case change:
                - if <yaml[class_config].list_keys[<yaml[<player.uuid>].read[classes.class]>.subclasses].contains[<[arg2].to_titlecase>]||false> && <yaml[<player.uuid>].read[classes.subclass]> != <[arg2].to_titlecase>:
                    - narrate "<&e>You change to <[arg2].to_titlecase>"
                    - if <yaml[<player.uuid>].read[classes.subclass]> != Default:
                        - run instantly function_ClearSubclassBuffs
                    - define class:<yaml[<player.uuid>].read[classes.class]>
                    - define subclass:<[arg2].to_titlecase>
                    - define last_subclass:<yaml[<player.uuid>].read[classes.subclass]>
                    - define sublevel:<yaml[<player.uuid>].read[classes.<[subclass]>_level]||1>
                    - define last_sublevel:<yaml[<player.uuid>].read[classes.sublevel]||1>
                    - define subxp:<yaml[<player.uuid>].read[classes.<[subclass]>_xp]||0>
                    - define last_subxp:<yaml[<player.uuid>].read[classes.<[last_subclass]>_xp]||0>
                    - define subclass_buffs:<yaml[class_config].list_keys[<[class]>.subclasses.<[subclass]>.buffs]>
                    - flag player ability:0
                    - yaml id:<player.uuid> set classes.subclass:<[subclass]>
                    - yaml id:<player.uuid> set classes.last_subclass:<[last_subclass]>
                    - yaml id:<player.uuid> set classes.sublevel:<[sublevel]>
                    - yaml id:<player.uuid> set classes.last_sublevel:<[last_sublevel]>
                    - yaml id:<player.uuid> set classes.subxp:<[subxp]>
                    - yaml id:<player.uuid> set classes.last_subxp:<[last_subxp]>
                    - yaml id:<player.uuid> set classes.<[last_subclass]>_level:<[last_sublevel]>
                    - yaml id:<player.uuid> set classes.<[last_subclass]>_xp:<[last_subxp]>
                    #- yaml id:<player.uuid> set classes.abilities:<yaml[class_config].read[<[class]>.subclasses.<[subclass]>.abilities]>
                    - run instantly function_UpdateSubclassBuffs
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
                    - stop
                - narrate "<&c>You cannot change subclass to <[arg2].to_titlecase>"
                - stop
        - narrate "<&c>Invalid subclass command"

command_Stats:
    type: command
    name: stats
    usage: /stats (name/help)
    script:
        - define stats:<yaml[<player.uuid>].list_keys[buffs]||null>
        - choose <context.args.[1]||null>:
            - case help:
                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Stats Help -"
                - narrate "<&8>-------------------"
                - narrate "<&e>- Stats increase attributes of your character or give you unique abilities"
                - narrate "<&e>/stats help<&8>- <&7>Explains stats"
                - narrate "<&e>/stats<&8> - <&7>Displays info on your current stats"
                - narrate "<&e>/stats (name) <&8>- <&7>Displays info on a stat"
                - stop

            - case null:
                - if <[stats]> == null:
                    - narrate "<&c>You have no stats"
                    - stop

                - narrate " "
                - narrate "<&8>-------------------"
                - narrate "<&a><&l>  - Stats -"
                - narrate "<&8>-------------------"
                - foreach <[stats]> as:stat:
                    - define val:<yaml[<player.uuid>].read[buffs.<[stat]>]>
                    - choose <[stat]>:
                        - case Health:
                            - narrate "<&e>Increased <&6>health<&e> - <[val]>"
                        - case Mana:
                            - narrate "<&e>Increased <&6>mana<&e> - <[val]>"
                        - case Armor:
                            - narrate "<&e>Increased <&6>armor<&e> - <[val]>"
                        - case Damage:
                            - narrate "<&e>Increased <&6>damage<&e> - <[val]>%"
                        - case MagicDamage:
                            - narrate "<&e>Increased <&6>magic damage<&e> - <[val]>%"
                        - case SwordDamage:
                            - narrate "<&e>Increased <&6>sword damage<&e> - <[val]>%"
                        - case AxeDamage:
                            - narrate "<&e>Increased <&6>axe damage<&e> - <[val]>%"
                        - case BowDamage:
                            - narrate "<&e>Increased <&6>bow damage<&e> - <[val]>%"
                        - case LongRangeDamage:
                            - narrate "<&e>Increased <&6>long range damage<&e> - <[val]>%"
                        - case Critical:
                            - narrate "<&e>Increased <&6>critical<&e> chance - <[val]>%"
                        - case Poison:
                            - narrate "<&e>Increased <&6>chance to poison<&e> - <[val]>%"
                        - case Bleed:
                            - narrate "<&e>Increased <&6>chance to bleed<&e> - <[val]>%"
                        - case Backstab:
                            - narrate "<&e>Increased <&6>backstab damage<&e> - <[val]>%"
                        - case Speed:
                            - narrate "<&e>Increased <&6>speed<&e> - <[val]>"
                        - case Dodge:
                            - narrate "<&e>Increased <&6>dodge<&e> - <[val]>%"
                        - case Parry:
                            - narrate "<&e>Increased <&6>parry<&e> - <[val]>%"
                        - case Lifesteal
                            - narrate "<&e>Increased <&6>lifesteal<&e> - <[val]>%"
                        - case Luck
                            - narrate "<&e>Increased <&6>luck<&e> - <[val]>"
                        - case Regen:
                            - narrate "<&e>Increased <&6>regen<&e> - <[val]>%"
                        - case HpRegen:
                            - narrate "<&e>Increased <&6>health regen<&e> - <[val]>%"
                        - case ManaRegen:
                            - narrate "<&e>Increased <&6>mana regen<&e> - <[val]>%"
                        - case RegenAura:
                            - narrate "<&e>Increased <&6>regen<&e> of allies - <[val]>%"
                        - case HpRegenAura:
                            - narrate "<&e>Increased <&6>health regen<&e> of allies - <[val]>%"
                        - case ManaRegenAura:
                            - narrate "<&e>Increases <&6>mana regen<&e> of allies - <[val]>%"
                        - case Hover:
                            - narrate "<&e>Can hover by sneaking"
                        - case UnderwaterBreathing:
                            - narrate "<&e>Can breathe underwater"
                - stop

        - choose <context.args.[1]>:
            - case Health:
                - narrate "<&e>Increases health"
            - case Mana:
                - narrate "<&e>Increases mana"
            - case Armor:
                - narrate "<&e>Increases armor"
            - case Damage:
                - narrate "<&e>Increases damage by a percentage"
            - case MagicDamage:
                - narrate "Increases magic damage by a percentage"
            - case SwordDamage:
                - narrate "<&e>Increases sword damage by a percentage"
            - case AxeDamage:
                - narrate "<&e>Increases axe damage by a percentage"
            - case BowDamage:
                - narrate "<&e>Increases bow damage by a percentage"
            - case LongRangeDamage:
                - narrate "<&e>Increases long range damage by a percentage"
            - case Critical:
                - narrate "<&e>Increases critical chance"
            - case Poison:
                - narrate "<&e>Increases chance to poison"
            - case Bleed:
                - narrate "<&e>Increases chance to bleed"
            - case Backstab:
                - narrate "<&e>Increases backstab damage by a percentage"
            - case Speed:
                - narrate "<&e>Increases speed"
            - case Dodge:
                - narrate "<&e>Increases dodge chance"
            - case Parry:
                - narrate "<&e>Increases parry chance"
            - case Lifesteal
                - narrate "<&e>Increases lifesteal by a percentage"
            - case Luck
                - narrate "<&e>Increases luck"
            - case Regen:
                - narrate "<&e>Increases regen by a percentage"
            - case HpRegen:
                - narrate "<&e>Increases health regen by a percentage"
            - case ManaRegen:
                - narrate "<&e>Increases mana regen by a percentage"
            - case RegenAura:
                - narrate "<&e>Increases regen of allies by a percentage"
            - case HpRegenAura:
                - narrate "<&e>Increases health regen of allies by a percentage"
            - case ManaRegenAura:
                - narrate "<&e>Increases mana regen of allies by a percentage"
            - case Hover:
                - narrate "<&e>Allows you to hover"
            - case UnderwaterBreathing:
                - narrate "<&e>Allows you to breathe underwater"
        #- stop
        - narrate "<&c>Invalid stat command"


command_Ability:
    type: command
    name: ability
    usage: /ability (name/help)
    script:
        - if <context.args.[1]||help> == help:
            - narrate "<&e>- Left click with a melee weapon to switch melee ability"
            - narrate "<&e>- Left click with a magic weapon to switch magic ability"
            - narrate "<&e>- Right click with a bow to to switch ranged ability"
            - narrate "<&e>- Opposite click to use selected ability"
            - narrate "<&e>/ability (name) to view ability info"
            - stop

        - define "ability:<context.raw_args.replace[ ].with[]>"
        - define name:<script[data_<[ability]>].yaml_key[name]||null>
        - define description:<script[data_<[ability]>].yaml_key[description]||null>
        - define cooldown:<script[data_<[ability]>].yaml_key[cooldown]||null>
        - define duration:<script[data_<[ability]>].yaml_key[duration]||null>
        - define mana:<script[data_<[ability]>].yaml_key[mana]||null>
        - if <[name]> != null:
            - narrate " "
            - narrate "<&8>-------------------"
            - narrate "<&a><&l>   - <[name]> -"
            - narrate "<&8>-------------------"
            - if <[cooldown]> != null:
                - narrate "<&e>Cooldown: <[cooldown]>"
            - if <[duration]> != null:
                - narrate "<&e>Duration: <[duration]>"
            - if <[mana]> != null:
                - narrate "<&e>Mana: <[mana]>"
            - narrate "<&6>- <[description]>"
            - stop
        - narrate "<&c>Invalid ability"

command_Mana:
    type: command
    name: mana
    usage: /mana
    script:
        - narrate "<&1><&l><yaml[<player.uuid>].read[buffs.Mana]||0>"
        #- narrate <queue.time_ran>

# - HANDLERS
handler_init:
    type: world
    events:
        on server start:
        - if !<server.has_file[../dConfig/races/races.yml]>:
            - yaml id:race_config create
            - yaml id:race_config loadtext:<s@race_config.to_text>
            - yaml id:race_config "savefile:../dConfig/races/races.yml"
        - else:
            - yaml id:race_config load:../dConfig/races/races.yml
        - if !<server.has_file[../dConfig/classes/classes.yml]>:
            - yaml id:class_config create
            - yaml id:class_config loadtext:<s@class_config.to_text>
            - yaml id:class_config "savefile:../dConfig/classes/classes.yml"
        - else:
            - yaml id:class_config load:../dConfig/classes/classes.yml

        on player joins:
        - if !<server.has_file[../dData/players/<player.uuid>.yml]>:
            - yaml id:<player.uuid> create
            - yaml id:<player.uuid> loadtext:<s@player_data.to_text>
            - narrate "<&e>Use /race to pick a race!"
            - narrate "<&e>Use /class to pick a class!"
        - else:
            - yaml id:<player.uuid> "load:../dData/players/<player.uuid>.yml"
            - if <yaml[<player.uuid>].read[races.race]||Default> == Default:
                - narrate "<&e>Use /race to pick a race!"
            - if <yaml[<player.uuid>].read[classes.class]||Default> == Default:
                - narrate "<&e>Use /class to pick a class!"
            - if <yaml[<player.uuid>].list_keys[buffs]||null> != null:
                - run instantly function_resetplayer
        #- narrate <queue.time_ran>

        on player quits:
        - flag player ability:!
        - yaml id:<player.uuid> "savefile:../dData/players/<player.uuid>.yml"
        - yaml id:<player.uuid> unload


handler_buffs:
    type: world
    debug: true
    events:
        on entity damaged by player:
        - define buffs:<yaml[<player.uuid>].list_keys[buffs]||null>
        - if <[buffs]> == null:
            - determine <context.final_damage>
        - define modifier:0
        - define modifier:+:<yaml[<player.uuid>].read[buffs.Damage]||0>
        - if <player.item_in_hand.material.contains[sword]>:
            - define modifier:+:<yaml[<player.uuid>].read[buffs.SwordDamage]||0>
        - if <player.item_in_hand.material.contains[axe]>:
            - define modifier:+:<yaml[<player.uuid>].read[buffs.AxeDamage]||0>
        - if <player.item_in_hand.material.contains[bow]>:
            - define modifier:+:<yaml[<player.uuid>].read[buffs.BowDamage]||0>
            - if <player.location.distance[<context.entity.location>]> >= 50:
                - define modifier:+:<yaml[<player.uuid>].read[buffs.LongRangeDamage]||0>
        - if <[buffs].contains[AimedShot]>:
            - define modifier:+:<yaml[<player.uuid>].read[buffs.AimedShot]||0>
            - yaml id:<player.uuid> set buffs.AimedShot:!
        - if <[buffs].contains[Backstab]> && !<player.target.location.facing[<player>].degrees[120]>:
            - narrate "<&e>*Backstab*"
            - define modifier:+:1.5
        - if <[buffs].contains[AoE]>:
            - foreach <player.location.find.living_entities.within[4]>:
                - hurt <context.final_damage> <[value]> cause:<player>
        - if <[buffs].contains[Poison]>:
            - cast POISON duration:200 power:3 <context.entity>
        - if <[buffs].contains[Critical]>:
            - if <util.random.int[1].to[100]> <= <yaml[<player.uuid>].read[buffs.Critical]>:
                - narrate "<&e>*Critical*"
                - define modifier:*:1.5
        - if <[buffs].contains[Lifesteal]>:
            - heal <context.final_damage./[100].*[<yaml[<player.uuid>].read[buffs.Lifesteal]>]> <player>
        #- narrate <queue.time_ran>
        - determine <context.final_damage.+[<context.final_damage./[100].*[<[modifier]>]>]>

        on player damaged by entity:
        - define buffs:<yaml[<player.uuid>].read[buffs]||null>
        - if <[buffs]> == null:
            - determine <context.final_damage>
        - if <player.has_flag[hovering]>:
            - adjust <player> gravity:true
        - if <[buffs].contains[Parry]>:
            - if <util.random.int[1].to[100]> <= <yaml[<player.uuid>].read[buffs.Parry]||0>:
                - narrate "<&e>*Parried*"
                - determine cancelled
        - if <[buffs].contains[Dodge]>:
            - if <util.random.int[1].to[100]> <= <yaml[<player.uuid>].read[buffs.Dodge]||0>:
                - narrate "<&e>*Dodged*"
                - determine cancelled
        - if <[buffs].contains[Absorb]>:
            - narrate "<&e>*Absorbed*"
            - if <context.final_damage> >= <yaml[<player.uuid>].read[buffs.Absorb]||0>:
                - playeffect effect:end_rod at:<player.location> q:20
                - yaml id:<player.uuid> set "buffs.Absorb:!"
                - determine <context.final_damage.-[<yaml[<player.uuid>].read[buffs.Absorb]||0>]>
            - determine <context.final_damage.-[<context.final_damage./[100].*[<yaml[<player.uuid>].read[buffs.Absorb]>]||0>]>
        - if <[buffs].contains[BlockReflect]>:
            - if <player.is_blocking>:
                - hurt <context.damager> <context.final_damage./[100].*[<yaml[<player.uuid>].read[<[classes.sublevel]>]||0>]>
        - if <[buffs].contains[BladeMaster]>:
            - narrate "<&e>*Parried*"
            - determine cancelled
        #- narrate <queue.time_ran>

        on player starts sneaking:
        - if <yaml[<player.uuid>].list_keys[buffs].contains[Hover]||false>:
            - if <player.has_flag[hovering]>:
                - flag player no_fall_damage
                - flag player hovering:!
                - adjust <player> gravity:true
            - else:
                - flag player hovering
                - adjust <player> gravity:false
            #- narrate <queue.time_ran>

        on player damaged by fall:
        - if <player.has_flag[no_fall_damage]>:
            - flag player no_fall_damage:!
            - determine cancelled
            #- narrate <queue.time_ran>

        on player damaged by drowning:
        - if <yaml[<player.uuid>].list_keys[buffs].contains[UnderwaterBreathing]>:
            #- narrate <queue.time_ran>
            - determine cancelled

        on delta time secondly every:10:
        - foreach <server.list_online_players_flagged[Regen]> as:player:
            - heal <[player].health.max./[100].*[<[player].flag[Regen]>]> <[player]>
            #- if <yaml[<[player].uuid>].read[buffs].contains[Mana]>:
            #    - yaml id:<[player].uuid> set "buffs.Mana:+:<yaml[<[player].uuid>].read[buffs.mana]./[100].*[<[player].flag[Regen]>]>"

        - foreach <server.list_online_players_flagged[HpRegen]> as:player:
            - heal <[player].health.max./[100].*[<[player].flag[HpRegen]>]> <[player]>

        #- foreach <server.list_online_players_flagged[ManaRegen]> as:player:
        #    - if <yaml[<[player].uuid>].read[buffs].contains[mana]>:
        #        - yaml set "buffs.Mana:+:<yaml[<[player].uuid>].read[buffs.mana]./[100].*[<[player].flag[ManaRegen]>]>"

        - foreach <server.list_online_players_flagged[RegenAura]> as:player:
            - foreach <[player].location.find.players.within[10]> as:target:
                - heal <[target].health.max./[100].*[<[player].flag[Regen]>]> <[target]>
                #- if <yaml[<[target].uuid>].read[buffs].contains[Mana]>:
                #    - yaml id:<[target].uuid> set "buffs.Mana:+:<yaml[<[target].uuid>].read[buffs.mana]./[100].*[<[player].flag[Regen]>]>"

        - foreach <server.list_online_players_flagged[HpRegenAura]> as:player:
            - foreach <[player].location.find.players.within[10]> as:target:
                - heal <[target].health.max./[100].*[<[player].flag[Regen]>]> <[target]>

        - foreach <server.list_online_players_flagged[ManaRegenAura]> as:player:
            - define mod:<[player].flag[ManaRegen]>
            - foreach <[player].location.find.players.within[10]> as:target:
                #- if <yaml[<[target].uuid>].read[buffs].contains[mana]>:
                #    - yaml set "buffs.Mana:+:<yaml[<[target].uuid>].read[buffs.mana]./[100].*[<[mod]>]>"
        #- narrate <queue.time_ran>

        on player kills entity:
        - if !<yaml[spawned_entities].list_keys[].contains[<context.entity>]>:
            - define class:<yaml[<player.uuid>].read[classes.class]>
            - define subclass:<yaml[<player.uuid>].read[classes.subclass]>
            - define race:<yaml[<player.uuid>].read[races.race]>
            - define subrace:<yaml[<player.uuid>].read[races.subrace]>

            - if <[class]> != Default:
                - yaml id:<player.uuid> set classes.xp:+:<element[10].+[<yaml[<player.uuid>].read[classes.level]>]>
                - if <yaml[<player.uuid>].read[classes.xp]> >= <element[10000].*[<yaml[<player.uuid>].read[classes.level]>]>:
                    - run instantly function_ClassLevel
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
            - if <[subclass]> != Default:
                - yaml id:<player.uuid> set classes.subxp:+:<element[5].+[<yaml[<player.uuid>].read[classes.level]>]>
                - if <yaml[<player.uuid>].read[classes.subxp]> >= <element[10000].*[<yaml[<player.uuid>].read[classes.sublevel]>]>:
                    - run instantly function_SubclassLevel
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
            - if <[race]> != Default:
                - yaml id:<player.uuid> set races.xp:+:<element[10].+[<yaml[<player.uuid>].read[races.level]>]>
                - if <yaml[<player.uuid>].read[races.xp]> >= <element[10000].*[<yaml[<player.uuid>].read[races.level]>]>:
                    - run instantly function_RaceLevel
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
            - if <[subrace]> != Default:
                - yaml id:<player.uuid> set races.subxp:+:<element[5].+[<yaml[<player.uuid>].read[races.level]>]>
                - if <yaml[<player.uuid>].read[races.subxp]> >= <element[10000].*[<yaml[<player.uuid>].read[races.sublevel]>]>:
                    - run instantly function_SubraceLevel
                    - yaml id:<player.uuid> savefile:../dData/players/<player.uuid>.yml
        #- narrate "<queue.time_ran>"


handler_Saving:
    type: world
    events:
        on delta time secondly every:300:
        - foreach <server.list_online_players> as:player:
            - define location:<[player].location>
            - define last_location:<[player].flag[last_location]||<[location]>>
            - flag <[player]> last_location:<[location]>
            - if <yaml[<[player].uuid>].read[races.race]> != Default && <yaml[<[player].uuid>].read[races.subrace]> != Default:
                - if <[location].distance_squared[<[last_location]>]> >= 400:
                    - yaml id:<[player].uuid> set races.xp:+:<element[50].+[<yaml[<[player].uuid>].read[races.level]>]>
                    - if <yaml[<[player].uuid>].read[races.xp]> >= <element[10000].*[<yaml[<[player].uuid>].read[races.level]>]>:
                        - run instantly function_RaceLevel player:<[player]>
                    - yaml id:<[player].uuid> set races.subxp:+:<element[25].+[<yaml[<[player].uuid>].read[races.level]>]>
                    - if <yaml[<[player].uuid>].read[races.subxp]> >= <element[10000].*[<yaml[<[player].uuid>].read[races.sublevel]>]>:
                        - run instantly function_SubraceLevel player:<[player]>
            - yaml id:<[player].uuid> savefile:../dData/players/<[player].uuid>.yml


handler_Entities:
    type: world
    events:
        on server start:
        - yaml id:spawned_entities create

        on spawner spawns entity:
        - yaml id:spawned_entities set <context.entity>:true

        on entity death priority:-1:
        - if <yaml[spawned_entities].list_keys[].contains[<context.entity>]||false>:
            - yaml id:spawned_entities set <context.entity>:!

        on delta time secondly every:60:
        - foreach <yaml[spawned_entities].list_keys[]||null> as:entity:
            - if !<server.entity_is_spawned[<[entity]>]>:
                - yaml id:spawned_entities set <[entity]>:!
#handler_abilities:
#   type: world
#   events:
#       on player right clicks block:
#       - define target:<player.target>
#       - define is_spawned:<player.target.mcmmo.is_spawned_mob>
#
#        - if <yaml[<player.uuid>].read[classes.subclass]||Default> != Default:
#            - if li@sword|axe contains <player.item_in_hand.material.name.after_last[_]>:
#                - define abilities:<yaml[<player.uuid>].read[classes.abilities]>
#                - flag player ability:++
#                - if <player.flag[ability]> > 1:
#                    - flag player ability:0
#                - define curr_ability <[abilities].get[<player.flag[ability]>]>
#                - if "<player.has_flag[cooldown_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>]>":
#                    - actionbar "<&e><&l>-= <&c><&l><[curr_ability]> <&e><&l>=-"
#                - else:
#                    - actionbar "<&e><&l>-= <&a><&l><[curr_ability]> <&e><&l>=-"

#            - if <player.flag[ability]> > 0 && <yaml[<player.uuid>].read[classes.class]> == Archer && "!<player.has_flag[cooldown_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>]>":
#                    - run instantly "ability_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>"
#                    #- yaml set "classes.subxp:+:<element[5].*[<player.flag[ability]>]>" id:<player.uuid>
#                    - flag player ability:0

#        on player left clicks block:
#        - if <yaml[<player.uuid>].read[classes.subclass]||Default> != Default:
#            - if <player.item_in_hand.material.name> == bow && <yaml[<player.uuid>].read[classes.class]> == archer:
#                - define abilities:<yaml[<player.uuid>].read[classes.abilities]>
#                - flag player ability:++
#                - if <player.flag[ability]> > 1:
#                    - flag player ability:0
#                - define curr_ability <[abilities].get[<player.flag[ability]>]>
#                - if "<player.has_flag[cooldown_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>]>":
#                    - actionbar "<&e><&l>-= <&c><&l><[curr_ability]> <&e><&l>=-"
#                - else:
#                    - actionbar "<&e><&l>-= <&a><&l><[curr_ability]> <&e><&l>=-"
            #- if <yaml[<player.uuid>].read[subclass_xp]> >= <el@10000.*[<yaml[<player.uuid>].read[class_level]>]>:
                #- run classes_SubLevel

#            - if <player.flag[ability]> > 0 && <yaml[<player.uuid>].read[classes.class]> != archer:
#                - define "curr_ability:<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>"
#                - if <yaml[<player.uuid>].read[buffs.Mana]||null> != null && <yaml[<player.uuid>].read[buffs.Mana]||0> >= <yaml[<[curr_ability]>].read[mana]||1>:
#                    - run instantly "ability_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>"
#                - else if "!<player.has_flag[cooldown_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>]>":
#                    - run instantly "ability_<yaml[<player.uuid>].read[classes.abilities].as_list.get[<player.flag[ability]>].replace[ ].with[]>"
#                #- yaml set "classes.subxp:+:<element[5].*[<player.flag[ability]>]>" id:<player.uuid>
#                - flag player ability:0


# - FUNCTIONS
function_ResetPlayer:
    type: task
    script:
        - foreach <yaml[<player.uuid>].list_keys[buffs]||null> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.-[<[player_val]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.-[<[player_val]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.-[<[player_val]>]>
                - case Hover:
                    - flag player Hover:!
                - case Regen:
                    - flag player Regen:!
                - case HpRegen:
                    - flag player HpRegen:!
                - case ManaRegen:
                    - flag player ManaRegen:!
                - case RegenAura:
                    - flag player RegenAura:!
                - case HpRegenAura:
                    - flag player HpRegenAura:!
                - case ManaRegenAura:
                    - flag player ManaRegenAura:!
        - yaml id:<player.uuid> set buffs:!
        - if <yaml[<player.uuid>].read[races.race]> != Default:
            - run instantly function_UpdateRaceBuffs
        - if <yaml[<player.uuid>].read[races.subrace]> != Default:
            - run instantly function_UpdateSubraceBuffs
        - if <yaml[<player.uuid>].read[classes.class]> != Default:
            - run instantly function_UpdateClassBuffs
        - if <yaml[<player.uuid>].read[classes.subclass]> != Default:
            - run instantly function_UpdateSubclassBuffs

function_ResetRace:
    type: task
    script:
        - if <yaml[<player.uuid>].read[races.race]> != Default:
            - run instantly function_ClearRaceBuffs
            - run instantly function_UpdateRaceBuffs
        - if <yaml[<player.uuid>].read[races.subrace]> != Default:
            - run instantly function_ClearSubraceBuffs
            - run instantly function_UpdateSubraceBuffs


function_ResetClass:
    type: task
    script:
        - if <yaml[<player.uuid>].read[classes.class]> != Default:
            - run instantly function_ClearClassBuffs
            - run instantly function_UpdateClassBuffs
        - if <yaml[<player.uuid>].read[classes.subclass]> != Default:
            - run instantly function_ClearSubclassBuffs
            - run instantly function_UpdateSubclassBuffs

function_ClearRaceBuffs:
    type: task
    script:
        - define race:<yaml[<player.uuid>].read[races.race]>
        - define level:<yaml[<player.uuid>].read[races.level]||1>
        - define race_buffs:<yaml[race_config].list_keys[<[race]>.buffs]>
        - foreach <[race_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[race_config].read[<[race]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.-[<[config_val].*[<[level]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.-[<[config_val].*[<[level]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.-[<[config_val].*[<[level]>]>]>
                - case Hover:
                    - flag player Hover:!
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:!
                - case Regen:
                    - if <[buff]> == 0:
                        - flag player Regen:!
                    - else:
                        - flag player Regen:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case HpRegen:
                    - if <[buff]> == 0:
                        - flag player HpRegen:!
                    - else:
                        - flag player HpRegen:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case ManaRegen:
                    - if <[buff]> == 0:
                        - flag player ManaRegen:!
                    - else:
                        - flag player ManaRegen:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case RegenAura:
                    - if <[buff]> == 0:
                        - flag player RegenAura:!
                    - else:
                        - flag player RegenAura:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case HpRegenAura:
                    - if <[buff]> == 0:
                        - flag player HpRegenAura:!
                    - else:
                        - flag player HpRegenAura:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case ManaRegenAura:
                    - if <[buff]> == 0:
                        - flag player ManaRegenAura:!
                    - else:
                        - flag player ManaRegenAura:<[player_val].-[<[config_val].*[<[level]>]>]>
            - if <[player_val].-[<[config_val].*[<[level]>]>]> == 0:
                - yaml id:<player.uuid> set buffs.<[buff]>:!
            - else:
                - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].-[<[config_val].*[<[level]>]>]>

function_ClearSubraceBuffs:
    type: task
    script:
        - define race:<yaml[<player.uuid>].read[races.race]>
        - define subrace:<yaml[<player.uuid>].read[races.subrace]>
        - define sublevel:<yaml[<player.uuid>].read[races.sublevel]||1>
        - define subrace_buffs:<yaml[race_config].list_keys[<[race]>.subraces.<[subrace]>.buffs]>
        - foreach <[subrace_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[race_config].read[<[race]>.subraces.<[subrace]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.-[<[config_val].*[<[sublevel]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.-[<[config_val].*[<[sublevel]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.-[<[config_val].*[<[sublevel]>]>]>
                - case Hover:
                    - flag player Hover:!
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:!
                - case Regen:
                    - if <[buff]> == 0:
                        - flag player Regen:!
                    - else:
                        - flag player Regen:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case HpRegen:
                    - if <[buff]> == 0:
                        - flag player HpRegen:!
                    - else:
                        - flag player HpRegen:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegen:
                    - if <[buff]> == 0:
                        - flag player ManaRegen:!
                    - else:
                        - flag player ManaRegen:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case RegenAura:
                    - if <[buff]> == 0:
                        - flag player RegenAura:!
                    - else:
                        - flag player RegenAura:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case HpRegenAura:
                    - if <[buff]> == 0:
                        - flag player HpRegenAura:!
                    - else:
                        - flag player HpRegenAura:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegenAura:
                    - if <[buff]> == 0:
                        - flag player ManaRegenAura:!
                    - else:
                        - flag player ManaRegenAura:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
            - if <[player_val].-[<[config_val].*[<[sublevel]>]>]> == 0:
                - yaml id:<player.uuid> set buffs.<[buff]>:!
            - else:
                - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].-[<[config_val].*[<[sublevel]>]>]>

function_UpdateRaceBuffs:
    type: task
    script:
        - define race:<yaml[<player.uuid>].read[races.race]>
        - define level:<yaml[<player.uuid>].read[races.level]||1>
        - define race_buffs:<yaml[race_config].list_keys[<[race]>.buffs]>
        - foreach <[race_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[race_config].read[<[race]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val].*[<[level]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val].*[<[level]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val].*[<[level]>]>]>
                - case Hover:
                    - flag player Hover:1
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:1
                - case Regen:
                    - flag player Regen:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case HpRegen:
                    - flag player HpRegen:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case ManaRegen:
                    - flag player ManaRegen:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case RegenAura:
                    - flag player RegenAura:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case HpRegenAura:
                    - flag player HpRegenAura:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case ManaRegenAura:
                    - flag player ManaRegenAura:<[player_val].+[<[config_val].*[<[level]>]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val].*[<[level]>]>]>

function_UpdateSubraceBuffs:
    type: task
    script:
        - define race:<yaml[<player.uuid>].read[races.race]>
        - define subrace:<yaml[<player.uuid>].read[races.subrace]>
        - define sublevel:<yaml[<player.uuid>].read[races.sublevel]||1>
        - define subrace_buffs:<yaml[race_config].list_keys[<[race]>.subraces.<[subrace]>.buffs]>
        - foreach <[subrace_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[race_config].read[<[race]>.subraces.<[subrace]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val].*[<[sublevel]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val].*[<[sublevel]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val].*[<[sublevel]>]>]>
                - case Hover:
                    - flag player Hover:1
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:1
                - case Regen:
                    - flag player Regen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegen:
                    - flag player HpRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegen:
                    - flag player ManaRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case RegenAura:
                    - flag player RegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegenAura:
                    - flag player HpRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegenAura:
                    - flag player ManaRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val].*[<[sublevel]>]>]>

function_ClearClassBuffs:
    type: task
    script:
        - define class:<yaml[<player.uuid>].read[classes.class]>
        - define level:<yaml[<player.uuid>].read[classes.level]||1>
        - define class_buffs:<yaml[class_config].list_keys[<[class]>.buffs]>
        - foreach <[class_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[class_config].read[<[class]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.-[<[config_val].*[<[level]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.-[<[config_val].*[<[level]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.-[<[config_val].*[<[level]>]>]>
                - case Hover:
                    - flag player Hover:!
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:!
                - case Regen:
                    - if <[buff]> == 0:
                        - flag player Regen:!
                    - else:
                        - flag player Regen:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case HpRegen:
                    - if <[buff]> == 0:
                        - flag player HpRegen:!
                    - else:
                        - flag player HpRegen:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case ManaRegen:
                    - if <[buff]> == 0:
                        - flag player ManaRegen:!
                    - else:
                        - flag player ManaRegen:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case RegenAura:
                    - if <[buff]> == 0:
                        - flag player RegenAura:!
                    - else:
                        - flag player RegenAura:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case HpRegenAura:
                    - if <[buff]> == 0:
                        - flag player HpRegenAura:!
                    - else:
                        - flag player HpRegenAura:<[player_val].-[<[config_val].*[<[level]>]>]>
                - case ManaRegenAura:
                    - if <[buff]> == 0:
                        - flag player ManaRegenAura:!
                    - else:
                        - flag player ManaRegenAura:<[player_val].-[<[config_val].*[<[level]>]>]>
            - if <[player_val].-[<[config_val].*[<[level]>]>]> == 0:
                - yaml id:<player.uuid> set buffs.<[buff]>:!
            - else:
                - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].-[<[config_val].*[<[level]>]>]>

function_ClearSubclassBuffs:
    type: task
    script:
        - define class:<yaml[<player.uuid>].read[classes.class]>
        - define subclass:<yaml[<player.uuid>].read[classes.subclass]>
        - define sublevel:<yaml[<player.uuid>].read[classes.sublevel]||1>
        - define subclass_buffs:<yaml[class_config].list_keys[<[class]>.subclasses.<[subclass]>.buffs]>
        - foreach <[subclass_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[class_config].read[<[class]>.subclasses.<[subclass]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.-[<[config_val].*[<[sublevel]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.-[<[config_val].*[<[sublevel]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.-[<[config_val].*[<[sublevel]>]>]>
                - case Hover:
                    - flag player Hover:!
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:!
                - case Regen:
                    - if <[buff]> == 0:
                        - flag player Regen:!
                    - else:
                        - flag player Regen:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case HpRegen:
                    - if <[buff]> == 0:
                        - flag player HpRegen:!
                    - else:
                        - flag player HpRegen:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegen:
                    - if <[buff]> == 0:
                        - flag player ManaRegen:!
                    - else:
                        - flag player ManaRegen:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case RegenAura:
                    - if <[buff]> == 0:
                        - flag player RegenAura:!
                    - else:
                        - flag player RegenAura:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case HpRegenAura:
                    - if <[buff]> == 0:
                        - flag player HpRegenAura:!
                    - else:
                        - flag player HpRegenAura:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegenAura:
                    - if <[buff]> == 0:
                        - flag player ManaRegenAura:!
                    - else:
                        - flag player ManaRegenAura:<[player_val].-[<[config_val].*[<[sublevel]>]>]>
            - if <[player_val].-[<[config_val].*[<[sublevel]>]>]> == 0:
                - yaml id:<player.uuid> set buffs.<[buff]>:!
            - else:
                - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].-[<[config_val].*[<[sublevel]>]>]>

function_UpdateClassBuffs:
    type: task
    script:
        - define class:<yaml[<player.uuid>].read[classes.class]>
        - define level:<yaml[<player.uuid>].read[classes.level]||1>
        - define class_buffs:<yaml[class_config].list_keys[<[class]>.buffs]>
        - foreach <[class_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[class_config].read[<[class]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val].*[<[level]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val].*[<[level]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val].*[<[level]>]>]>
                - case Hover:
                    - flag player Hover:1
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:1
                - case Regen:
                    - flag player Regen:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case HpRegen:
                    - flag player HpRegen:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case ManaRegen:
                    - flag player ManaRegen:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case RegenAura:
                    - flag player RegenAura:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case HpRegenAura:
                    - flag player HpRegenAura:<[player_val].+[<[config_val].*[<[level]>]>]>
                - case ManaRegenAura:
                    - flag player ManaRegenAura:<[player_val].+[<[config_val].*[<[level]>]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val].*[<[level]>]>]>

function_UpdateSubclassBuffs:
    type: task
    script:
        - define class:<yaml[<player.uuid>].read[classes.class]>
        - define subclass:<yaml[<player.uuid>].read[classes.subclass]>
        - define sublevel:<yaml[<player.uuid>].read[classes.sublevel]||1>
        - define subclass_buffs:<yaml[class_config].list_keys[<[class]>.subclasses.<[subclass]>.buffs]>
        - foreach <[subclass_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[class_config].read[<[class]>.subclasses.<[subclass]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val].*[<[sublevel]>]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val].*[<[sublevel]>]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val].*[<[sublevel]>]>]>
                - case Hover:
                    - flag player Hover:1
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:1
                - case Regen:
                    - flag player Regen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegen:
                    - flag player HpRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegen:
                    - flag player ManaRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case RegenAura:
                    - flag player RegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegenAura:
                    - flag player HpRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegenAura:
                    - flag player ManaRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val].*[<[sublevel]>]>]>

function_RaceLevel:
    type: task
    script:
        - define race:<yaml[<player.uuid>].read[races.race]>
        - define level:<yaml[<player.uuid>].read[races.level].+[1]||1>
        - define race_buffs:<yaml[race_config].list_keys[<[race]>.buffs]>
        - foreach <[race_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[race_config].read[<[race]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val]>]>
                - case Hover:
                    - flag player Hover:1
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:1
                - case Regen:
                    - flag player Regen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegen:
                    - flag player HpRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegen:
                    - flag player ManaRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case RegenAura:
                    - flag player RegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegenAura:
                    - flag player HpRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegenAura:
                    - flag player ManaRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val]>]>
            - yaml id:<player.uuid> set races.level:<[level]>

function_SubraceLevel:
    type: task
    script:
        - define race:<yaml[<player.uuid>].read[races.race]>
        - define subrace:<yaml[<player.uuid>].read[races.subrace]>
        - define sublevel:<yaml[<player.uuid>].read[races.sublevel].+[1]||1>
        - define race_buffs:<yaml[race_config].list_keys[<[race]>.subraces.<[subrace]>.buffs]>
        - foreach <[race_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[race_config].read[<[race]>.subraces.<[subrace]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val]>]>
                - case Hover:
                    - flag player Hover:1
                - case UnderwaterBreathing:
                    - flag player UnderwaterBreathing:1
                - case Regen:
                    - flag player Regen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegen:
                    - flag player HpRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegen:
                    - flag player ManaRegen:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case RegenAura:
                    - flag player RegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case HpRegenAura:
                    - flag player HpRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
                - case ManaRegenAura:
                    - flag player ManaRegenAura:<[player_val].+[<[config_val].*[<[sublevel]>]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val]>]>
            - yaml id:<player.uuid> set races.sublevel:<[sublevel]>

function_ClassLevel:
    type: task
    script:
        - define class:<yaml[<player.uuid>].read[classes.class]>
        - define level:<yaml[<player.uuid>].read[classes.level].+[1]||1>
        - define class_buffs:<yaml[class_config].list_keys[<[class]>.buffs]>
        - foreach <[class_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[class_config].read[<[class]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val]>]>
            - yaml id:<player.uuid> set classes.level:<[level]>

function_SubclassLevel:
    type: task
    script:
        - define class:<yaml[<player.uuid>].read[classes.class]>
        - define subclass:<yaml[<player.uuid>].read[classes.subclass]>
        - define sublevel:<yaml[<player.uuid>].read[classes.sublevel].+[1]||1>
        - define class_buffs:<yaml[class_config].list_keys[<[class]>.subclasses.<[subclass]>.buffs]>
        - foreach <[class_buffs]> as:buff:
            - define player_val:<yaml[<player.uuid>].read[buffs.<[buff]>]||0>
            - define config_val:<yaml[class_config].read[<[class]>.subclasses.<[subclass]>.buffs.<[buff]>]>
            - choose <[buff]>:
                - case Health:
                    - adjust <player> max_health:<player.health.max.+[<[config_val]>]>
                - case Armor:
                    - adjust <player> armor_bonus:<player.armor_bonus.+[<[config_val]>]>
                - case Speed:
                    - adjust <player> walk_speed:<player.walk_speed.+[<[config_val]>]>
            - yaml id:<player.uuid> set buffs.<[buff]>:<[player_val].+[<[config_val]>]>
            - yaml id:<player.uuid> set classes.sublevel:<[sublevel]>


# - DATA
player_data:
    type: yaml data
    races:
        race: Default
        subrace: Default
        last_race: Defaultt
        last_subrace: Default
        level: 1
        sublevel: 1
        xp: 0
        subxp: 0
    classes:
        class: Default
        subclass: Default
        last_class: Default
        last_subclass: Default
        level: 1
        sublevel: 1
        xp: 0
        subxp: 0
    buffs:
        None: 0


# - CONFIG
race_config:
    type: yaml data
    Human:
        buffs:
            Health: 0.125
            Damage: 0.125
        subraces:
            Man:
                buffs:
                    Health: 0.125
                    Damage: 0.125
            Dwarf:
                buffs:
                    Health: 0.125
                    Armor: 0.125
            Undead:
                buffs:
                    MagicDamage: 0.25
                    UnderwaterBreathing: 1
    Orc:
        buffs:
            AxeDamage: 0.125
            Armor: 0.125
        subraces:
            Warorc:
                buffs:
                    AxeDamage: 0.125
                    Health: 0.125
            Goblin:
                buffs:
                    Backstab: 1
                    Critical: 0.25
            Ogre:
                buffs:
                    Health: 0.125
                    Armor: 0.125
    Elf:
        buffs:
            SwordDamage: 0.25
            Dodge: 0.125
        subraces:
            Highelf:
                buffs:
                    MagicDamage: 0.25
                    Regen: 0.125
            Surfaceelf:
                buffs:
                    BowDamage: 0.5
                    Speed: 0.0025
            Darkelf:
                buffs:
                    SwordDamage: 0.125
                    Dodge: 0.25
    Beast:
        buffs:
            Damage: 0.125
            Speed: 0.0025
        subraces:
            Centaur:
                buffs:
                    BowDamage: 0.125
                    Speed: 0.0025
            Harpy:
                buffs:
                    Hover: 1
                    Speed: 0.0025
            Gorgon:
                buffs:
                    Armor: 0.125
                    Damage: 0.125


class_config:
    type: yaml data
    Warrior:
        buffs:
            AxeDamage: 0.125
            Armor: 0.125
        subclasses:
            Protector:
                buffs:
                    Health: 0.125
                    Damage: 0.125
                abilities:
                    - Saviour
            Paladin:
                buffs:
                    Regen: 0.125
                    RegenAura: 0.125
                abilities:
                    - Righteousness
            Champion:
                buffs:
                    AxeDamage: 0.125
                    Parry: 0.375
                abilities:
                    - Whirlwind
    Healer:
        buffs:
            HpRegen: 0.125
            Mana: 1.25
        subclasses:
            Priest:
                buffs:
                    ManaRegen: 0.125
                    Mana: 1.25
                abilities:
                    - Divine Protection
            Cleric:
                buffs:
                    HpRegen: 0.125
                    Mana: 1.25
                abilities:
                    - Prayer
            Necromancer:
                buffs:
                    Health: 0.125
                    Lifesteal: 0.0125
                abilities:
                    - Hunger for Darkness
    Rogue:
        buffs:
            SwordDamage: 0.25
            Dodge: 0.125
        subclasses:
            Thief:
                buffs:
                    Speed: 0.0025
                    Dodge: 0.25
                abilities:
                    - Sprint
            Cutthroat:
                buffs:
                    SwordDamage: 0.25
                    Parry: 0.25
                abilities:
                    - Blade Flurry
            Assassin:
                buffs:
                    Critical: 0.25
                    Backstab: 0.075
                abilities:
                    - Shade Step
    Archer:
        buffs:
            BowDamage: 0.5
            Speed: 0.0025
        subclasses:
            Marksman:
                buffs:
                    LongRangeDamage: 0.75
                    Speed: 0.0025
                abilities:
                    - Aimed Shot
            Trickster:
                buffs:
                    BowDamage: 0.5
                    Speed: 0.0025
                abilities:
                    - Ephemereal Arrow
            Hunter:
                buffs:
                    BowDamage: 0.5
                    Speed: 0.0025
                abilities:
                    - Call Pack
    Sorcerer:
        buffs:
            MagicDamage: 0.25
            Mana: 1.25
        subclasses:
            Mage:
                buffs:
                    MagicDamage: 0.25
                    Mana: 1.25
                abilities:
                    - Fireball
            Alchemist:
                buffs:
                    MagicDamage: 0.25
                    Speed: 0.0025
                abilities:
                    - Poison Cloud
            Spellsword:
                buffs:
                    SwordDamage: 0.25
                    Mana: 1.25
                abilities:
                    - Enchanted Armor