# +----------------------------------
# |   List of fight flags
# +----------------------------------

# Target (The player you are attacking)
# Server_Fight_Number (the fight number)
# fight_CD (fight cooldown)
# Leader_Warning (a warning flag for trying to fight a leader - they get a chance to back off)
# Fight (fight ID for the players)
# Fight_Turn (Whoever has this flag has the turn in the fight)
# Fight_Unhealthy_Start (starting with less than full health)
# Fighters_<player.flag[Fight]> (number of fighters and their names in a list)
# Fight_Turn_Counter_<player.flag[Fight]> (Simple counter)

#              - flag player Target:!
#              - flag player Fight:!
#              - flag player Fight_Turn:!
#              - flag player Attack:!
#              - flag player Fight_Attack:!
#              - flag player Fight_Dodged:!
#              - flag player Fight_Blocked:!
#              - flag player Fight_Weapon:!
#              - flag player Fight_CD:!
#              - flag player Fight_Leader_Warning:!
#              - flag player Health:!
#              - flag player Fight_Unhealthy_Start:!
#              - flag player Weapon_Type:!
#              - flag player Defender_First_Turn:!
#              - flag player Fight_Winner:!
#              - flag player Fight_Cancel:!

Fight_Command:
    type: command
    name: fight
    description: Start a fight with another player
    usage: /fight <playername>
    script:
# +----------------------------------
# +- Conditions for a fight to begin
# +----------------------------------
# Checking that they have exactly 1 argument (hopefully a playername.)
      - if !<context.args.size.is[EQUALS].to[1]> {
        - narrate "<red>You need to specify the playername you wish to fight!"
        - queue clear
        }
      - define Target <context.args.get[1]>
# Checking that they aren't on a fight Cooldown
      - if <player.flag[Fight_CD]> {
        - run Fight_Cant_Fight
        - queue clear
        }
# Checking that the player they are trying to fight is online
      - if <server.match_player[%Target%].is_online||false> !true {
        - narrate "<red>The player you are trying to fight isn't online"
        - queue clear
        }
# Checking that they are close enough to the other player.
      - if <player.location.distance[<server.match_player[%Target%].location>]> > 10 {
        - narrate "<red>You're too far away to initiate a fight"
        - queue clear
        }
# Checking if player is already in a fight
      - if <player.flag[Fight]> != null {
        - narrate "<red>You're already in a fight! You have to finish it before you can start a new fight"
        - queue clear
        }
# Checking if the other player is in a fight. If he/she is, join the fight instead of starting a new one
      - if <server.match_player[%Target%].flag[Fight]> != null {
        - flag player Fight:<server.match_player[%Target%].flag[Fight]>
        - flag player health:<player.health.scale.as_int>
        - flag player Target:%Target%
        - if <player.flag[health]> < 20 {
          - flag player Fight_Unhealthy_Start
          }
        - narrate "<red>+-----------------------------------------------------+" targets:<player.location.find.players.within[10]>
        - narrate "<red>| <gold>%Player% has joined the fight against<&co> <red>%Target%" targets:<player.location.find.players.within[10]>
        - narrate "<red>+-----------------------------------------------------+" targets:<player.location.find.players.within[10]>
        - flag global Fighters_%Fight%:<-:<player.name>
        - if 1 > 2
        - narrate "<red>There's <gold><global.flag[Fighters_%Fight%].size> <red>players in this fight."
        - narrate "<red><global.flag[Fighters_%Fight%].as_list.formatted>"
        - queue clear
        }
      - if <player.flag[Fight_Leader_Warning]> && <server.match_player[%Target%].in_group[Leader]> {
        - flag global Fighters_%Fight%:<-:%Target%|%Target%|%Target%|%Target%
        - if 1 > 2
        }
# Checking if they are attempting to start a fight with a leader
      - if <server.match_player[%Target%].in_group[Leader]> {
        - narrate "<red>Leaders are always accompanied by <gold>4 royal guards. <red>If you are sure you want to start this fight. type the command one more time."
        - flag player Fight_Leader_Warning
        - queue clear
        }
# +----------------------------------


# Flagging server with Fight_Number (counts how many fights have been started.)
      - flag server Server_Fight_Number:++
      - narrate "<red>Fight number<&co> <gold><server.flag[Server_Fight_Number].as_int> has started"

# Assigning the players a target
      - flag player Target:%Target%
      - flag <server.match_player[%Target%]> Target:<player.name>

# assigning Unique fight name to the players
      - flag player Fight:<player.name>
      - flag <server.match_player[%Target%]> Fight:<player.name>

# Defining %Fight% for use inside tags
      - define Fight <player.flag[Fight]>

# Making a list of all the players in the fight
      - flag global Fighters_%Fight%:<-:<player.name>|<player.flag[Target]>
      - if 1 > 2

# Giving the players a health flag
      - flag player health:<player.health.scale>
      - if <player.flag[health]> < 20 {
        - flag player Fight_Unhealthy_Start
        }
      - flag <server.match_player[%Target%]> health:<player.health.scale>
      - if <server.match_player[%Target%].flag[health]> < 20 {
        - flag <server.match_player[%Target%]> Fight_Unhealthy_Start
        }

# Announcing the fight
      - narrate "<red>+-----------------------------------------------------+"
      - narrate "<red>| <blue>Starting fight with<&co> <red><player.flag[target]>"
      - narrate "<red>+-----------------------------------------------------+"

      - narrate "<red>+-----------------------------------------------------+" targets:<server.match_player[<player.flag[target]>]>
      - narrate "<red>| <blue>Starting fight with<&co> <red><player.name>" targets:<server.match_player[<player.flag[target]>]>
      - narrate "<red>+-----------------------------------------------------+" targets:<server.match_player[<player.flag[target]>]>

      - random {
        - run Fight_First_Turn_Attacker
        - run Fight_First_Turn_Attacker
        - run Fight_First_Turn_Defender
        }



# +----------------------------------
# |   Target
# +----------------------------------
Target_Command:
    type: command
    name: Target
    description: Target another player
    usage: /Target <playername>
    script:
# Checking if they chose a target
      - if !<context.args.size.is[EQUALS].to[1]> {
        - narrate "<red>You need to specify the playername you wish to target!"
        - queue clear
        }
# Checking if the target has the Fight flag
      - if !<server.match_player[<context.args.get[1]>].has_flag[Fight]> {
        - narrate "The player you are trying to target, isn't in a fight"
        - queue clear
        }
# Checking if they are in the same fight
      - if <server.match_player[<context.args.get[1]>].flag[Fight]> != <player.flag[Fight]> {
        - narrate "<red>The player you are trying to target is in a diferent fight."
        - queue clear
        }
# Setting new target
      - flag player Target:<context.parsed_args.get[1]>
      - narrate "<blue>You've targeted<&co> <gold><player.flag[Target]>."


# +----------------------------------
# |   Attack
# +----------------------------------
Attack_Command:
    type: command
    name: Attack
    description: Attack another player
    usage: /Attack
    script:
# Defining %Fight% for use inside tags
      - define Fight <player.flag[Fight]>
      - if !<player.flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Attack command"
        - queue clear
        }

# If the player was attacked and he did nothing to try and avoid it. It deals the damage
      - if <player.flag[Attack]> != null {
        - run Fight_Damage
        }

# checks if they have a target
      - if <player.flag[Target]> == null {
        - narrate "<Red>You don't have a target to attack."
        - narrate "<Red>Please use /target <playername> to define a new target"
        - queue clear
        }

# checks if it's their turn
      - if <player.flag[Fight_Turn]> == null {
        - run Fight_Not_Your_Turn
        - queue clear
        }

# Removing the players turn
      - flag player Fight_Turn:!

# [Temporary] Confirmation that it worked.
      - narrate "<red>YOU ATTACK"


# checks what weapon they have on them.
      - if <player.item_in_hand> == i@wood_sword {
        - flag player Weapon_Type:wooden
        - run Fight_Attack_Wood_sword
        - queue clear
        } else if <player.item_in_hand> == i@stone_sword {
        - flag player Weapon_Type:stone
        - run Fight_Attack_Stone_sword
        - queue clear
        } else if <player.item_in_hand> == i@iron_sword {
        - flag player Weapon_Type:iron
        - run Fight_Attack_Iron_sword
        - queue clear
        } else if <player.item_in_hand> == i@gold_sword {
        - flag player Weapon_Type:golden
        - run Fight_Attack_Gold_sword
        - queue clear
        } else if <player.item_in_hand> == i@diamond_sword {
        - flag player Weapon_Type:diamond
        - run Fight_Attack_Diamond_sword
        - queue clear
        } else if <player.item_in_hand> == i@wood_axe {
        - flag player Weapon_Type:wooden
        - run Fight_Attack_Wood_Axe
        - queue clear
        } else if <player.item_in_hand> == i@stone_axe {
        - flag player Weapon_Type:stone
        - run Fight_Attack_Stone_Axe
        - queue clear
        } else if <player.item_in_hand> == i@iron_axe {
        - flag player Weapon_Type:iron
        - run Fight_Attack_Iron_Axe
        - queue clear
        } else if <player.item_in_hand> == i@gold_axe {
        - flag player Weapon_Type:gold
        - run Fight_Attack_Gold_Axe
        - queue clear
        } else if <player.item_in_hand> == i@diamond_axe {
        - flag player Weapon_Type:diamond
        - run Fight_Attack_Diamond_Axe
        - queue clear
        } else {
# If they don't have a weapon, normal attack is used.
        - run Fight_Attack
        }

# +----------------------------------
# |   Shoot
# +----------------------------------
Shoot_Command:
    type: command
    name: Shoot
    description: Shoot another player
    usage: /Shoot
    script:
# Defining %Fight% for use inside tags
      - define Fight <player.flag[Fight]>
      - define Player <player.flag[Character]>

      - if !<player.flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Shoot command"
        - queue clear
        }

# If the player was attacked and he did nothing to try and avoid it. It deals the damage
      - if <player.flag[Attack]> != null {
        - run Fight_Damage
        }

# checks if they have a target
      - if <player.flag[Target]> == null {
        - narrate "<Red>You don't have a target to attack."
        - narrate "<Red>Please use /target <playername> to define a new target"
        - queue clear
        }

# checks if it's their turn
      - if <player.flag[Fight_Turn]> == null {
        - run Fight_Not_Your_Turn
        - queue clear
        }

# Removing the players turn
      - flag player Fight_Turn:!
      - if <player.item_in_hand> == i@bow {
        - if <player.inventory.contains[i@arrow]> {
          - flag player Weapon_Type:bow
          - run Fight_Shoot_Bow
          - take i@arrow
          } else {
          - narrate "<gold>%Player% <blue>reaches for an arrow in his quiver but finds it <red>empty."
          - run Fight_Turn_Chooser
          }
        }

# +----------------------------------
# |   Throw
# +----------------------------------
Throw_Command:
    type: command
    name: Throw
    description: Throw something at another player
    usage: /Throw
    script:
      - if !<player.flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Throw command"
        - queue clear
        }

# +----------------------------------
# |   Dodge
# +----------------------------------
Dodge_Command:
    type: command
    name: Dodge
    description: Dodge an attack
    usage: /Dodge
    script:
# Checking if player is in a fight
      - if !<player.has_flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Dodge command"
        - queue clear
        }
# Checking if it's their turn
      - if !<player.flag[Fight_Turn]> {
        - run Fight_Not_Your_Turn 
        - queue clear
        }
# Checking if they have been attacked
      - if !<player.has_flag[Attack]> {
        - narrate "<red>There's nothing to dodge."
        - queue clear
        }
# Defining a random number between 0 and 100
      - define Random <util.random.int[0].to[100]>
      - define Player <player.flag[Character]>
# Checking if the number is below or equal to 25(%). If it is, it's a succesful dodge
      - if %Random% <= 25 {
        - if 1 > 2
# Adding a dodged flag.
        - flag player Fight_Dodged
# Runs the Fight_Dodge script which narrates a random dodge message.
        - run Fight_Dodge
        } else if %Random% > 80 {
# Runs the Fight_Dodge_Fall script which narrates a random "fall" and skip the players turn
        - run Fight_Dodge_Fall
        } else {
# If the Dodge failed, say so.
        - narrate "<gold>%Player% <blue>attempted to dodge but failed." targets:<player.location.find.players.within[10]>
        - run Fight_Damage
        - random {
          - narrate "<blue>It's still <gold>%Player%'s <blue>turn" targets:<player.location.find.players.within[10]>
          - repeat 1 {
            - narrate "<gold>%Player% <blue>takes a hard blow and isn't able to attack" targets:<player.location.find.players.within[10]>
            - flag player Fight_Turn:!
            - run Fight_Turn_Chooser
            }
          }
        }

# +----------------------------------
# |   Block
# +----------------------------------
Block_Command:
    type: command
    name: Block
    description: Block an attack
    usage: /block
    script:
      - if !<player.flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Block command"
        - queue clear
        }
# +----------------------------------
# |   Taunt
# +----------------------------------
Taunt_Command:
    type: command
    name: Taunt
    description: Taunt another player
    usage: /taunt
    script:
      - if !<player.flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Taunt command"
        - queue clear
        }

# +----------------------------------
# |   Escape
# +----------------------------------
Escape_Command:
    type: command
    name: Escape
    description: Escape an attack
    usage: /escape
    script:
      - define Player <player.flag[Character]>
      - define Fight <player.flag[Fight]>
# Checking that they are in a fight
      - if !<player.has_flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the /Escape command"
        - queue clear
        }
      - define random <util.random.int[0].to[100]>
# Checking if it's the defenders first turn
      - if <player.flag[Defender_First_Turn]> != true {
        - if %random% > 20 {
          - narrate "<gold>%Player% <blue>attempted to escape but <red>failed"
          } else {
          - narrate "<gold>%Player% <blue>Succesfully escaped the fight"
          - run Fight_Escape
          }
# If it is their first turn. Give them a lot higher chance to escape
        } else if %random% > 80 {
        - narrate "<gold>%Player% <blue>attempted to escape but <red>failed"
        } else {
        - narrate "<gold>%Player% <blue>succesfully escaped the fight"
        - run Fight_Escape
        }
























# +----------------------------------
# |   Cancel
# +----------------------------------
Cancel_Command:
    type: command
    name: Cancel
    description: Cancel a fight
    usage: /cancel
    script:
      - if !<player.has_flag[Fight]> {
        - narrate "<red>You need to be in a fight to use the Cancel command"
        - queue clear
        }
      - define Player <player.flag[Character]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Fight <player.flag[Fight]>
      - define Cancel_Number <server.flag[Fight_Cancel_%Fight%].as_int> - 1
      - define First_Fighter <server.flag[Fighters_%Fight%].get[1]>

      - if <server.flag[Fight_Cancel_%Fight%]> == %Cancel_Number% {
        - repeat <server.flag[Fighters_%Fight%].size>
          - flag server Fighters_%Fight%:<-:%First_Fighter%
          - 1 > 2
          - flag <server.match_player[%First_Fighter%]> Fight:!
          - flag <server.match_player[%First_Fighter%]> Target:!
          - flag <server.match_player[%First_Fighter%]> Fight_Turn:!
          - flag <server.match_player[%First_Fighter%]> Attack:!
          - flag <server.match_player[%First_Fighter%]> Fight_Attack:!
          - flag <server.match_player[%First_Fighter%]> Fight_Dodged:!
          - flag <server.match_player[%First_Fighter%]> Fight_Blocked:!
          - flag <server.match_player[%First_Fighter%]> Fight_Weapon:!
          - flag <server.match_player[%First_Fighter%]> Fight_CD:!
          - flag <server.match_player[%First_Fighter%]> Fight_Leader_Warning:!
          - flag <server.match_player[%First_Fighter%]> Health:!
          - flag <server.match_player[%First_Fighter%]> Fight_Unhealthy_Start:!
          - flag <server.match_player[%First_Fighter%]> Weapon_Type:!
          - flag <server.match_player[%First_Fighter%]> Defender_First_Turn:!
          - flag <server.match_player[%First_Fighter%]> Fight_Winner:!
          - flag <server.match_player[%First_Fighter%]> Fight_Cancel:!
          }
        - flag global Fighters_<player.flag[Fight]>:!
        - flag server Fight_Turn_Counter_%Fight%:!
        - narrate "<red>Fight has been cancelled!"
        } else {
        - flag server Fight_Cancel_%Fight%:++
        - narrate "<gold>%Player% <blue>wants to <red>cancel <blue>the fight!"
        }


# +----------------------------------
# |   Roll
# +----------------------------------
Roll_Command:
    type: command
    name: roll
    description: Roll random numbers
    usage: /roll or /roll dice
    script:
      - define Player <player.flag[Character]>
      - if <context.args.size.is[EQUALS].to[0]> {
        - narrate "<gold>%Player% <blue>Rolled<&co> <gold><util.random.int[0].to[100]>" targets:<player.location.find.players.within[10]>
        - queue clear
        }
      - if <context.args.get[1]> == dice {
        - narrate "<gold>%Player% <blue>rolls the dice<&co> <gold><util.random.int[1].to[6]> & <gold><util.random.int[1].to[6]>" targets:<player.location.find.players.within[10]>
        }


























# +----------------------------------
# |   Winner Command - Kill
# +----------------------------------
Kill_Command:
    type: command
    name: Kill
    description: Kill another player
    usage: /kill
    script:
      - if !<player.flag[Fight_Winner]> {
        - narrate "<red>Only fight winners can use the kill command"
        - ^queue clear
        }
      - flag player Fight_Winner:!
      - define Fight <player.flag[Fight]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Player <player.flag[Character]>
      - run Fight_Kill
# Remove all of the loser's fight related flags
      - flag <server.match_player[%Target%]> Fight:!
      - flag <server.match_player[%Target%]> Fight_Turn:!
      - flag <server.match_player[%Target%]> Attack:!
      - flag <server.match_player[%Target%]> Fight_Attack:!
      - flag <server.match_player[%Target%]> Fight_Dodged:!
      - flag <server.match_player[%Target%]> Fight_Blocked:!
      - flag <server.match_player[%Target%]> Fight_Weapon:!
      - flag <server.match_player[%Target%]> Fight_CD:!
      - flag <server.match_player[%Target%]> Fight_Leader_Warning:!
      - flag <server.match_player[%Target%]> Health:!
      - flag <server.match_player[%Target%]> Fight_Unhealthy_Start:!
      - flag <server.match_player[%Target%]> Weapon_Type:!
      - flag <server.match_player[%Target%]> Defender_First_Turn:!
      - flag <server.match_player[%Target%]> Fight_Winner:!
      - flag <server.match_player[%Target%]> Fight_Cancel:!
      - flag player Target:!
# "Kill" the player physically causing them to respawn and lose most of their items.
      - adjust <server.match_player[%Target%]> health:0
      - if <global.flag[Fighters_%Fight%].size> > 1 {
        - queue clear
# Do nothing
        }
# Remove all of the rest of the fight related flags
      - flag global Fighters_<player.flag[Fight]>:!
      - flag server Fight_Turn_Counter_%Fight%:!
      - flag player Fight_Turn:!
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Dodged:!
      - flag player Fight_Blocked:!
      - flag player Fight_Weapon:!
      - flag player Fight_CD:!
      - flag player Fight_Leader_Warning:!
      - flag player Health:!
      - flag player Fight_Unhealthy_Start:!
      - flag player Weapon_Type:!
      - flag player Defender_First_Turn:!
      - flag player Fight:!
      - flag player Target:!
      - flag player Fight_Cancel:!
      }



# +----------------------------------
# |   Winner Command - Capture / Release
# +----------------------------------
Capture_Command:
    type: command
    name: Capture
    description: Capture another player
    usage: /Capture
    script:
      - if <player.flag[Fight_Winner]> {
        - narrate "<red>Only fight winners can use the mercy command"
        - queue clear
        }
      - define Fight <player.flag[Fight]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Player <player.flag[Character]>
      - flag player Fight_Winner:!
      - narrate "<gold>%Player% <blue>Ties <gold>%Target%<blue>'s hands behind %Gender% back." targets:<player.location.find.players.within[10]>
      - narrate "<gold>%Target%<blue>'s has been captured by <gold>%Player%" targets:<player.location.find.players.within[10]>
# Flag the player as having captured his/her target and the capured as captured.
      - flag player Captured:%Target%
      - flag <server.match_player[%Target%]> Captured_By:%Player%
      - flag <server.match_player[%Target%]> Fight:!
      - flag <server.match_player[%Target%]> Fight_Turn:!
      - flag <server.match_player[%Target%]> Attack:!
      - flag <server.match_player[%Target%]> Fight_Attack:!
      - flag <server.match_player[%Target%]> Fight_Dodged:!
      - flag <server.match_player[%Target%]> Fight_Blocked:!
      - flag <server.match_player[%Target%]> Fight_Weapon:!
      - flag <server.match_player[%Target%]> Fight_CD:!
      - flag <server.match_player[%Target%]> Fight_Leader_Warning:!
      - flag <server.match_player[%Target%]> Health:!
      - flag <server.match_player[%Target%]> Fight_Unhealthy_Start:!
      - flag <server.match_player[%Target%]> Weapon_Type:!
      - flag <server.match_player[%Target%]> Defender_First_Turn:!
      - flag <server.match_player[%Target%]> Fight_Winner:!
      - flag <server.match_player[%Target%]> Fight_Cancel:!
      - flag player Target:!
# "Kill" the player physically causing them to respawn and lose most of their items.
      - if <global.flag[Fighters_%Fight%].size> > 1 {
        - queue clear
# Do nothing
        }
# Remove all of the rest of the fight related flags
      - flag global Fighters_<player.flag[Fight]>:!
      - flag server Fight_Turn_Counter_%Fight%:!
      - flag player Fight_Turn:!
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Dodged:!
      - flag player Fight_Blocked:!
      - flag player Fight_Weapon:!
      - flag player Fight_CD:!
      - flag player Fight_Leader_Warning:!
      - flag player Health:!
      - flag player Fight_Unhealthy_Start:!
      - flag player Weapon_Type:!
      - flag player Defender_First_Turn:!
      - flag player Fight:!
      - flag player Target:!
      - flag player Fight_Cancel:!
      - repeat 10 {
        - wait 10
        - if <player.flag[Captured]> != null {
          - if <player.location.distance[<server.match_player[%Target%].location>]> > 10 {
            - narrate "<red>You've been captured by <gold>%Player%<red>, please follow this person until your release." targets:<server.match_player[%Target%]>
            - teleport <server.match_player[%Target%]> <player.location>
            }
          }

Free_Command:
    type: command
    name: Free
    description: Release another player
    usage: /free
    script:
      - if <player.flag[Captured]> != null {
        - define Target <server.match_player[<player.flag[Captured]>].flag[Character]>
        - define Player <player.flag[Character]>
        - flag <server.match_player[%Target%]> Captured_By:!
        - flag player Captured:!
        - narrate "<gold>%Player% <blue>releases <gold>%Target% <blue>from captivity" targets:<player.location.find.players.within[10]>
        - wait 2
        - narrate "<green>You've been released from <red>captivity" targets:<server.match_player[%Target%]>
        } else {
        - narrate "<red>You don't have anyone in your captivity."
        }






# +----------------------------------
# |   Winner Command - Mame
# +----------------------------------
Mame_Command:
    type: command
    name: Mame
    description: Mame another player
    usage: /mame
    script:
      - if !<player.flag[Fight_Winner]> {
        - narrate "<red>Only fight winners can use the mame command"
        - queue clear
        }
      - flag player Fight_Winner:!
      - define Fight <player.flag[Fight]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Player <player.flag[Character]>
      - run Fight_Mame
      - flag <server.match_player[%Target%]> Fight:!
      - flag <server.match_player[%Target%]> Fight_Turn:!
      - flag <server.match_player[%Target%]> Attack:!
      - flag <server.match_player[%Target%]> Fight_Attack:!
      - flag <server.match_player[%Target%]> Fight_Dodged:!
      - flag <server.match_player[%Target%]> Fight_Blocked:!
      - flag <server.match_player[%Target%]> Fight_Weapon:!
      - flag <server.match_player[%Target%]> Fight_CD:!
      - flag <server.match_player[%Target%]> Fight_Leader_Warning:!
      - flag <server.match_player[%Target%]> Health:!
      - flag <server.match_player[%Target%]> Fight_Unhealthy_Start:!
      - flag <server.match_player[%Target%]> Weapon_Type:!
      - flag <server.match_player[%Target%]> Defender_First_Turn:!
      - flag <server.match_player[%Target%]> Fight_Winner:!
      - flag <server.match_player[%Target%]> Fight_Cancel:!
# "Kill" the player physically causing them to respawn and lose most of their items.
      - adjust <server.match_player[%Target%]> health:0
      - if <global.flag[Fighters_%Fight%].size> > 1 {
        - queue clear
# Do nothing
        }
# Remove all of the rest of the fight related flags
      - flag global Fighters_<player.flag[Fight]>:!
      - flag server Fight_Turn_Counter_%Fight%:!
      - flag player Fight_Turn:!
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Dodged:!
      - flag player Fight_Blocked:!
      - flag player Fight_Weapon:!
      - flag player Fight_CD:!
      - flag player Fight_Leader_Warning:!
      - flag player Health:!
      - flag player Fight_Unhealthy_Start:!
      - flag player Weapon_Type:!
      - flag player Defender_First_Turn:!
      - flag player Fight:!
      - flag player Target:!
      - flag player Fight_Cancel:!

# +----------------------------------
# |   Winner Command - Knock Out
# +----------------------------------
Knockout_Command:
    type: command
    name: Knockout
    description: Knock out another player
    usage: /knockout
    script:
      - if <player.flag[Fight_Winner]> {
        - narrate "<red>Only fight winners can use the knockout command"
        - queue clear
        }
      - flag player Fight_Winner:!
      - define Fight <player.flag[Fight]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Player <player.flag[Character]>
      - narrate "<gold>%Player% knocks out <player.flag[Target]>" targets:<player.location.find.players.within[10]>
# Remove all of the loser's fight related flags
      - flag <server.match_player[%Target%]> Fight:!
      - flag <server.match_player[%Target%]> Fight_Turn:!
      - flag <server.match_player[%Target%]> Attack:!
      - flag <server.match_player[%Target%]> Fight_Attack:!
      - flag <server.match_player[%Target%]> Fight_Dodged:!
      - flag <server.match_player[%Target%]> Fight_Blocked:!
      - flag <server.match_player[%Target%]> Fight_Weapon:!
      - flag <server.match_player[%Target%]> Fight_CD:!
      - flag <server.match_player[%Target%]> Fight_Leader_Warning:!
      - flag <server.match_player[%Target%]> Health:!
      - flag <server.match_player[%Target%]> Fight_Unhealthy_Start:!
      - flag <server.match_player[%Target%]> Weapon_Type:!
      - flag <server.match_player[%Target%]> Defender_First_Turn:!
      - flag <server.match_player[%Target%]> Fight_Winner:!
      - flag <server.match_player[%Target%]> Fight_Cancel:!
      - flag player Target:!
# "Kill" the player physically causing them to respawn and lose most of their items.
      - adjust <server.match_player[%Target%]> health:0
      - if <global.flag[Fighters_%Fight%].size> > 1 {
        - queue clear
# Do nothing
        }
# Remove all of the rest of the fight related flags
      - flag global Fighters_<player.flag[Fight]>:!
      - flag server Fight_Turn_Counter_%Fight%:!
      - flag player Fight_Turn:!
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Dodged:!
      - flag player Fight_Blocked:!
      - flag player Fight_Weapon:!
      - flag player Fight_CD:!
      - flag player Fight_Leader_Warning:!
      - flag player Health:!
      - flag player Fight_Unhealthy_Start:!
      - flag player Weapon_Type:!
      - flag player Defender_First_Turn:!
      - flag player Fight:!
      - flag player Target:!
      - flag player Fight_Cancel:!


# +----------------------------------
# |   Winner Command - Mercy
# +----------------------------------
Mercy_Command:
    type: command
    name: Mercy
    description: Show mercy to another player
    usage: /Mercy
    script:
      - if <player.flag[Fight_Winner]> {
        - narrate "<red>Only fight winners can use the mercy command"
        - queue clear
        }
      - flag player Fight_Winner:!
      - define Fight <player.flag[Fight]>
      - define Player <player.flag[Character]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - narrate "<blue><player.name> shows <player.flag[Target]> mercy" targets:<player.location.find.players.within[10]>
      - flag <server.match_player[%Target%]> Fight:!
      - flag <server.match_player[%Target%]> Fight_Turn:!
      - flag <server.match_player[%Target%]> Attack:!
      - flag <server.match_player[%Target%]> Fight_Attack:!
      - flag <server.match_player[%Target%]> Fight_Dodged:!
      - flag <server.match_player[%Target%]> Fight_Blocked:!
      - flag <server.match_player[%Target%]> Fight_Weapon:!
      - flag <server.match_player[%Target%]> Fight_CD:!
      - flag <server.match_player[%Target%]> Fight_Leader_Warning:!
      - flag <server.match_player[%Target%]> Health:!
      - flag <server.match_player[%Target%]> Fight_Unhealthy_Start:!
      - flag <server.match_player[%Target%]> Weapon_Type:!
      - flag <server.match_player[%Target%]> Defender_First_Turn:!
      - flag <server.match_player[%Target%]> Fight_Winner:!
      - flag <server.match_player[%Target%]> Fight_Cancel:!
      - flag player Target:!
      - if <global.flag[Fighters_%Fight%].size> > 1 {
# Do nothing
        }
      - flag global Fighters_<player.flag[Fight]>:!
      - flag server Fight_Turn_Counter_%Fight%:!
      - flag player Fight_Turn:!
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Dodged:!
      - flag player Fight_Blocked:!
      - flag player Fight_Weapon:!
      - flag player Fight_CD:!
      - flag player Fight_Leader_Warning:!
      - flag player Health:!
      - flag player Fight_Unhealthy_Start:!
      - flag player Weapon_Type:!
      - flag player Defender_First_Turn:!
      - flag player Fight_Winner:!
      - flag player Fight:!
      - flag player Target:!
      - flag player Fight_Cancel:!


















# +----------------------------------
# |   Fight Debug
# +----------------------------------
        on Fight_Debug command:
# Helps with debugging
        - determine passively fulfilled
# Defining %Fight% for use inside tags
        - define Fight <player.flag[Fight]>
        - define Fight_Turn_Counter <server.flag[Fight_Turn_Counter_%Fight%].as_int>

        - narrate "<dark_red>Fight Debug"
        - narrate "<red>Your Fight flag ID is<&co> <gold>%Fight%"
        - narrate "<red>Turn counter is<&co> <gold><server.flag[Fight_Turn_Counter_%Fight%].as_int>"
#        - narrate "<red>It's<&co> <gold> <global.flag[Fighters_%Flag%].get[<server.flag[Fight_Turn_Counter_%Fight%]>]>"
        - narrate "<red>It's<&co> <gold> <global.flag[Fighters_%Fight%].get[%Fight_Turn_Counter%].as_list.formatted>'s turn"
        - narrate "<red>Number of players in fight<&co> <gold><global.flag[Fighters_%Fight%].size>"
        - narrate "<red>1<&co> <gold><global.flag[Fighters_%Fight%].get[1].as_list.formatted>"
        - narrate "<red>2<&co> <gold><global.flag[Fighters_%Fight%].get[2].as_list.formatted>"
        - narrate "<red>Your target is<&co> <gold><player.flag[Target]>"
        - narrate ""
        - if <player.flag[Fight_Turn]> {
          - narrate "<red> It's <gold>your <red>turn!"
          } else {
          - narrate "<red> It's <gold>NOT <red>your turn!"
          }

# +----------------------------------
# |   Fight Reset
# +----------------------------------
        on Fight_Reset command:
# Reset everything
        - determine passively fulfilled

# Defining %Fight% for use inside tags
        - define Fight <player.flag[Fight]>
        - define Target <server.match_player[<player.flag[Target]>].flag[Character]>

# general flags
        - flag global Fighters_%Fight%:!
        - flag server Fight_Turn_Counter_%Fight%:!

        - flag player Fight:!
        - flag player Fight_Turn:!
        - flag player Fight_Leader_Warning:!
        - flag player Target:!

# Attack Flags
        - flag player Attack:!
        - flag player Fight_Attack:!
        - flag player Fight_Dodged:!
        - flag player Fight_Blocked:!


# [Temporary for testing] Removing your Target's flags.

        - flag <server.match_player[%Target%]> Fight:!
        - flag <server.match_player[%Target%]> Fight_Turn:!
        - flag <server.match_player[%Target%]> Leader_Warning:!
        - flag <server.match_player[%Target%]> Target:!

# Attack Flags
        - flag <server.match_player[%Target%]> Attack:!
        - flag <server.match_player[%Target%]> Fight_Attack:!
        - flag <server.match_player[%Target%]> Fight_Dodged:!
        - flag <server.match_player[%Target%]> Fight_Blocked:!
        - narrate "<red>All Fight information Deleted"
































# +----------------------------------
# |  Unarmed Attack Damage
# +----------------------------------

Fight_Attack:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Unarmed
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - if 1 > 2
        - run Fight_Unarmed_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Unarmed_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Unarmed_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Unarmed_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Unarmed_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - if 1 > 2
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Unarmed_Attack_Messages
        - queue clear
        }

# +----------------------------------
# |  Sword Attack Damage
# +----------------------------------

Fight_Attack_Wood_sword:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Wood_Sword
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Sword_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - if 1 > 2
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - queue clear
        }

Fight_Attack_Stone_sword:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Stone_Sword
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Sword_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Iron_sword:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Iron_Sword
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Sword_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Gold_sword:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Gold_Sword
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Sword_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Diamond_sword:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Diamond_Sword
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Sword_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Sword_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - queue clear
        - if 1 > 2
        }

# +----------------------------------
# |  Axe Attack Damage
# +----------------------------------

Fight_Attack_Wood_Axe:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Wood_Axe
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Axe_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Stone_Axe:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Stone_Axe
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Axe_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Iron_Axe:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Iron_Axe
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Axe_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Gold_Axe:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Gold_Axe
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Axe_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Attack_Diamond_Axe:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Diamond_Axe
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Axe_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Axe_Attack_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - queue clear
        - if 1 > 2
        }

Fight_Shoot_Bow:
    type: task
    Script:
# Check if the player attempted to Dodge
      - if <player.flag[Fight_Dodged]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Dodged:!
# Check if the player attempted to Block
        } else if <player.flag[Fight_Blocked]> {
# Lower chances of a good hit by 20
        - define random <util.random.int[-20].to[80]>
        - flag player Fight_Blocked:!
        } else {
# Check if the player didn't attempt to dodge or block, roll with full range
        - define random <util.random.int[1].to[100]>
        }
      - narrate "rolled %random%"
# Flagging the target with the attackers name and the weapon type
      - flag <server.match_player[<player.flag[target]>]> Attack:<player.name>
      - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:Bow
# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% <= 20 {
        - run Fight_Shoot_Bow_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!
        - queue clear

        } else if %random% > 20 && %random% <= 40 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:1
        - run Fight_Shoot_Bow_Messages
        - queue clear

        } else if %random% > 40 && %random% <= 60 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:2
        - run Fight_Shoot_Bow_Messages
        - queue clear

        } else if %random% > 60 && %random% <= 80 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:3
        - run Fight_Shoot_Bow_Messages
        - queue clear

        } else if %random% > 80 && %random% <= 95 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:4
        - run Fight_Shoot_Bow_Messages
        - queue clear

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Shoot_Bow_Messages
        - queue clear
        - if 1 > 2
        }


























# +----------------------------------
# |   Attack Messages (Unarmed)
# +----------------------------------

Fight_Unarmed_Miss_Messages:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - random {
        - narrate "<gold>%Player% <red>Misses" targets:<player.location.find.players.within[10]>
        }
      - run Fight_Turn_Chooser

Fight_Unarmed_Attack_Messages:
    type: task
    Script:
      - define Player <player.name>
      - define Target <player.flag[Target]>
      - define Lower_Body_Part_Li li@
      - define Upper_Body_Part_Li li@
      - define Lower_Body_Part_Li "<def[Lower_Body_Part_Li].include[buttocks|lower abdomen|right thigh|left thigh|right knee|left knee| right calf|left calf|right ankle|left ankle|groin]>"
      - define Upper_Body_Part_Li "<def[Upper_Body_Part_Li].include[buttocks|face|head|neck|right shoulder|left shoulder|right arm|left arm|right forearm|left forearm|right hand|left hand|chest|upper abdomen|lower abdomen|groin]>"
      - define Lower_Body_Part <def[Lower_Body_Part_Li].random>
      - define Upper_Body_Part <def[Upper_Body_Part_Li].random>
# The Gender flag doesn't exist yet!!!!
      - if <player.flag[Gender]> != Female {
        - define Gender his
        } else {
        - define Gender her
        }
      - random {
        - narrate "<gold>%Player% <blue>attempts to punch <gold>%Target% <blue>in the <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to Strike at <gold>%Target%'s <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to Scratch <gold>%Target%'s <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to kick <gold>%Target% <blue>in the <red>%Lower_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to tackle <gold>%Target%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to throttle <gold>%Target%'s <red>neck" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to slap <gold>%Target%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to smack <gold>%Target% <blue>in the <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to headbutt <gold>%Target%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to stomp on <gold>%Target%'s <red>foot" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to bite <gold>%Target%'s <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to pound <gold>%Target%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to jab <gold>%Target% <blue>in the <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to give <gold>%Target% <blue>a right hook to the <red>%Upper_Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to pull <gold>%Target%'s <red>hair" targets:<player.location.find.players.within[10]>
        }
# Gives the turn to the next player
      - run Fight_Turn_Chooser

# +----------------------------------
# |   Attack Messages (Swords)
# +----------------------------------

Fight_Sword_Miss_Messages:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - random {
        - narrate "<gold>%Player% <red>Misses" targets:<player.location.find.players.within[10]>
        }
      - run Fight_Turn_Chooser

Fight_Sword_Attack_Messages:
    type: task
    Script:
      - define Player <player.name>
      - define Target <player.flag[Target]>
      - define Weapon_Type <player.flag[Weapon_Type]>
      - define Body_Part_Li li@
      - define Body_Part_Li "<def[Body_Part_Li].include[buttocks|face|head|neck|right shoulder|left shoulder|right arm|left arm|right forearm|left forearm|right hand|left hand|chest|upper abdomen|lower abdomen|right thigh|left thigh|right knee|left knee| right calf|left calf|right ankle|left ankle|groin]>"
      - define Body_Part <def[Body_Part_Li].random>
# The Gender flag doesn't exist yet!!!!
      - if <player.flag[Gender]> != Female {
        - define Gender his
        } else {
        - define Gender her
        }
      - random {
        - narrate "<gold>%Player% <blue>attempts to stab <gold>%Target% <blue>in the <red>%Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>tries to slash <gold>%Target% <blue>in the <red>%Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to slash %Gender% %Weapon_Type% sword at <gold>%Target%'s <red>%Body_Part%" targets:<player.location.find.players.within[10]>
        }
# Gives the turn to the next player
      - run Fight_Turn_Chooser
      - flag player Weapon_Type:!


# +----------------------------------
# |   Attack Messages (Axes)
# +----------------------------------

Fight_Axe_Miss_Messages:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - random {
        - narrate "<gold>%Player% <red>Misses" targets:<player.location.find.players.within[10]>
        }
      - run Fight_Turn_Chooser

Fight_Axe_Attack_Messages:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Weapon_Type <player.flag[Weapon_Type]>
      - define Body_Part_Li li@
      - define Body_Part_Li "<def[Body_Part_Li].include[buttocks|face|head|neck|right shoulder|left shoulder|right arm|left arm|right forearm|left forearm|right hand|left hand|chest|upper abdomen|lower abdomen|right thigh|left thigh|right knee|left knee| right calf|left calf|right ankle|left ankle|groin]>"
      - define Body_Part <def[Body_Part_Li].random>
# The Gender flag doesn't exist yet!!!!
      - if <player.flag[Gender]> != Female {
        - define Gender his
        } else {
        - define Gender her
        }
      - random {
        - narrate "<gold>%Player% <blue>tries to slash <gold>%Target% <blue>in the <red>%Body_Part%" targets:<player.location.find.players.within[10]>
        - narrate "<gold>%Player% <blue>attempts to slash %Gender% %Weapon_Type% axe at <gold>%Target%'s <red>%Body_Part%" targets:<player.location.find.players.within[10]>
        }
# Gives the turn to the next player
      - run Fight_Turn_Chooser
      - flag player Weapon_Type:!


# +----------------------------------
# |   Attack Messages (Bows)
# +----------------------------------

Fight_Shoot_Bow_Miss_Messages:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - random {
        - narrate "<gold>%Player% <red>Misses" targets:<player.location.find.players.within[10]>
        }
      - run Fight_Turn_Chooser

Fight_Shoot_Bow_Messages:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Weapon_Type <player.flag[Weapon_Type]>
      - define Body_Part_Li li@
      - define Body_Part_Li "<def[Body_Part_Li].include[buttocks|face|head|neck|right shoulder|left shoulder|right arm|left arm|right forearm|left forearm|right hand|left hand|chest|upper abdomen|lower abdomen|right thigh|left thigh|right knee|left knee| right calf|left calf|right ankle|left ankle|groin]>"
      - define Body_Part <def[Body_Part_Li].random>
# The Gender flag doesn't exist yet!!!!
      - if <player.flag[Gender]> != Female {
        - define Gender his
        } else {
        - define Gender her
        }
      - random {
        - narrate "<gold>%Player% <blue>attempts to shoot <gold>%Target%'s <blue>in the <red>%Body_Part%" targets:<player.location.find.players.within[10]>
        }
# Gives the turn to the next player
      - run Fight_Turn_Chooser
      - flag player Weapon_Type:!















# +----------------------------------
# |   Win and Lose Scripts
# +----------------------------------

Fight_Lost:
    type: task
    Script:
      - define Fight <player.flag[Fight]>
      - flag player Fight_Loser
      - flag <server.match_player[<player.flag[target]>]> Fight_Winner
      - narrate "<red>You Lost the fight."
      - narrate "<red>Please wait for the winner to choose what happens to you..."
      - if <player.flag[Fight_Turn]> {
        - flag player Fight_Turn:!
        - run Fight_Turn_Chooser
      }
      - flag global Fighters_%Fight%:<-:<player.flag[Target]>
      - if 1 > 2
      - run Fight_Won player:<player.flag[Target]>

Fight_Won:
    type: task
    Script:
      - define Fight <player.flag[Fight]>
      - narrate "<red>You Won the fight."
      - narrate "<red>Please choose what happens to the loser<&co>"
      - narrate "<gold>/Mercy"
      - narrate "<gold>/Mame"
      - narrate "<gold>/KnockOut"
      - if <player.flag[VA_Kill]> {
        - narrate "<gold>/Capture"
        }
      - if <player.flag[VA_Kill]> {
        - narrate "<red>/Kill  - This has serious consequences for the loser."
        }

Fight_Mame:
    type: task
    Script:
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Player <player.flag[Character]>
      - flag player Target:!
# temporary, no need to list these every time. Just need to do it once.
      - flag global Common_Mame_Li:|:right ear|left ear|left nipple|right nipple|left thumb|right thumb|left index finger|right index finger|left middle finger|right middle finger|left ring finger|right ring finger|left pinky|right pinky|left little toe|right little toe|left big toe|right big toe
      - flag global Rare_Mame_Li:|:right arm|left arm|left forearm|right forearm|left hand|right hand|left calf|right calf|left ankle|right ankle|left eye|right eye|tounge
      - flag global Scar_Mame_Li:|:right cheek|left cheek|nose|forehead|left arm|right arm|left forearm|right forearm|left hand|right hand|chest|abdomen|back|across left eye|across right eye
      - define random <util.random.int[0].to[100]>



      - if %random% <= 45 {
        - if 1 > 2
        - define Common_Mame <global.flag[Common_Mame_Li].random>
# If the player already have that part mamed, run the mame script again.
        - if <server.match_player[%Target%].flag[Mamed].contains[%Common_Mame%]> {
          - run Fight_Mame
          } else {
          - flag <server.match_player[%Target%]> Common_Mamed:->:%Common_Mame%
          - random {
            - narrate "<gold>%Player% <blue>pulls out a small knife and cuts off <gold>%Target%<blue>'s <red>%Common_Mame%"
            }
          }



        } else if %random% > 50 {
        - define Scar_Mame <global.flag[Scar_Mame_Li].random>
# If the player already have that part mamed, run the mame script again.
        - if <server.match_player[%Target%].flag[Scared].contains[%Scar_Mame%]> {
          - run Fight_Mame
          } else {
          - flag <server.match_player[%Target%]> Rare_Mamed:->:%Scar_Mame%
          - random {
            - narrate "<gold>%Player% <blue>pulls out a small knife and cuts a deep wound over <gold>%Target%<blue>'s <red>%Scar_Mame%"
            }
          }



        }  else {
        - define Rare_Mame <global.flag[Rare_Mame_Li].random>
# If the player already have that part mamed, run the mame script again.
        - if <server.match_player[%Target%].flag[Mamed].contains[%Rare_Mame%]> {
          - run Fight_Mame
          } else {
          - flag <server.match_player[%Target%]> Rare_Mamed:->:%Rare_Mame%
          - random {
            - narrate "<gold>%Player% <blue>pulls out a small knife and cuts off <gold>%Target%<blue>'s <red>%Rare_Mame%"
            }
          }
        }

Fight_Kill:
    type: task
    Script:
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - define Player <player.flag[Character]>
      - flag player Target:!
      - if <player.flag[Gender]> != Female {
        - define Gender his
        } else {
        - define Gender her
        }
# Sword kill messages
      - if <player.item_in_hand> == i@wood_sword || <player.item_in_hand> == i@stone_sword || <player.item_in_hand> == i@iron_sword || <player.item_in_hand> == i@gold_sword || <player.item_in_hand> == i@diamond_sword {
        - random {
          - narrate "<gold>%Player% <red>chops off <gold>%Target%<red>’s head with %Gender% sword"
          - narrate "<gold>%Player% <red>decapitates <gold>%Target%<red> with %Gender% sword"
          - narrate "<gold>%Player% <red>stabs <gold>%Target%<red> in the heart with %Gender% sword"
          }
# Axe kill messages
        } else if <player.item_in_hand> == i@wood_axe || <player.item_in_hand> == i@stone_axe || <player.item_in_hand> == i@iron_axe || <player.item_in_hand> == i@gold_axe || <player.item_in_hand> == i@diamond_axe {
        - random {
          - narrate "<gold>%Player% <red>chops off <gold>%Target%<red>’s head with %Gender% axe"
          - narrate "<gold>%Player% <red>decapitates <gold>%Target%<red> with %Gender% axe"
          - narrate "<gold>%Player% <red>cleaves <gold>%Target%<red> with an axe"
          - narrate "<gold>%Player% <red>butchers <gold>%Target%<red> with %Gender% axe"
          }
# Bow kill messages
        } else if <player.item_in_hand> == i@bow {
        - random {
          - narrate "<gold>%Player% <red>pierces <gold>%Target%<red>'s heart with an arrow"
          - narrate "<gold>%Player% <red>peppers <gold>%Target%<red>'s body with arrows"
          }
# Unarmed kill messages
        } else {
        - random {
          - narrate "<gold>%Player% <red>asphyxiates <gold>%Target%<red>, leaving their body on the ground."
          - narrate "<gold>%Player% <red>strangles <gold>%Target%<red> until they are no longer moving."
          - narrate "<gold>%Player% <red>brutalizes <gold>%Target%<red> and leaves the lifeless body on the ground."
          - narrate "<gold>%Player% <red>forces <gold>%Target%<red>'s neck breaking their spine and allowing their body to slump to the ground."
          }
        }
      - adjust <server.match_player[%Target%]> health:0
      - flag player Murders:++
      - flag <server.match_player[%Target%]> Killed_By:%Player%







Fight_Escape:
    type: task
    Script:
      - define Fight <player.flag[Fight]>
      - define Target <server.match_player[<player.flag[Target]>].flag[Character]>
      - flag player Fight_Turn:!
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Dodged:!
      - flag player Fight_Blocked:!
      - flag player Fight_Weapon:!
      - flag player Fight_CD:!
      - flag player Fight_Leader_Warning:!
      - flag player Health:!
      - flag player Fight_Unhealthy_Start:!
      - flag player Weapon_Type:!
      - flag player Defender_First_Turn:!
      - flag player Fight_Winner:!
      - flag player Fight:!
      - flag player Target:!
# Check if there's anyone else left in the fight.
      - if <global.flag[Fighters_%Fight%].size> > 1 {
# Do nothing
        } else {
# If this concludes the end of the fight, remove your target's flags as well
        - flag global Fighters_<player.flag[Fight]>:!
        - flag server Fight_Turn_Counter_%Fight%:!
        - flag <server.match_player[%Target%]> Fight:!
        - flag <server.match_player[%Target%]> Fight_Turn:!
        - flag <server.match_player[%Target%]> Attack:!
        - flag <server.match_player[%Target%]> Fight_Attack:!
        - flag <server.match_player[%Target%]> Fight_Dodged:!
        - flag <server.match_player[%Target%]> Fight_Blocked:!
        - flag <server.match_player[%Target%]> Fight_Weapon:!
        - flag <server.match_player[%Target%]> Fight_CD:!
        - flag <server.match_player[%Target%]> Fight_Leader_Warning:!
        - flag <server.match_player[%Target%]> Health:!
        - flag <server.match_player[%Target%]> Fight_Unhealthy_Start:!
        - flag <server.match_player[%Target%]> Weapon_Type:!
        - flag <server.match_player[%Target%]> Defender_First_Turn:!
        - flag <server.match_player[%Target%]> Fight_Winner:!
        }











# +----------------------------------
# |   Other Task Scripts
# +----------------------------------

Fight_First_Turn_Attacker:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - define Fight <player.flag[Fight]>
      - flag player Fight_Turn
      - flag server Fight_Turn_Counter_%Fight%:1
      - random {
        - narrate "<gold>%Player% <blue>gets the first turn" targets:<player.location.find.players.within[10]>
        }

Fight_First_Turn_Defender:
    type: task
    Script:
      - define Player <player.flag[Character]>
      - define Fight <player.flag[Fight]>
      - flag <server.match_player[<player.flag[target]>]> Fight_Turn
      - flag server Fight_Turn_Counter_%Fight%:2
      - flag player First_Turn
      - random {
        - narrate "<gold><player.flag[Target]> <blue>gets the first turn" targets:<player.location.find.players.within[10]>
        }


Fight_Not_Your_Turn:
    type: task
    Script:
      - random {
        - narrate "<red>It's not your turn to fight, please wait."
        - narrate "<red>Please be patient and wait for your turn."
        }

Fight_Cant_Fight:
    type: task
    Script:
      - random {
        - narrate "<red>You're too wounded to fight. Please wait <player.flag[fight_CD]>"
        }

Fight_Damage:
    type: task
    Script:
# [Temporary] confirmation that you are going to be damaged
      - narrate "<red> You were damaged"
      - define Player <player.flag[Character]>
      - if <player.flag[Fight_Attack]> != null {
        - if <player.flag[Fight_Attack]> == 1 {
          - flag player health:-:1
          - if <player.flag[health]> <= 0 {
# This if statements just fixes a selecting error in sublime. Making it look nicer when editing
            - if 1 > 2
            - narrate "<dark_red>YOU LOST"
            - run Fight_Lost
            - queue clear
            }
# Setting the actual health of the player to how much health they are supposed to have left
            - adjust <player> health:<player.flag[Health]>
# Setting the hunger of the player to 10(half) -  so they don't regenerate health.
            - adjust <player> food_level:10
            - narrate "<red>%Player% lost <gold>1 <red>health" targets:<player.location.find.players.within[10]>
          }
        - if <player.flag[Fight_Attack]> == 2 {
          - flag player health:-:2
          - if <player.flag[health]> <= 0 {
            - if 1 > 2
            - narrate "<dark_red>YOU LOST"
            - run Fight_Lost
            - queue clear
            }
            - adjust <player> health:<player.flag[Health]>
            - adjust <player> food_level:10
            - narrate "<red>%Player% lost <gold>2 <red> health" targets:<player.location.find.players.within[10]>
          }
        - if <player.flag[Fight_Attack]> == 3 {
          - flag player health:-:3
          - if <player.flag[health]> <= 0 {
            - if 1 > 2
              - narrate "<dark_red>YOU LOST"
              - run Fight_Lost
              - queue clear
              }
            - adjust <player> health:<player.flag[Health]>
            - adjust <player> food_level:10
            - narrate "<red>%Player% lost <gold>3 <red> health" targets:<player.location.find.players.within[10]>
          }
        - if <player.flag[Fight_Attack]> == 4 {
          - flag player health:-:4
          - if <player.flag[health]> <= 0 {
            - if 1 > 2
            - narrate "<dark_red>YOU LOST"
            - run Fight_Lost
            - queue clear
            }
            - adjust <player> health:<player.flag[Health]>
            - adjust <player> food_level:10
            - narrate "<red>%Player% lost <gold>4 <red> health" targets:<player.location.find.players.within[10]>
          }
        - if <player.flag[Fight_Attack]> == 5 {
          - flag player health:-:5
          - if <player.flag[health]> <= 0 {
            - if 1 > 2
            - narrate "<dark_red>YOU LOST"
            - run Fight_Lost
            - queue clear
            }
            - adjust <player> health:<player.flag[Health]>
            - adjust <player> food_level:10
            - narrate "<red>%Player% lost <gold>5 <red> health" targets:<player.location.find.players.within[10]>
          }
        - flag player Fight_Attack:!
        }
      - flag player Attack:!


Fight_Dodge:
    type: task
    Script:
# Defining stuff, for narrates
      - define Player <player.flag[Character]>
      - define Attacker <player.flag[Attack]>
      - define Weapon <player.flag[Fight_Weapon]>
# Removing attack flags, so they won't get damaged
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Shoot:!
      - flag player Fight_Throw:!
      - flag player Fight_Weapon:!
      - if %Weapon% == Unarmed {
        - narrate "<gold>%Player% <blue>quickly moves out of reach as he was nearly struck by <gold>%Attacker%" targets:<player.location.find.players.within[10]>
        } else {
        - random {
          - narrate "<gold>%Player% <blue>quickly moves out of reach as he was nearly struck by <gold>%Attacker%’s <blue>%Weapon%" targets:<player.location.find.players.within[10]>
          }
        }
      - narrate "<blue>It's still <gold>%Player%'s <blue>turn" targets:<player.location.find.players.within[10]>

Fight_Dodge_Fall:
    type: task
    Script:
# Defining stuff, for narrates and flags
      - define Player <player.flag[Character]>
      - define Attacker <player.flag[Attack]>
      - define Weapon <player.flag[Fight_Weapon]>
      - define Fight <player.flag[Fight]>
      - if <player.flag[Gender]> == Male {
        - define Gender his
        } else {
        - define Gender her
        }
# Removing attack flags, so they won't get damaged
      - flag player Attack:!
      - flag player Fight_Attack:!
      - flag player Fight_Weapon:!
      - flag player Fight_Shoot:!
      - flag player Fight_Throw:!
# Explains what happened
      - random {
        - narrate "<gold>%Player% <blue>barely dodges the %Weapon%, but falls over, losing %Gender% turn" targets:<player.location.find.players.within[10]>
        }
      - define Random <util.random.int[1].to[100]>
      - if %Random% > 80 {
        } else {
        - random {
          - repeat 1 {
            - flag player health:-:1
            - define Fall_Damage 1
            }
          - repeat 1 {
            - flag player health:-:2
            - define Fall_Damage 2
            }
          }
        - if <player.flag[health]> <= 0 {
          - if 1 > 2
          - narrate "<dark_red>YOU LOST"
          - run Fight_Lost
          - queue clear
          }
          - adjust <player> health:<player.flag[Health]>
          - adjust <player> food_level:10
          - narrate "<gold>%Player% <blue>lost <red>%Fall_Damage% <blue>health from falling over" targets:<player.location.find.players.within[10]>
        }
# Player loses their turn.
      - flag player Fight_Turn:!
#      - flag server Fight_Turn_Counter_%Fight%:++
      - run Fight_Turn_Chooser

Fight_Turn_Chooser:
    type: task
    Script:
# Defining %Fight% and %Fight_Turn_Counter% for use inside tags
      - define Fight <player.flag[Fight]>
      - flag server Fight_Turn_Counter_%Fight%:++
      - define Fight_Turn_Counter <server.flag[Fight_Turn_Counter_%Fight%].as_int>

# Checking if the Fight_Turn_Counter number is bigger than the amount of players in the fight
      - if <server.flag[Fight_Turn_Counter_%Fight%]> > <global.flag[Fighters_%Fight%].size> {
# If it's bigger than the amount of players, resetting it to "1"
        - flag server Fight_Turn_Counter_%Fight%:1
# Flagging the first player with their turn
        - flag <server.match_player[<global.flag[Fighters_%Fight%].get[1].as_list.formatted>]> Fight_Turn
# [Temporary] Confirmation that it worked.
        - narrate "<blue>Giving the turn to first player<&co> <gold><global.flag[Fighters_%Fight%].get[1].as_list.formatted>" Targets:<player.location.find.players.within[10]>

# If there's more players in the fight than the current turn counter number. Find the next player
        } else {
# Flagging the next player with their Turn
        - flag <server.match_player[<global.flag[Fighters_%Fight%].get[%Fight_Turn_Counter%].as_list.formatted>]> Fight_Turn
# [Temporary] Confirmation that it worked.
        - narrate "<blue>Giving the turn to<&co> <gold><global.flag[Fighters_%Fight%].get[%Fight_Turn_Counter%].as_list.formatted>" Targets:<player.location.find.players.within[10]>
        }