ProcedureTutorial:
  type: procedure 
  definitions: price|moneysign 
  script: 
  - if <player.money> < %price% determine false
  - if <player.health.percentage> > 80 determine false 
  - take money qty:%price% 
  - narrate "You lost %moneysign%%price%!" 
  - determine true
HasEnoughMana:
  type: procedure 
  definitions: player|amount
  script: 
  - ^if <player[%player%].flag[CurrentMana].asint> < %amount% {
      - ^determine false
    }
  - ^determine true
MobLevel:
  type: procedure 
  definitions: location
  script: 
  - ^define distanceNewDalantum <def[location].distance[<server.flag[ArathiaLocation]>]>
  - ^define distanceArathia <def[location].distance[<server.flag[NewDalantumLocation]>]>
  - ^if %distanceNewDalantum% < %distanceArathia% {
      - ^define lowest %distanceNewDalantum%
    }
  - ^if %distanceArathia% < %distanceNewDalantum% {
      - ^define lowest %distanceArathia%
    }
  - ^if <def[lowest].asint> < 150 {
      - ^determine 1
    }
  - ^if <def[lowest].asint> > 150 && <def[lowest].asint> < 300 {
      - ^determine 2
    }
  - ^if <def[lowest].asint> > 300 && <def[lowest].asint> < 450 {
      - ^determine 3
    }
  - ^if <def[lowest].asint> > 450 && <def[lowest].asint> < 600 {
      - ^determine 4
    }
  - ^if <def[lowest].asint> > 600 && <def[lowest].asint> < 750 {
      - ^determine 5
    }
  - ^if <def[lowest].asint> > 750 && <def[lowest].asint> < 900 {
      - ^determine 6
    }
  - ^if <def[lowest].asint> > 900 && <def[lowest].asint> < 1050 {
      - ^determine 7
    }
  - ^if <def[lowest].asint> > 1050 && <def[lowest].asint> < 1200 {
      - ^determine 8
    }
  - ^if <def[lowest].asint> > 1200 && <def[lowest].asint> < 1350 {
      - ^determine 9
    }
  - ^if <def[lowest].asint> > 1350 && <def[lowest].asint> < 1500 {
      - ^determine 10
    }
  - ^if <def[lowest].asint> > 1500 && <def[lowest].asint> < 1650 {
      - ^determine 11
    }
  - ^if <def[lowest].asint> > 1650 && <def[lowest].asint> < 1800 {
      - ^determine 12
    }
  - ^if <def[lowest].asint> > 1800 && <def[lowest].asint> < 1950 {
      - ^determine 13
    }
  - ^if <def[lowest].asint> > 1950 && <def[lowest].asint> < 2100 {
      - ^determine 14
    }
  - ^if <def[lowest].asint> > 2100 && <def[lowest].asint> < 2250 {
      - ^determine 15
    }
  - ^if <def[lowest].asint> > 2250 && <def[lowest].asint> < 2400 {
      - ^determine 16
    }
  - ^if <def[lowest].asint> > 2400 && <def[lowest].asint> < 2550 {
      - ^determine 17
    }
  - ^if <def[lowest].asint> > 2550 && <def[lowest].asint> < 2700 {
      - ^determine 18
    }
  - ^if <def[lowest].asint> > 2700 && <def[lowest].asint> < 2850 {
      - ^determine 19
    }
  - ^if <def[lowest].asint> > 3000 && <def[lowest].asint> < 3500 {
      - ^determine 20
    }
  - ^if <def[lowest].asint> > 3500 && <def[lowest].asint> < 4000 {
      - ^determine 21
    }
  - ^if <def[lowest].asint> > 4500 && <def[lowest].asint> < 5000 {
      - ^determine 22
    }
  - ^if <def[lowest].asint> > 5500 && <def[lowest].asint> < 6000 {
      - ^determine 23
    }
  - ^if <def[lowest].asint> > 6000 && <def[lowest].asint> < 6500 {
      - ^determine 24
    }
  - ^if <def[lowest].asint> > 6500 && <def[lowest].asint> < 7000 {
      - ^determine 26
    }
  - ^if <def[lowest].asint> > 7000 && <def[lowest].asint> < 7500 {
      - ^determine 27
    }
  - ^if <def[lowest].asint> > 7500 && <def[lowest].asint> < 10000 {
      - ^determine 28
    }
  - ^if <def[lowest].asint> > 10000 {
      - ^determine 29
    }
MaximumMana:
  type: procedure 
  definitions: level|intelligence|player
  script: 
  - ^inject AuraTicks def:%level%|%intelligene%|%player%
  - ^define LevelValue <def[level].mul[5]>
  - ^define IntellectValue <def[intelligence].mul[10]>
  - ^define total <def[IntellectValue].add[<def[LevelValue]>]>
  - ^determine %total%
ManaRegenerationRate:
  type: procedure
  definitions: level|intelligence|player
  script: 
  - ^define LevelValue <def[level].mul[0.025]>
  - ^define IntellectValue <def[intelligence].mul[0.1]>
  - ^define bonus <player[%player%].flag[Spellhaste]>
  - ^if %bonus% == null {
       - ^define bonus 0
     } else {
       - ^playeffect <player[%player%].location> effect:enchantment_table qty:50
     }
  - ^define total <def[IntellectValue].add[<def[LevelValue]>].add[<def[bonus]>]>
  - ^determine %total%
CanUserLevelUp:
  type: procedure
  definitions: level|player
  script: 
  - ^if <player[%player%].flag[Exp].asint> > > <proc[ToNextLevel].context[<def[level]>]> {
      - ^determine true
    }
  - ^determine false
ToNextLevel:
  type: procedure
  definitions: level
  script: 
  - ^define base 3
  - ^define minimum 10
  - ^determine <def[minimum].add[<def[base].power[<def[level]>]>]>
SinceLastLevel:
  type: procedure
  definitions: level
  script: 
  - ^if <def[level]> == 1 {
      - ^determine 0
    }
  - ^determine <proc[ToNextLevel].context[<def[level].sub[1]>]>
ArmorBonus:
  type: procedure
  definitions: player|level
  script: 
  - ^if <player.equipment.helmet> == null {
      - ^define babHelmet 0.0
      - ^define tier 0
     }
  - ^if <player.equipment.chestplate> == null {
      - ^define babChestplate 0.0
     }
  - ^if <player.equipment.leggings> == null {
      - ^define babLeggings 0.0
     }
  - ^if <player.equipment.boots> == null {
      - ^define babBoots 0.0
     }
  - ^if <player.equipment.helmet.material> == m@iron_helmet {
       - ^define babHelmet 1.75
     }
  - ^if <player.equipment.chestplate.material> == m@iron_chestplate {
       - ^define babChestplate 1.75
     }
  - ^if <player.equipment.leggings.material> == m@iron_leggings {
       - ^define babChestplate 1.75
     }
  - ^if <player.equipment.Boots.material> == m@iron_boots {
       - ^define babBoots 1.75
     }
  - ^if <player.equipment.helmet.material> == m@leather_helmet {
       - ^define babHelmet 1.0
     }
  - ^if <player.equipment.chestplate.material> == m@leather_chestplate {
       - ^define babChestplate 1.0
     }
  - ^if <player.equipment.leggings.material> == m@leather_leggings {
       - ^define babChestplate 1.0
     }
  - ^if <player.equipment.Boots.material> == m@leather_boots {
       - ^define babBoots 1.0
     }
  - ^if <player.equipment.helmet.material> == m@diamond_helmet {
       - ^define babHelmet 2.0
     }
  - ^if <player.equipment.chestplate.material> == m@diamond_chestplate {
       - ^define babChestplate 2.0
     }
  - ^if <player.equipment.leggings.material> == m@diamond_leggings {
       - ^define babChestplate 2.0
     }
  - ^if <player.equipment.Boots.material> == m@diamond_boots {
       - ^define babBoots 2.0
     }
  - ^if !<player.equipment.helmet.lore.get[3]> == null {
       - ^define tier 1
     } else if <player.equipment.leggings.lore.get[3]> contains Tier {
       - ^define tier <player.item_in_hand.lore.get[3].substring[5]>
     }
  - ^if !<player.equipment.chestplate.lore.get[3]> == null {
       - ^define tier 1
     } else if <player.equipment.leggings.lore.get[3]> contains Tier {
       - ^define tier <player.item_in_hand.lore.get[3].substring[5]>
     }
  - ^if !<player.equipment.leggings.lore.get[3]> == null {
       - ^define tier 1
     } else if <player.equipment.leggings.lore.get[3]> contains Tier {
       - ^define tier <player.item_in_hand.lore.get[3].substring[5]>
     }
  - ^if !<player.equipment.boots.lore.get[3]> == null {
       - ^define tier 1
     } else if <player.equipment.leggings.lore.get[3]> contains Tier {
       - ^define tier <player.item_in_hand.lore.get[3].substring[5]>
     }
ValidateScoreboard:
  type: procedure 
  definitions: player
  script:
    - define next <proc[ToNextLevel].context[<player[%player%].flag[Level].asint>]>
    - ^scoreboard viewers:%player% lines:Level id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player[%player%].flag[Level].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% lines:Experience id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player.flag[Exp].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% lines:Strength id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player[%player%].flag[Strength].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% lines:Intelligence id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player[%player%].flag[Intelligence].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% lines:Dexterity id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player[%player%].flag[Dexterity].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% lines:Vitality id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player[%player%].flag[Vitality].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% lines:Next id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<def[Next].asint> displayslot:sidebar
    - ^scoreboard viewers:%player% "lines:Attribute Points" id:PlayerDisplay%player% "objective:Skill Stats" criteria:dummy score:<player[%player%].flag[AttributePoints].asint> displayslot:sidebar
    - ^scoreboard remove "lines:Level" id:PlayerDisplay%player% "objective:Level" criteria:dummy score:<player[%player%].flag[Level].asint> displayslot:PLAYER_LIST
RegenerateManaLoop:
    type: task
    script:
    - ^wait 1
    - ^foreach <server.list_online_players> {
            - define player %value%
            - ^if <player[%player%].flag[Intelligence]> == null || <player[%player%].flag[Intelligence]> == 0 {
                 - ^flag player player:%player% Intelligence:5
                 - ^flag player player:%player% Dexterity:5
                 - ^flag player player:%player% Vitality:5
                 - ^flag player player:%player% Strength:5
               }
            - ^if <player[%player%].flag[CurrentMana]> == null {
                 - ^flag player player:%player% CurrentMana:0
               }
            - ^if <player[%player%].flag[Level]> == null {
                 - flag player player:%player% Level:0
               }
            - ^if <server.flag[<player[%player%].flag[EquippedAbility]>IsAura]> {
                 - ^if <player[%player%].flag[EquippedAbility]> == Zealotry {
                      - ^define sum <player[%player%].flag[Strength].add[%level%]>
                      - ^define abilityRange <def[sum].div[2].asint>
                      - ^define abilityPower <def[sum].div[20].asint>
                      - ^define targets <player[%player%].location.find.players.within[<def[abilityRange].asint>]>
                      - ^foreach %targets% {
                             - ^playeffect <def[value].location> effect:SPELL qty:50 data:1
                         }
                      - ^potion speed duration:3s power:%abilityPower% %targets%
                      - ^define manacostBase 15
                      - ^define totalManaCost <def[manacostBase].add[<player[%player%].flag[Level].div[2].asint>].sub[<player[%player%].flag[Strength].div[2].asint>]>
                      - ^flag player player:%player% CurrentMana:<player[%player%].flag[CurrentMana].sub[%totalManaCost%]>
                      - ^if <player[%player%].flag[CurrentMana]> < 0 {
                           - ^flag player player:%player% EquippedAbility:!
                           - ^flag player player:%player% CurrentMana:0
                           - ^narrate "Your ability was automatically unequipped because you ran out of mana." t:%player%
                         }
                    }
                 - ^if <player[%player%].flag[EquippedAbility]> == Vengeance {
                      - ^define sum <player[%player%].flag[Strength].add[%level%]>
                      - ^define abilityRange <def[sum].div[2].asint>
                      - ^define abilityPower <def[sum].div[2].asint>
                      - ^define targets <player[%player%].location.find.players.within[<def[abilityRange].asint>]>
                      - ^foreach %targets% {
                             - ^playeffect <def[value].location> effect:RED_DUST qty:50
                         }
                      - ^define manacostBase 30
                      - ^define totalManaCost <def[manacostBase].add[<player[%player%].flag[Level].asint>].sub[<player[%player%].flag[Strength].asint>]>
                      - ^flag player player:%player% CurrentMana:<player[%player%].flag[CurrentMana].sub[%totalManaCost%]>
                      - ^if <player[%player%].flag[CurrentMana]> < 0 {
                           - ^flag player player:%player% EquippedAbility:!
                           - ^flag player player:%player% CurrentMana:0
                         }
                    }
                 - ^if <player[%player%].flag[EquippedAbility]> == HolyFire {
                      - ^define sum <player[%player%].flag[Strength].add[%level%]>
                      - ^define abilityRange <def[sum].div[0.25].asint>
                      - ^define abilityPower <def[sum].div[2].asint>
                      - ^define targets <player[%player%].location.find.entities[ZOMBIE|SPIDER|SKELETON|CREEPER|CAVE_SPIDER].within[<def[abilityRange].asint>]>
                      - ^foreach %targets% {
                             - ^playeffect <def[value].location> effect:MOBSPAWNER_FLAMES qty:500
                             - ^playeffect <def[value].location> effect:EXTINGUISH qty:1
                             - ^burn <def[value]> duration:2s
                             - ^hurt %abilityPower% <def[value]>
                         }
                      - ^define manacostBase 45
                      - ^define totalManaCost 45
                      - ^flag player player:%player% CurrentMana:<player[%player%].flag[CurrentMana].sub[%totalManaCost%]>
                      - ^if <player[%player%].flag[CurrentMana]> < 0 {
                           - ^flag player player:%player% EquippedAbility:!
                           - ^flag player player:%player% CurrentMana:0
                           - ^narrate "Your ability was automatically unequipped because you ran out of mana." t:%player%
                         }
                    }
                 - ^if <player[%player%].flag[EquippedAbility]> == Fanaticism {
                      - ^define sum <player[%player%].flag[Strength].add[%level%]>
                      - ^define abilityRange <def[sum].div[0.25].asint>
                      - ^define abilityPower <def[sum].div[5].asint>
                      - ^define targets <player[%player%].location.find.players.within[<def[abilityRange].asint>]>
                      - ^foreach %targets% {
                             - ^playeffect <def[value].location> effect:ANGRY_VILLAGER qty:5
                             - ^playeffect <def[value].location> effect:SPELL qty:50
                         }
                      - ^potion increase_damage duration:3s power:%abilityPower% %targets%
                      - ^define manacostBase 45
                      - ^define totalManaCost 45
                      - ^flag player player:%player% CurrentMana:<player[%player%].flag[CurrentMana].sub[%totalManaCost%]>
                      - ^if <player[%player%].flag[CurrentMana]> < 0 {
                           - ^flag player player:%player% EquippedAbility:!
                           - ^flag player player:%player% CurrentMana:0
                           - ^narrate "Your ability was automatically unequipped because you ran out of mana." t:%player%
                         }
                    }
                 - ^if <player[%player%].flag[EquippedAbility]> == FistOfTheHeavens {
                      - ^define sum <player[%player%].flag[Strength].add[%level%]>
                      - ^define abilityRange <def[sum].div[0.25].asint>
                      - ^define abilityPower <def[sum].div[2].asint>
                      - ^define targets <player[%player%].location.find.entities[ZOMBIE|SPIDER|SKELETON|CREEPER|CAVE_SPIDER].within[<def[abilityRange].asint>]>
                      - ^foreach %targets% {
                             - ^playeffect <def[value].location> effect:MOBSPAWNER_FLAMES qty:500
                             - ^playeffect <def[value].location> effect:EXTINGUISH qty:1
                             - ^burn <def[value]> duration:2s
                             - ^hurt %abilityPower% <def[value]>
                             - ^strike <def[value].location>
                         }
                      - ^define manacostBase 45
                      - ^define totalManaCost 45
                      - ^flag player player:%player% CurrentMana:<player[%player%].flag[CurrentMana].sub[%totalManaCost%]>
                      - ^if <player[%player%].flag[CurrentMana]> < 0 {
                           - ^flag player player:%player% EquippedAbility:!
                           - ^flag player player:%player% CurrentMana:0
                           - ^narrate "Your ability was automatically unequipped because you ran out of mana." t:%player%
                         }
                    }
               }

            - ^define MaxMana <proc[MaximumMana].context[<player[<def[player]>].flag[Level]>|<player[<def[player]>].flag[Intelligence]>|%player%]>
            - ^if <player[%player%].flag[CurrentMana]> < %MaxMana% {
                - ^flag player player:%player% CurrentMana:<player.flag[CurrentMana].add[<proc[ManaRegenerationRate].context[<player[%player%].flag[Level]>|<player[%player%].flag[Intelligence]>|%player%]>]>
               }
            - ^if <player[%player%].flag[CurrentMana]> > %MaxMana% {
                 - ^flag player player:%player% CurrentMana:%MaxMana%
               }
            - ^define Mana <player[%player%].flag[CurrentMana]>
            - ^define ManaPercentage <def[Mana].div[<def[MaxMana]>]>
            - ^define finalValue <def[ManaPercentage].mul[200]>
            - ^adjust %player% "show_boss_bar:<def[finalValue].asint>|<blue>Mana<&co> <player[%player%].flag[CurrentMana].asint>/<def[MaxMana].asint>"
      }
    - ^inject RegenerateManaLoop
LevelUp:
  type: task
  definitions: player
  script:
  - ^flag Level:++
  - ^narrate "<red>You leveled up! You are now level <player.flag[level].asint>"
  - ^narrate "<red>You need <proc[ToNextLevel].context[<player.flag[Level].asint>].asint> experience to level up again."
  - ^narrate "<green>You gained an attribute point! Spend it with /attributes spend"
  - ^if <player.flag[AttributePoints]> == null {
      - ^flag AttributePoints:0
    }
  - ^flag AttributePoints:++
  - ^firework location:<def[player].location> primary:random|random|random|random flicker trail
  - ^run CalculateHealthBonus def:%player%
  - ^heal 500 %player%
CalculateHealthBonus:
    type: task
    definitions: player
    script:
    - ^if <player.flag[Vitality]> == null {
        - flag Vitality:5
      }
    - ^if <player.flag[Vitality]> == 0 {
        - flag Vitality:5
      }
    - ^define potionEffectLevel <player.flag[Vitality].sub[5]>
    - ^if %potionEffectLevel% == 0 queue clear
    - ^potion health_boost duration:86400 power:<def[potionEffectLevel].asint> <def[player]>
CalculateDeathPenalty:
    type: task
    definitions: player
    script:
    - ^define previousLevel <proc[SinceLastLevel].context[<player[%player%].flag[Level].asint>]>
    - ^define nextLevel <proc[ToNextLevel].context[<player[%player%].flag[Level].asint>]>
    - ^define percentage <player[%player%].flag[Level].mul[5]>
    - ^if %percentage% >= 100 {
        - ^define percentage 100
      }
    - ^define percentage <def[percentage].div[100]>
    - ^define difference <player[%player%].flag[Exp].sub[%previousLevel%]>
    - ^define multipliedValue <def[difference].mul[<def[percentage]>]>
    - ^if <player.is_op> { 
        - ^narrate "Death experience penalty calculations"
        - ^narrate "Previous level %previousLevel%"
        - ^narrate "Next level %nextLevel%"
        - ^narrate "Percentage %percentage%"
        - ^narrate "Difference %difference%"
        - ^narrate "Multiplied Value %multipliedValue%"
      }
    - ^narrate "<red>You have died. You lost <def[multipliedValue].asint> experience."
    - ^define finalValue <player[%player%].flag[Exp].sub[%multipliedValue%]>
    - ^narrate "<red>Your current experience is <def[finalValue].asint>."
    - ^flag player player:%player% Exp:%finalValue%
    - ^run ValidateScoreboard def:%player%
'Attributes':
 type: world
 events:
   on resetplayer command:
   - if !<player.is_op> queue clear
   - determine passively fulfilled
   - narrate "<red>Resetting player flags for <context.args.get[1]>"
   - flag player player:<context.args.get[1]> Level:1
   - flag player player:<context.args.get[1]> Exp:0
   - flag player player:<context.args.get[1]> Intelligence:5
   - flag player player:<context.args.get[1]> Dexterity:5
   - flag player player:<context.args.get[1]> Strength:5
   - flag player player:<context.args.get[1]> Vitality:5
   - run ValidateScoreboard def:<context.args.get[1]>
   on attributes command:
   - determine passively fulfilled
   - if <context.args.get[1]> == null {
       - narrate "<red>Incorrect usage."
       - narrate "<red>Use /attributes (list, spend)"
       - queue clear
     }
   - if <context.args.get[1]> == list {
       - narrate "There are 4 attributes to choose from."
       - narrate "<red>Strength <reset>determines your ability to use all physical weapons."
       - narrate "It applies a percentage bonus of damage to the weapon you're using."
       - narrate "Strength may also alter the effectiveness of some abilities."
       - narrate "Strength does not increase damage for bows, wands or weapons marked <green>Agile."
       - narrate "<blue>Intelligence <reset>determines your ability to control the Maw."
       - narrate "It increases your mana and mana regeneration rate."
       - narrate "It also increases your damage with wands and"
       - narrate "may also alter the effectiveness of some abilities."
       - narrate "<green>Dexterity <reset>affects your effectiveness with ranged weapons."
       - narrate "It also increases your damage with any weapon marked Agile."
       - narrate "Dexterity will also sligtly increase your chance to crit."
       - narrate "Dexterity will increase the effectiveness of some abilities."
       - narrate "<dark_red>Vitality <reset>increases your maximum health."
       - narrate "Each point of Vitality will increase your maximum life by 2 hearts."
       - queue clear
     }
   - if <context.args.get[1]> == spend {
       - if <player.flag[AttributePoints]> == null || <player.flag[AttributePoints]> < 1 {
           - flag AttributePoints:0
           - narrate "<red>You don't have any attribute points! Level up to gain them."
           - queue clear
         }
       - if <context.args.get[2]> == null {
           - narrate "Specify an attribute to spend a point on!"
           - queue clear
         }
       - flag AttributePoints:--
       - if <context.args.get[2]> contains Str {
           - flag Strength:++
           - narrate "Increased <red>Strength <reset> by one point."
           - narrate "You now have <red><player.flag[Strength].asint> <reset>Strength."
           - run ValidateScoreboard def:p@<player.name>
           - run CalculateHealthBonus def:p@<player.name>
           - queue clear
         }
       - if <context.args.get[2]> contains Int {
           - flag Intelligence:++
           - narrate "Increased <blue>Intelligence <reset>by one point."
           - narrate "You now have <blue><player.flag[Intelligence].asint> <reset>Intelligence."
           - run ValidateScoreboard def:p@<player.name>
           - run CalculateHealthBonus def:p@<player.name>
           - queue clear
         }
       - if <context.args.get[2]> contains Dex {
           - flag Dexterity:++
           - narrate "Increased <green>Dexterity <reset>by one point."
           - narrate "You now have <green><player.flag[Dexterity].asint> <reset>Dexterity."
           - run ValidateScoreboard def:p@<player.name>
           - run CalculateHealthBonus def:p@<player.name>
           - queue clear
         }
       - if <context.args.get[2]> contains Vit {
           - flag Vitality:++
           - narrate "Increased <dark_red>Vitality by one point."
           - narrate "You now have <dark_red><player.flag[Vitality].asint> <reset>Vitality."
           - run ValidateScoreboard def:p@<player.name>
           - run CalculateHealthBonus def:p@<player.name>
           - queue clear
         }
     }
'Player Base Abilities':
 type: world
 events:
   on rejuvinate command:
   - define requiredMana <proc[MaximumMana].context[<player.flag[Level]>|<player.flag[Intelligence]>]>
   - if !<proc[HasEnoughMana].context[<player>|%requiredMana%]> {
       - narrate "<red>You don't have enough mana to do that."
       - determine fulfilled
     }
   - potion slow duration:10s power:10 <player>
   - potion weakness duration:10s power:1000 <player>
   - potion regeneration duration:10s power:<player.flag[Level].mul[2].asint> <player>
   - flag CurrentMana:0
   - narrate "<red>You slip into a trance, recovering from your injuries at a rapid rate!"
   - flag Stunned:true duration:10s
   - determine fulfilled
   on equip command:
   - if <player.flag[Class]> == null {
       - narrate "<red>You haven't picked a class and therefore cannot choose abilities."
       - determine fulfilled
     }
   - if !<server.flag[<context.args.get[1]>Class]> == <player.flag[Class]> {
       - narrate "<red>That isn't an ability within your class."
       - determine fulfilled
     }
   - if <<server.flag[<context.args.get[1]>RequiredLevel].asint>||0.0> >= <player.flag[Level].asint> { 
       - narrate "<red>You don't meet the level requirement for that ability."
       - determine fulfilled
     }
   - narrate "<red>Bound <context.args.get[1]> to right click."
   - flag EquippedAbility:<context.args.get[1]>
   - determine fulfilled
   on selectClass command:
   - determine passively fulfilled
   - if <player.is_op> || <player.flag[hasBeta]> == true {
       - if <context.args.get[1]> == null {
           - narrate "<red>Incorrect usage. Use /selectClass (class you want to choose)"
           - queue clear
         }
       - if <player.flag[ClassSelectionCD]> { 
           - narrate "<red>You changed your class too recently."
           - queue clear
         }
       - if <context.args.get[1]> == Paladin || <context.args.get[1]> == Mage {
           - narrate "Your class is now <context.args.get[1]>!"
           - narrate "Documentation regarding classes is pending."
           - flag Class:<context.args.get[1]>
           - if <player.flag[Class]> == Mage {
               - give i@WAND
             }
           - if <player.flag[Class]> == Paladin {
               - give i@Mace
             }
           - flag ClassSelectionCD:true duration:1000s
         }
     }
   on givebeta command:
   - if !<player.is_op> queue clear
   - narrate "<red>Giving beta to <context.args.get[1]>"
   - narrate "<red>You have been given access to the beta by <player.name>! Use /selectClass to pick your class." t:p@<context.args.get[1]>
   - narrate "<red>Please report any bugs you find." t:p@<context.args.get[1]>
   - flag player player:<context.args.get[1]> hasBeta:true
'Entity Killed':
 type: world
 events:
   on validateScoreboard command:
   - run ValidateScoreboard def:p@<player.name>
   on server start:
   - ^if <queue.exists[ManaLoop]> queue queue:ManaLoop stop
   - run RegenerateManaLoop id:ManaLoop
   on artificialLoopStart command:
   - determine passively fulfilled
   - ^if <queue.exists[ManaLoop]> queue queue:ManaLoop stop
   - ^narrate "Mana task artificially begun."
   - run RegenerateManaLoop id:ManaLoop
   on player join:
   - run CalculateHealthBonus def:p@<player.name>
   - run ValidateScoreboard def:p@<player.name>
   - ^if <queue.exists[ManaLoop]> queue queue:ManaLoop stop
   - run RegenerateManaLoop id:ManaLoop
   on player respawn:
   - run CalculateHealthBonus def:p@<player.name>
   on player death:
   - run CalculateDeathPenalty def:p@<player.name>
   on hb command:
   - run CalculateHealthBonus def:p@<player.name>
   - determine fulfilled
   on player damaged:
   - 
   on player damages entity:
   - define amt <context.damage>
   - if <context.entity.entity_type> == PLAYER {
       - define amt <player.flag[Level]>
     }
   - if <player.flag[Strength]> == null {
       - flag Strength:5
     }
   - if <player.flag[Strength]> == 0 {
       - flag Strength:5
     }
   - if <player.flag[Dexterity]> == null {
       - flag Dexterity:5
     }
   - if <player.flag[Dexterity]> == 0 {
       - flag Dexterity:5
     }
   - define lowDamagePercentage <player.flag[Strength].div[10].asint>
   - define highDamagePercentage <player.flag[Strength].div[5].asint>
   - define lowDamageAmount <def[lowDamagePercentage].mul[%amt%]>
   - define highDamageAmount <def[highDamagePercentage].mul[%amt%]>
   - if %lowDamageAmount% < 1 {
       - define lowDamageAmount 1
     }
   - if %highDamageAmount% < 2 {
       - define highDamageAmount 2
     }
   - define finalDamageAmount <util.random.int[<def[lowDamageAmount].asint>].to[<def[highDamageAmount].asint>]>
   - define critRandom <util.random.int[1].to[100]>
   - if <def[critRandom]> <= <player.flag[Dexterity].asint> {
       - define crit true
     }
   - if <player.is_op> && <player.flag[adminDisableNotifications]> == null {
       - narrate "Crit value was <def[CritRandom].asint>"
       - narrate "Initial amount was %amt%."
       - narrate "Random variance was <def[lowDamageAmount].asint> to <def[highDamageAmount].asint>, value was <def[finalDamageAmount]>."
       - narrate "Entity has <context.entity.health>."
     }
   - if <def[crit]> {
       - define finalDamageAmount <def[finalDamageAmount].mul[3]>
       - playsound zombie_infect <player.location>
       - playeffect <player.location> effect:potion_break amt:20
       - if <player.flag[disableCritNotifications]> == null || <player.flag[disableCritNotifications]> == false {
           - narrate "<red>You crit, dealing <def[finalDamageAmount].asint> damage!"
         }
     }
   - if <context.entity.health> <= <def[finalDamageAmount]> {
       - define finalDamageAmount <def[finalDamageAmount].mul[5]>
       - define ent <context.entity.entity_type>
       - if %ent% == ZOMBIE || %ent% == SPIDER || %ent% == SKELETON || %ent% == CREEPER {
           - if <player.flag[Exp]> == null {
               - flag Exp:0
             }
           - define level <proc[MobLevel].context[<context.entity.location>]>
           - define multiplied <def[level].mul[<def[level].asint>]>
           - narrate "%multiplied% %level% <player.flag[Exp].add[<def[multiplied].asint>]>" t:p@Ares513
           - flag Exp:<player.flag[Exp].add[<def[multiplied].asint>]>
           - if <player.is_op> {
               - narrate "<red>Player gained <def[multiplied]> experience."
               - narrate "<red>Player has <player.flag[Exp].asint> experience."
             }
           - if <proc[CanUserLevelUp].context[<player.flag[Level].asint>|<player>]> {
               - run LevelUp def:p@<player.name>
             }
         }
       - run ValidateScoreboard def:p@<player.name>
     }
   - determine <def[finalDamageAmount]>
   on disableAdminNotifications command:
   - if !<player.is_op> queue clear
   - narrate "Setting notifications to <context.args.get[1]>."
   - narrate "Any value but <italic>null <reset>and <italic>false <reset>will disable the notification for critical hits."
   - flag adminDisableNotifications:<context.args.get[1]>
   - determine fulfilled
   on disableCritNotifications command:
   - narrate "Setting notification value to <context.args.get[1]>"
   - flag disableCritNotifications:<context.args.get[1]>
   - narrate "Any value but <italic>null <reset>and <italic>false <reset>will disable the notification for critical hits."
   - determine fulfilled
   on setupskill command:
   - if !<player.is_op> queue clear
   - flag global "<context.args.get[1]>Class:<context.args.get[2]>"
   - flag global "<context.args.get[1]>RequiredLevel:<context.args.get[3]>"
   - flag global "<context.args.get[1]>CastingTime:<context.args.get[4]>"
   - flag global "<context.args.get[1]>IsAura:<context.args.get[5]>"
   - narrate "<red>Setting skill <context.args.get[1]> class to <context.args.get[2]>"
   - narrate "<red>Setting skill <context.args.get[1]> required level <context.args.get[3]>"
   - narrate "<red>Setting skill <context.args.get[1]> casting time to <context.args.get[4]>"
   - narrate "<red>Setting skill <context.args.get[1]> aura value to <context.args.get[5]>"
   - determine fulfilled