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

#<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 {
# 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 !p@<context.parsed_args.get[1]>.is_online {
            - if p@<context.parsed_args.get[1]>.is_online {
              - 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[<context.parsed_args.get[1].location>]> > 10 {
              - if <player.location.distance[<context.parsed_args.get[1].location>]> < 1 {
                - narrate "<red>You're too far away to initiate a fight"
                } else {

# Checking if player is already in a fight
                - if <player.flag[Fight]> {
                  - 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 <p@<context.parsed_args.get[1]>.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:<context.parsed_args.get[1]>
                    - flag p@<player.flag[Target]> Target:<player.name>

# assigning Unique fight name to the players
                    - flag player Fight:<player.name>
                    - flag p@<player.flag[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 p@<player.flag[Target]> health:<player.health.scale>
                    - if <p@<player.flag[Target]>.flag[health]> < 20 {
                      - flag p@<player.flag[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:p@<player.flag[target]>
                    - narrate "<red>| <blue>Starting fight with<&co> <red><player.name>" targets:p@<player.flag[target]>
                    - narrate "<red>+-----------------------------------------------------+" targets:p@<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 !<p@<context.parsed_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 <p@<context.parsed_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]> {
          - if <player.flag[Fight_Attack]> {
            - if <player.flag[Fight_Attack]> == 1 {
              - flag player health:-:1
              - if <player.flag[health]> =< 0 {
                - narrate "<dark_red>YOU LOST"
                - run Fight_Dead
                - queue clear
                }
              - adjust <player> health:<player.flag[Health]>
              - narrate "<red>1 damage" targets:<player.location.find.players.within[10]>
              }
            - if <player.flag[Fight_Attack]> == 2 {
              - flag player health:-:2
              - if <player.flag[health]> =< 0 {
                - narrate "<dark_red>YOU LOST"
                - run Fight_Dead
                - queue clear
                }
              - adjust <player> health:<player.flag[Health]>
              - narrate "<red>2 damage" targets:<player.location.find.players.within[10]>
              }
            - if <player.flag[Fight_Attack]> == 3 {
              - flag player health:-:3
              - if <player.flag[health]> =< 0 {
                - narrate "<dark_red>YOU LOST"
                - run Fight_Dead
                - queue clear
                }
              - adjust <player> health:<player.flag[Health]>
              - narrate "<red>3 damage" targets:<player.location.find.players.within[10]>
              }
            - if <player.flag[Fight_Attack]> == 4 {
              - flag player health:-:4
              - if <player.flag[health]> =< 0 {
                - narrate "<dark_red>YOU LOST"
                - run Fight_Dead
                - queue clear
                }
              - adjust <player> health:<player.flag[Health]>
              - narrate "<red>4 damage" targets:<player.location.find.players.within[10]>
              }
            - if <player.flag[Fight_Attack]> == 5 {
              - flag player health:-:5
              - if <player.flag[health]> =< 0 {
                - narrate "<dark_red>YOU LOST"
                - run Fight_Dead
                - queue clear
                }
              - adjust <player> health:<player.flag[Health]>
              - narrate "<red>5 damage" targets:<player.location.find.players.within[10]>
              }
            - flag player Fight_Attack:!
            }
          - wait 2
          - flag player Attack:!
          } else {

# 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 {
                - run Fight_Attack_Wood_Sword
                } else {
                - if <player.item_in_hand> == i@stone_sword {
                  - run Fight_Attack_Stone_Sword
                  } else {
                  - if <player.item_in_hand> == i@iron_sword {
                    - run Fight_Attack_Iron_Sword
                    } else {
                    - if <player.item_in_hand> == i@gold_sword || i@diamond_sword {
                      - run Fight_Attack_Gold_Sword
                      } else {
                      - if <player.item_in_hand> == i@wood_axe {
                        - run Fight_Attack_Wood_Axe
                        } else {
                        - if <player.item_in_hand> == i@stone_axe {
                          - run Fight_Attack_Stone_Axe
                          } else {
                          - if <player.item_in_hand> == i@iron_axe {
                            - run Fight_Attack_Iron_Axe
                            } else {
                            - if <player.item_in_hand> == i@gold_axe || i@diamond_axe {
                              - run Fight_Attack_Gold_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"

# Adding one to the turn counter
              - flag server Fight_Turn_Counter_%Fight%:++

# Running the task script that determines who's turn it is.
              - run Fight_Turn_Chooser
              }
            }
          }



# +----------------------------------
# |   Shoot
# +----------------------------------
        on Shoot command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {
#Check for Bow
#Check for CrossBow
            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "You need to be in a fight to use these commands"
          }
# +----------------------------------
# |   Throw
# +----------------------------------
        on Throw command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {
#Check for Daggers
            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "You need to be in a fight to use these commands"
          }
# +----------------------------------
# |   Dodge
# +----------------------------------
        on Dodge command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {
            - run Fight_Dodge
            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "You need to be in a fight to use these commands"
          }
# +----------------------------------
# |   Block
# +----------------------------------
        on Block command:
        - determine passively fulfilled
        - if <player.flag[Target]> {
          - if <player.flag[Fight_Turn]> {

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

            } else {
            - run Fight_Not_Your_Turn
            }
          } else {
          - narrate "You need to be in a fight to use these commands"
          }

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

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

          } else {
          - narrate "You need to be in a fight to use these commands"
          }
# +----------------------------------
# |   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

        on mame command:
        - determine passively fulfilled

        on knock out command:
        - determine passively fulfilled

        on leave command:
        - determine passively fulfilled

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

# Adding one to the turn counter
        - flag server Fight_Turn_Counter_%Fight%:++

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

# 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:!
        - narrate "<red>All Fight information Deleted"
































# +----------------------------------
# |   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[1].to[100]> - 20
        - 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[1].to[100]> - 20
        - 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]>
        }

# Checking the random number, to determine the amount of damage it will hit for.
      - if %random% =< 20 {
        - narrate "rolled %random%"
        - run Fight_Attack_0

        } else if %random% > 20 && =< 40 {
        - narrate "rolled %random%"
        - run Fight_Attack_1

        } else if %random% > 40 && =< 60 {
        - narrate "rolled %random%"
        - run Fight_Attack_2

        } else if %random% > 60 && =< 80 {
        - narrate "rolled %random%"
        - run Fight_Attack_3

        } else if %random% > 80 && =< 100 {
        - narrate "rolled %random%"
        - run Fight_Attack_4
        }

#      - random {
#          - run Fight_Attack_0
#          - run Fight_Attack_0
#          - run Fight_Attack_1
#          - run Fight_Attack_1
#          - run Fight_Attack_1
#          - run Fight_Attack_1
#          - run Fight_Attack_2
#          - run Fight_Attack_2
#          - run Fight_Attack_2
#          - run Fight_Attack_2
#          - run Fight_Attack_3
#          - run Fight_Attack_3
#          }

Fight_Attack_Wood_sword:
    type: task
    Script:
      - narrate "Wood_Sword"
      - random {
          - run Fight_Attack_Wood_Sword_0
          - run Fight_Attack_Wood_Sword_0
          - run Fight_Attack_Wood_Sword_1
          - run Fight_Attack_Wood_Sword_1
          - run Fight_Attack_Wood_Sword_1
          - run Fight_Attack_Wood_Sword_1
          - run Fight_Attack_Wood_Sword_2
          - run Fight_Attack_Wood_Sword_2
          - run Fight_Attack_Wood_Sword_2
          - run Fight_Attack_Wood_Sword_2
          - run Fight_Attack_Wood_Sword_3
          - run Fight_Attack_Wood_Sword_3
          }

Fight_Attack_Stone_sword:
    type: task
    Script:
      - narrate "Stone_Sword"
      - random {
        - run Fight_Attack_Stone_Sword_0
        - run Fight_Attack_Stone_Sword_1
        - run Fight_Attack_Stone_Sword_1
        - run Fight_Attack_Stone_Sword_1
        - run Fight_Attack_Stone_Sword_1
        - run Fight_Attack_Stone_Sword_2
        - run Fight_Attack_Stone_Sword_2
        - run Fight_Attack_Stone_Sword_2
        - run Fight_Attack_Stone_Sword_2
        - run Fight_Attack_Stone_Sword_3
        - run Fight_Attack_Stone_Sword_3
        - run Fight_Attack_Stone_Sword_4
        }

Fight_Attack_Iron_sword:
    type: task
    Script:
      - narrate "Iron_Sword"
      - random {
        - run Fight_Attack_Iron_Sword_0
        - run Fight_Attack_Iron_Sword_1
        - run Fight_Attack_Iron_Sword_1
        - run Fight_Attack_Iron_Sword_1
        - run Fight_Attack_Iron_Sword_2
        - run Fight_Attack_Iron_Sword_2
        - run Fight_Attack_Iron_Sword_2
        - run Fight_Attack_Iron_Sword_3
        - run Fight_Attack_Iron_Sword_3
        - run Fight_Attack_Iron_Sword_4
        - run Fight_Attack_Iron_Sword_4
        - run Fight_Attack_Iron_Sword_5
        }

Fight_Attack_Gold_sword:
    type: task
    Script:
      - narrate "Gold_Sword"
      - random {
        - run Fight_Attack_Gold_Sword_0
        - run Fight_Attack_Gold_Sword_1
        - run Fight_Attack_Gold_Sword_1
        - run Fight_Attack_Gold_Sword_2
        - run Fight_Attack_Gold_Sword_2
        - run Fight_Attack_Gold_Sword_2
        - run Fight_Attack_Gold_Sword_3
        - run Fight_Attack_Gold_Sword_3
        - run Fight_Attack_Gold_Sword_4
        - run Fight_Attack_Gold_Sword_4
        - run Fight_Attack_Gold_Sword_5
        - run Fight_Attack_Gold_Sword_5
      }

Fight_Attack_Diamond_sword:
    type: task
    Script:
      - narrate "Diamond_Sword"
      - random {
        - run Fight_Attack_Diamond_Sword_0
        - run Fight_Attack_Diamond_Sword_1
        - run Fight_Attack_Diamond_Sword_1
        - run Fight_Attack_Diamond_Sword_2
        - run Fight_Attack_Diamond_Sword_2
        - run Fight_Attack_Diamond_Sword_2
        - run Fight_Attack_Diamond_Sword_3
        - run Fight_Attack_Diamond_Sword_3
        - run Fight_Attack_Diamond_Sword_4
        - run Fight_Attack_Diamond_Sword_4
        - run Fight_Attack_Diamond_Sword_5
        - run Fight_Attack_Diamond_Sword_5
      }

# +----------------------------------
# |   Attack Messages (no Weapon)
# +----------------------------------

Fight_Attack_0:
    type: task
    Script:
      - random {
        - narrate "NW miss0" targets:<player.location.find.players.within[10]>
        - narrate "NW miss1" targets:<player.location.find.players.within[10]>
        - narrate "NW miss2" targets:<player.location.find.players.within[10]>
        - narrate "NW miss3" targets:<player.location.find.players.within[10]>
        - narrate "NW miss4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_1:
    type: task
    Script:
      - flag p@<player.flag[target]> Attack:<player.name>
      - flag p@<player.flag[target]> Fight_attack:1
      - random {
        - narrate "NW 1" targets:<player.location.find.players.within[10]>
        - narrate "NW 1" targets:<player.location.find.players.within[10]>
        - narrate "NW 1" targets:<player.location.find.players.within[10]>
        - narrate "NW 1" targets:<player.location.find.players.within[10]>
        - narrate "NW 1" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_2:
    type: task
    Script:
      - flag p@<player.flag[target]> Attack:<player.name>
      - flag p@<player.flag[target]> Fight_attack:2
      - random {
        - narrate "NW 2" targets:<player.location.find.players.within[10]>
        - narrate "NW 2" targets:<player.location.find.players.within[10]>
        - narrate "NW 2" targets:<player.location.find.players.within[10]>
        - narrate "NW 2" targets:<player.location.find.players.within[10]>
        - narrate "NW 2" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_3:
    type: task
    Script:
      - flag p@<player.flag[target]> Attack:<player.name>
      - flag p@<player.flag[target]> Fight_attack:3
      - random {
        - narrate "NW 3" targets:<player.location.find.players.within[10]>
        - narrate "NW 3" targets:<player.location.find.players.within[10]>
        - narrate "NW 3" targets:<player.location.find.players.within[10]>
        - narrate "NW 3" targets:<player.location.find.players.within[10]>
        - narrate "NW 3" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_4:
    type: task
    Script:
      - flag p@<player.flag[target]> Attack:<player.name>
      - flag p@<player.flag[target]> Fight_attack:4
      - random {
        - narrate "NW 4" targets:<player.location.find.players.within[10]>
        - narrate "NW 4" targets:<player.location.find.players.within[10]>
        - narrate "NW 4" targets:<player.location.find.players.within[10]>
        - narrate "NW 4" targets:<player.location.find.players.within[10]>
        - narrate "NW 4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_5:
    type: task
    Script:
      - flag p@<player.flag[target]> Attack:<player.name>
      - flag p@<player.flag[target]> Fight_attack:5
      - random {
        - narrate "NW 5" targets:<player.location.find.players.within[10]>
        - narrate "NW 5" targets:<player.location.find.players.within[10]>
        - narrate "NW 5" targets:<player.location.find.players.within[10]>
        - narrate "NW 5" targets:<player.location.find.players.within[10]>
        - narrate "NW 5" targets:<player.location.find.players.within[10]>
        }

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

Fight_Attack_Wood_Sword_0:
    type: task
    Script:
      - random {
        - narrate "Wood_Sword miss0" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword miss1" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword miss2" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword miss3" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword miss4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Wood_Sword_1:
    type: task
    Script:
      - random {
        - narrate "Wood_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 1" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Wood_Sword_2:
    type: task
    Script:
      - random {
        - narrate "Wood_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 2" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Wood_Sword_3:
    type: task
    Script:
      - random {
        - narrate "Wood_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 3" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Wood_Sword_4:
    type: task
    Script:
      - random {
        - narrate "Wood_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Wood_Sword_5:
    type: task
    Script:
      - random {
        - narrate "Wood_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Wood_Sword 5" targets:<player.location.find.players.within[10]>
        }

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

Fight_Attack_Stone_Sword_0:
    type: task
    Script:
      - random {
        - narrate "Stone_Sword miss0" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword miss1" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword miss2" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword miss3" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword miss4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Stone_Sword_1:
    type: task
    Script:
      - random {
        - narrate "Stone_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 1" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Stone_Sword_2:
    type: task
    Script:
      - random {
        - narrate "Stone_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 2" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Stone_Sword_3:
    type: task
    Script:
      - random {
        - narrate "Stone_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 3" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Stone_Sword_4:
    type: task
    Script:
      - random {
        - narrate "Stone_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Stone_Sword_5:
    type: task
    Script:
      - random {
        - narrate "Stone_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Stone_Sword 5" targets:<player.location.find.players.within[10]>
        }
# +----------------------------------
# |   Attack Messages (Iron_Sword)
# +----------------------------------

Fight_Attack_Iron_Sword_0:
    type: task
    Script:
      - random {
        - narrate "Iron_Sword miss0" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword miss1" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword miss2" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword miss3" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword miss4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Iron_Sword_1:
    type: task
    Script:
      - random {
        - narrate "Iron_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 1" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Iron_Sword_2:
    type: task
    Script:
      - random {
        - narrate "Iron_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 2" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Iron_Sword_3:
    type: task
    Script:
      - random {
        - narrate "Iron_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 3" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Iron_Sword_4:
    type: task
    Script:
      - random {
        - narrate "Iron_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Iron_Sword_5:
    type: task
    Script:
      - random {
        - narrate "Iron_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Iron_Sword 5" targets:<player.location.find.players.within[10]>
        }

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

Fight_Attack_Gold_Sword_0:
    type: task
    Script:
      - random {
        - narrate "Gold_Sword miss0" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword miss1" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword miss2" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword miss3" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword miss4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Gold_Sword_1:
    type: task
    Script:
      - random {
        - narrate "Gold_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 1" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Gold_Sword_2:
    type: task
    Script:
      - random {
        - narrate "Gold_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 2" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Gold_Sword_3:
    type: task
    Script:
      - random {
        - narrate "Gold_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 3" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Gold_Sword_4:
    type: task
    Script:
      - random {
        - narrate "Gold_Sword Gold_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Gold_Sword_5:
    type: task
    Script:
      - random {
        - narrate "Gold_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Gold_Sword 5" targets:<player.location.find.players.within[10]>
        }

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

Fight_Attack_Diamond_Sword_0:
    type: task
    Script:
      - random {
        - narrate "Diamond_Sword miss0" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword miss1" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword miss2" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword miss3" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword miss4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Diamond_Sword_1:
    type: task
    Script:
      - random {
        - narrate "Diamond_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 1" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 1" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Diamond_Sword_2:
    type: task
    Script:
      - random {
        - narrate "Diamond_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 2" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 2" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Diamond_Sword_3:
    type: task
    Script:
      - random {
        - narrate "Diamond_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 3" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 3" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Diamond_Sword_4:
    type: task
    Script:
      - random {
        - narrate "Diamond_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 4" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 4" targets:<player.location.find.players.within[10]>
        }
Fight_Attack_Diamond_Sword_5:
    type: task
    Script:
      - random {
        - narrate "Diamond_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 5" targets:<player.location.find.players.within[10]>
        - narrate "Diamond_Sword 5" targets:<player.location.find.players.within[10]>
        }
























































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

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

Fight_First_Turn_Defender:
    type: task
    Script:
      - flag p@<context.parsed_args.get[1].as_player> Fight_Turn
      - flag server Fight_Turn_Counter_%Fight%:2
      - random {
        - narrate "<gold><player.name> <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_Turn_Chooser:
    type: task
    Script:
# Defining %Fight% and %Fight_Turn_Counter% for use inside tags
      - define Fight <player.flag[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
# [Temporary] Confirmation that it worked.
        - narrate "<dark_red>Resetting Fight_Turn_Counter_%Fight% to 1"
# Flagging the first player with their turn
        - flag p@<global.flag[Fighters_%Fight%].get[1].as_list.formatted> Fight_Turn
# [Temporary] Confirmation that it worked.
        - narrate "<dark_red>Giving the turn to first player<&co> <global.flag[Fighters_%Fight%].get[1].as_list.formatted>"

# 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 p@<global.flag[Fighters_%Fight%].get[%Fight_Turn_Counter%].as_list.formatted> Fight_Turn
# [Temporary] Confirmation that it worked.
        - narrate "<dark_red>Giving the turn to<&co> <global.flag[Fighters_%Fight%].get[%Fight_Turn_Counter%].as_list.formatted>"
        }