# +----------------------------------
# |   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)

# Attack
# Fight_Attack
# Fight_Dodged
# Fight_Blocked
# Fight_Weapon

#<li@list.size> (returns the size of the list)
#<li@list.include[...|...]>
#.include[three|four]
#<player.location.distance[<player2.location>]> < 5
#- adjust <player> health:1
#- queue delay:5t 

Fight_Script:
    type: world
    events:
# +----------------------------------
# |   Fight Start
# +----------------------------------
        on fight command:
        - determine passively fulfilled


# +- 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!"
          } else {
          - define Target <context.args.get[1]>
# Checking that they aren't on a fight Cooldown
          - if <player.flag[Fight_CD]> {
            - run Fight_Cant_Fight
            } else {
# 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"
              } else {
# 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"
                } else {

# 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"
                  } else {

                  - if <player.flag[Leader_Warning]> {
                    - narrate "<red>RUN LEADER THINGY"
                    }
# 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 Leader_Warning
                    } else {
# +----------------------------------


# 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]>

# 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
# +----------------------------------
        on Target command:
        - determine passively fulfilled
# 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!"
          } else {
# 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"
            } else {
# 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."
              } else {
# Setting new target
              - flag player Target:<context.parsed_args.get[1]>
              - narrate "<blue>You've targeted<&co> <gold><player.flag[Target]>."
              }
            }
          }

# +----------------------------------
# |   Attack
# +----------------------------------
        on attack command:
        - determine passively fulfilled
# Defining %Fight% for use inside tags
        - define Fight <player.flag[Fight]>

# 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"
          } else {

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

# Removing the players turn
            - flag player Fight_Turn:!

# 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
              } else if <player.item_in_hand> == i@stone_sword {
              - flag player Weapon_Type:stone
              - run Fight_Attack_Stone_sword
              } else if <player.item_in_hand> == i@iron_sword {
              - flag player Weapon_Type:iron
              - run Fight_Attack_Iron_sword
              } else if <player.item_in_hand> == i@gold_sword {
              - flag player Weapon_Type:golden
              - run Fight_Attack_Gold_sword
              } else if <player.item_in_hand> == i@diamond_sword {
              - flag player Weapon_Type:diamond
              - run Fight_Attack_Diamond_sword
              } else if <player.item_in_hand> == i@wood_axe {
              - flag player Weapon_Type:wooden
              - run Fight_Attack_Wood_Axe
              } else if <player.item_in_hand> == i@stone_axe {
              - flag player Weapon_Type:stone
              - run Fight_Attack_Stone_Axe
              } else if <player.item_in_hand> == i@iron_axe {
              - flag player Weapon_Type:iron
              - run Fight_Attack_Iron_Axe
              } else if <player.item_in_hand> == i@gold_axe {
              - flag player Weapon_Type:gold
              - run Fight_Attack_Gold_Axe
              } else if <player.item_in_hand> == i@diamond_axe {
              - flag player Weapon_Type:diamond
              - run Fight_Attack_Diamond_Axe
              } else {
# If they don't have a weapon, normal attack is used.
              - run Fight_Attack
              }
# [Temporary] Confirmation that it worked.
            - narrate "<red>YOU ATTACK"
            }
          }



# +----------------------------------
# |   Shoot
# +----------------------------------
        on Shoot command:
        - determine passively fulfilled
        - if <player.flag[Fight]> {
          - if <player.flag[Fight_Turn]> {
#Check for Bow
#Check for CrossBow
            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "<red>You need to be in a fight to use the Shoot command"
          }
# +----------------------------------
# |   Throw
# +----------------------------------
        on Throw command:
        - determine passively fulfilled
        - if <player.flag[Fight]> {
          - if <player.flag[Fight_Turn]> {
#Check for Daggers
            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "<red>You need to be in a fight to use the Throw command"
          }
# +----------------------------------
# |   Dodge
# +----------------------------------
        on Dodge command:
        - determine passively fulfilled
# Checking if player is in a fight
        - if <player.has_flag[Fight]> !true {
          - narrate "<red>You need to be in a fight to use the dodge command"
          } else {
# Checking if it's their turn
          - if !<player.flag[Fight_Turn]> {
            - run Fight_Not_Your_Turn 
            } else {
# Checking if they have been attacked
            - if !<player.has_flag[Attack]> {
              - narrate "<red>There's nothing to dodge."
              } else {
# Defining a random number between 0 and 100
              - define Random <util.random.int[0].to[100]>
              - define Player <player.name>
# 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:!
#                    - flag server Fight_Turn_Counter_%Fight%:++
                    - run Fight_Turn_Chooser
                    }
                  }
                }
              }
            }
          }

# +----------------------------------
# |   Block
# +----------------------------------
        on Block command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {

            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "<red>You need to be in a fight to use the Block command"
          }
# +----------------------------------
# |   Taunt
# +----------------------------------
        on Taunt command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {

            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "<red>You need to be in a fight to use the Taunt command"
          }

# +----------------------------------
# |   Escape
# +----------------------------------
        on escape command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {

            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "<red>You need to be in a fight to use the Escape command"
          }
# +----------------------------------
# |   forfeit
# +----------------------------------
        on Cancel command:
        - determine passively fulfilled
        - if <player.flag[Target]> {

          } else {
          - narrate "<red>You need to be in a fight to use the Cancel command"
          }
# +----------------------------------
# |   Roll
# +----------------------------------
        on roll command:
        - determine passively fulfilled
        - narrate "<blue><player.name> Rolled<&co> <gold><util.random.int[1].to[100]>" targets:<player.location.find.players.within[10]>

# +----------------------------------
# |   Winner Commands
# +----------------------------------
        on kill command:
        - determine passively fulfilled
        - if <player.flag[Fight_Winner]> {
          - if <player.flag[VA_Kill]> {
            - execute as_server "kill <player.flag[Target]>"
            } else {
            - narrate "<red>You don't have an accepted VA to kill"
            }
          }


        on capture command:
        - determine passively fulfilled
        - if <player.flag[Fight_Winner]> {
          }
        on mame command:
        - determine passively fulfilled
        - if <player.flag[Fight_Winner]> {
          }
        on knockout command:
        - determine passively fulfilled
        - if <player.flag[Fight_Winner]> {
          }
        on mercy command:
        - determine passively fulfilled
        - if <player.flag[Fight_Winner]> {
          - define Fight <player.flag[Fight]>
          - if <player.flag[Fight_Winner]> {
            - narrate "<blue><player.name> shows <player.flag[Target]> mercy" targets:<player.location.find.players.within[10]>
            - flag <server.match_player[<player.flag[Target]>]> Fight:!
            - flag <server.match_player[<player.flag[Target]>]> Fight_Turn:!
            - flag <server.match_player[<player.flag[Target]>]> Target:!
            - flag player Target:!
            - flag player Fight_Winner:!
            - if 1 > 2
            - if <global.flag[Fighters_%Fight%].size> > 1 {
# Do nothing
            } else {
            - flag global Fighters_<player.flag[Fight]>:!
            - flag server Fight_Turn_Counter_%Fight%:!
            - flag player Fight:!
            }

# Check if there's more than 1 person left in the fight. If not end it. If there is, start new turn.
            }
          } else {
          - narrate "<red>Only fight winners can use the mercy command"
          }

# +----------------------------------
# |   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 Next_Turn
# +----------------------------------
        on Fight_Next_Turn command:
# Forces the next turn
        - determine passively fulfilled
# Defining %Fight% for use inside tags
        - define Fight <player.flag[Fight]>

# [Temporary] Confirmation that it worked.
        - narrate "<red>Forcing a new turn"
        - flag player Fight_Turn:!

# Running the task script that determines who's turn it is.
        - run Fight_Turn_Chooser
# +----------------------------------
# |   Fight Reset
# +----------------------------------
        on Fight_Reset command:
# Reset everything
        - determine passively fulfilled

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

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

        - flag player Fight:!
        - flag player Fight_Turn:!
        - flag player 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 {
        - run Fight_Unarmed_Miss_Messages
        - flag <server.match_player[<player.flag[target]>]> Attack:!
        - flag <server.match_player[<player.flag[target]>]> Fight_Weapon:!

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

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

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

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

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

# +----------------------------------
# |  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:!

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

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

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

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

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

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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Sword_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - 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:!

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

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

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

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

        } else if %random% > 95 && %random% <= 100 {
        - flag <server.match_player[<player.flag[target]>]> Fight_Attack:5
        - run Fight_Axe_Attack_Messages
        - 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:!

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

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

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

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

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



























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

Fight_Unarmed_Miss_Messages:
    type: task
    Script:
      - define Player <player.name>
      - 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.name>
      - 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


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

Fight_Axe_Miss_Messages:
    type: task
    Script:
      - define Player <player.name>
      - 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.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>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


















# +----------------------------------
# |   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..."
      - flag global Fighters_%Fight%:<-:<player.flag[Target]>
      - if 1 > 2
      - if <player.flag[Fight_Turn]> {
        - flag player Fight_Turn:!
#        - flag server Fight_Turn_Counter_%Fight%:++
        - run Fight_Turn_Chooser
      }
      - 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."
        }



























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

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

Fight_First_Turn_Defender:
    type: task
    Script:
      - define Fight <player.flag[Fight]>
      - flag <server.match_player[<player.flag[target]>]> Fight_Turn
      - flag server Fight_Turn_Counter_%Fight%:2
      - 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.name>
      - 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.name>
      - 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.name>
      - 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]>
        }