### Flags
# Teams_Groups:
# Teams_Group_Name_Kills:
# Teams_Group_Name_Deaths:
# Teams_Group_Name_Rank:
# Teams_Group_Name_Members:
# Teams_Group_Name_MaxMembers:
# Teams_Group_Name_Leaders:
# Teams_Group_Name_Owner:
# Teams_Group_Name_Created:
# Teams_Group_Name_Bank:
# Teams_Player_Group:
# Teams_Player_Menu_Respond:
# Teams_Player_Pending:
# Teams_Player_Chat:


# Groups.Group.Name.Members
# Groups.Group.Name.MaxMembers
# Groups.Group.Name.Leaders
# Groups.Group.Name.Owner
# Groups.Group.Name.Created

# Groups.Group.Name.Description
# Groups.Group.Name.BannerLogo




# ProfileSystem.Profile.Groups

# Groups.All_Groups:

### TODO
# - Tilføj online status

# <s@Teams_Data.yaml_key[config.ranks.color.1]>

Teams_Data:
    type: yaml data
    config:
        namemaxlength: 10
        nameminlength: 2
        maxmembers: 18
# <def[name].matches[^[a-z0-9-_]+$].not>
# <def[name].matches[^[a-z0-9_]+$].not>

Teams_Events:
    type: world
    events:

        on player damaged:
        - if <context.cause> != ENTITY_ATTACK {
            - if <context.cause> != PROJECTILE {
                - queue clear
            }
        }
        - if <context.entity.is_player||false>  {
            - define player <context.entity>
            - inject Teams_FriendlyFire
        }
        else if <context.projectile.shooter.is_player||false> {
            - define player <context.projectile.shooter>
            - inject Teams_FriendlyFire
        }

        on player clicks in Teams_Menu:
        - determine cancelled passively
        - inventory close d:<context.inventory>
        - if <context.item.scriptname||false> == "Teams_Close" {
            - queue clear
        }
        - define title <context.item.display_name.after[<&l>]>
        - if <context.item.lore.get[1].starts_with[<&b>(]> {
            - flag player Teams_Player_Menu_Respond:<def[title]>
            - narrate FORMAT:Util_FF "<&7>Skriv <&a>/group <def[title]>"
            - queue clear
        }
        - execute as_player "group <def[title]>"


        on player drags in Teams_Menu:
        - determine cancelled passively

        on player drags in Teams_Menu_v2:
        - determine cancelled passively

        on player clicks in Teams_Menu_v2:
        - determine cancelled passively

        on player clicks Teams_Menu_Item_Back in inventory:
        - determine cancelled passively
        - inventory open d:in@Teams_Main_Menu

        on player clicks Teams_Menu_Item_Members in Teams_Main_Menu:
        - determine cancelled passively
        - inventory open d:in@Teams_Menu_Members_Menu

        # Teams_Menu_Item_Members

        on player clicks in Teams_Menu_Members_Menu:
        - determine cancelled passively
        - if <context.item.material.name> != human_skull {
            - queue clear
        }
        - define title <context.item.display_name.strip_color.after[<&co><&sp>]>
        - define Target <server.match_offline_player[<def[title]>]||null>
        - if <def[Target]> == null {
            - narrate format:util_ff "<&c>Denne spiller findes ikke."
            - queue clear
        }
        - flag player ProfileSystem_Target:<def[Target]>
        - inventory open d:in@ProfileSystem_Profile_Menu
        # TODO: Goto friend profile


Teams_FriendlyFire:
    type: task
    debug: false
    script:
    - define team <player.flag[Teams_Player_Group]||null> 
    - if <def[team]> != null {
        - define other <def[player].flag[Teams_Player_Group]||null>
        - if <def[other]> != null {
            - if <def[team]> == <def[other]> {
                - determine CANCELLED
            }
        }
    }

Teams_Admin_Command:
    type: command
    name: adminteam
    description: Admin Commands for teams.
    usage: /adminteam
    aliases:
    - ateam
    permission: qmod.admin
    permission message: Sorry, <player.name>, you don't have the permission '<permission>'!
    script:
    ##
    - if <context.args.size> > 0 {
        # Help
        - if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.admins.commands.args.help]>" {
            - inject Teams_Admin_Help_List
        }
        else if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.admins.commands.args.delete]>" {
            - if <context.args.size> >= 2 {
                - define team <context.args.get[2]>
                - inject Teams_Remove_Team
                - narrate FORMAT:Util_FF "<s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.admins.lang.deleteteam]> <&b><def[team]>"
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Admin_Help_Message]>"
            }
        }
        else if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.admins.commands.args.reset]>" {
            - if <context.args.size> >= 2 {
                - define team <context.args.get[2]>
                - define flag Teams_Group_<def[team]>_Created
                - if <server.has_flag[<def[flag]>].not> {
                    - narrate FORMAT:Util_FF "<&c><def[Target].name> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag "Teams_Group_<def[team]>_Kills"
                - flag server "<def[flag]>:0"
                - define flag "Teams_Group_<def[team]>_Deaths"
                - flag server "<def[flag]>:0"
                - define flag "Teams_Group_<def[team]>_Bank"
                - flag server "<def[flag]>:0"
                - define flag "Teams_Group_<def[team]>_Rank"
                - flag server "<def[flag]>:1"
                ## Check if has mission man:

                ##
                - narrate FORMAT:Util_FF "<s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.admins.lang.resetteam]> <&b><def[team]>"
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Admin_Help_Message]>"
            }
        }
        else if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.admins.commands.args.join]>" {
            - if <context.args.size> >= 2 {
                - define team <context.args.get[2]>
                - define flag Teams_Group_<def[team]>_Created
                - if <server.has_flag[<def[flag]>].not> {
                    - narrate FORMAT:Util_FF "<&c><def[Target].name> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define team <player.flag[Teams_Player_Group]||null>
                - if <def[team]> != null {
                    - inject Teams_Inject_Leave
                }
                - define flag Teams_Group_<def[team]>_Members
                - flag player Teams_Player_Group:<def[team]>
                - flag server "<def[flag]>:->:<player>"
                - define flag "Teams_Group_<def[team]>_Members"
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.acceptedpending]> <&b><def[team]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
                - flag player Teams_Player_Pending:!
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Admin_Help_Message]>"
            }
        }
        else if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.admins.commands.args.rename]>" {
            - if <context.args.size> >= 3 {
                - define oldteam <context.args.get[2]>
                - define newteam <context.args.get[3]>
                - define flag Teams_Group_<def[oldteam]>_Created
                - if <server.has_flag[<def[flag]>].not> {
                    - narrate FORMAT:Util_FF "<&c><def[Target].name> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - inject Teams_Rename_Team
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Admin_Help_Message]>"
            }
        }
        else {
            - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.unknown]> <proc[Teams_Admin_Help_Message]>"
        }
    }
    else {
        - inject Teams_Admin_Help_List
    }

Groups_Command:
    type: command
    name: team
    description: Commands for teams.
    usage: /team
    aliases:
    - bande
    - gruppe
    - group
    - teams
    - grupper
    - groups
    - bander
    script:
    - narrate test1
    - if <server.has_flag[Chat_Lock]> {
        - narrate "<&c>Denne kommando kan ikke bruges når chatten er låst."
        - queue clear
    }
    - if <context.args.size> > 0 {
        # Help
        - if <context.args.get[1]> == "help" {
            - inject Teams_Help_List
        }
        # Opret
        else if <context.args.get[1]> == "opret" {
            - if <player.has_permission[cube.hero].global.not> {
                - narrate format:util_ff "<&c>Du har ikke adgang til at oprette en gruppe"
                - queue clear
            }
            - if <player.has_flag[Teams_Player_Spam]||true> {
                - narrate FORMAT:Util_FF "<s@Teams_Data.yaml_key[config.lang.spamming]> <player.flag[Teams_Player_Spam].expiration.formatted>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - if <def[team]> != null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.alreadyonteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define team "<context.args.get[2]>"
                - if <server.has_flag[Teams_Group_<def[team]>_Created]||true> {
                    - narrate FORMAT:Util_FF "<&c><def[team]> <s@Teams_Data.yaml_key[config.lang.teamalreadyexist]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[team].length> > <s@Teams_Data.yaml_key[config.namemaxlength]> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.nametoolong]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[team].length> < <s@Teams_Data.yaml_key[config.nameminlength]> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.nametooshort]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[team].matches[^[a-zA-Z0-9_]+$].not> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - flag player Teams_Player_Spam:True duration:30s
                # Create Team
                - flag player ProfileSystem.Profile.Groups:->:<def[team]>
                - flag server "Groups.Group.<def[team]>.Members:->:<player>"
                - flag server "Groups.Group.<def[team]>.MaxMembers:<s@Teams_Data.yaml_key[config.maxmembers]>"
                # - flag server "Groups.Group.<def[team]>.Leaders:->:<player>"
                # - flag server "Groups.Group.<def[team]>.Leaders:<-:<player>"
                - flag server "Groups.Group.<def[team]>.Owner:<player>"
                - flag server "Groups.Group.<def[team]>.Created:<util.date.time.day>-<util.date.time.month>-<util.date.time.year>"
                - flag server Groups.All_Groups:->:<def[team]>
                - announce FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.newteam]> <&b><def[team]>"
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # Info
        else if <context.args.get[1]> == "info" {
            - if <context.args.size> >= 2 {
                # Check other team (args either player or team)
                - define team <context.args.get[2]>
                - if <server.has_flag[Groups.Group.<def[team]>.Created].not> {
                    - define Target <server.match_offline_player[<context.args.get[2]>]||null>
                    - if <def[Target]> == null {
                        - narrate FORMAT:Util_FF "<&c>Ingen gruppe fundet"
                        - queue clear
                    }
                    else {
                        # Found player
                        - define team <def[Target].flag[ProfileSystem.Profile.Groups].as_list.get[<context.args.get[3].as_int||1>]||null>
                        - if <def[team]> == null {
                            - narrate FORMAT:Util_FF "<&c>Denne spiller har ikke nogen grupper"
                            - queue clear
                        }
                    }
                }
                # Found team <def[team]>
                - flag player ProfileSystem_Group_Target:<def[team]>
                - inventory open d:in@Teams_Menu_Members_Menu
            }
            else if <player.has_flag[ProfileSystem.Profile.Groups].as_list.get[<context.args.get[3].as_int||1>]||null> != null {
                # Check own team <def[team]>
                - flag player ProfileSystem_Group_Target:<def[team]>
                - inventory open d:in@Teams_Menu_Members_Menu
            }
            else {
                - narrate format:util_ff "<&c>Du er ikke medlem af nogen grupper"
                # No Team
            }
            - queue clear
        }
        # Forlad
        else if <context.args.get[1]> == "forlad" {
            - define team <context.args.get[2]||null>
            - if <def[team]> == null {
                - narrate format:util_ff "<&c>Du skal vælge den gruppe du vil forlade. <&e>/team forlad (gruppe)"
            }
            - inject Teams_Inject_Leave
        }
        # top
        else if <context.args.get[1]> == "top" {
            - inject Teams_Top_Task
        }
        # Invite
        else if <context.args.get[1]> == "invite" {
            - if <context.args.size> >= 2 {
                - if <def[team]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag Teams_Group_<def[team]>_Leaders
                - define flag1 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag]>].as_list.contains[<player>].not||true> && <server.flag[<def[flag1]>].is[EQUALS].to[<player>].not> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noleader]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag Teams_Group_<def[team]>_Members
                - define maxmembers Teams_Group_<def[team]>_MaxMembers
                - if <server.flag[<def[flag]>].size> >= <server.flag[<def[maxmembers]>].round> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.teamfull]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define Target <server.match_player[<context.args.get[2]>]||null>
                - if <def[Target]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.noplayerfound]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[Target]> == <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                else if <def[Target].flag[Teams_Player_Group]||null> == <def[team]> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.alreadyonteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                else if <def[target].has_flag[Teams_Player_Pending]> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.alreadypending]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag Teams_Group_<def[team]>_Members
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.invited]> <&b><def[target].name>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
                - flag <def[target]> Teams_Player_Pending:<def[team]> duration:2m
                - define command "/<s@Teams_Data.yaml_key[config.commands.main]> (<s@Teams_Data.yaml_key[config.commands.args.accept]><&8>/<&a><s@Teams_Data.yaml_key[config.commands.args.deny]>)"
                - define lang "<s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.invitedtoteam]>"
                - narrate FORMAT:Util_FF "<&3><def[lang]> <&b><def[target].flag[Teams_Player_Pending]> <&a><def[command]>" targets:<def[target]>
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # Deny
        else if <context.args.get[1]> == "deny" {
            - if <player.has_flag[Teams_Player_Pending].not||true> {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.nopending]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - narrate FORMAT:Util_FF "<s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.declinedpending]> <player.flag[Teams_Player_Pending]>"
            - define flag "Teams_Group_<player.flag[Teams_Player_Pending]>_Members"
            - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.declinedpending]> <&b><player.flag[Teams_Player_Pending]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            - flag player Teams_Player_Pending:!
        }
        # Accept
        else if <context.args.get[1]> == "accept" {
            - if <player.has_flag[Teams_Player_Pending].not||true> {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.nopending]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - define flag Teams_Group_<player.flag[Teams_Player_Pending]>_Members
            - define maxmembers Teams_Group_<player.flag[Teams_Player_Pending]>_MaxMembers
            - if <server.flag[<def[flag]>].size> >= <server.flag[<def[maxmembers]>].round> {
                - narrate FORMAT:Util_FF "<&c><player.flag[Teams_Player_Pending]> <s@Teams_Data.yaml_key[config.lang.teamfull]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - if <def[team]> != null {
                - inject Teams_Inject_Leave
            }
            - define flag Teams_Group_<player.flag[Teams_Player_Pending]>_Members
            - flag player Teams_Player_Group:<player.flag[Teams_Player_Pending]>
            - flag server "<def[flag]>:->:<player>"
            - define flag "Teams_Group_<player.flag[Teams_Player_Pending]>_Members"
            - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.acceptedpending]> <&b><def[team]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            - flag player Teams_Player_Pending:!
        }
        # # Deposit
        # else if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.commands.args.deposit]>" {
            # - if <def[team]> == null {
                # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                # - queue clear
            # }
            # - if <context.args.size> >= 2 {
                # - define deposited <context.args.get[2].as_int||null>
                # - if <def[deposited]> == null {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - if <player.money> < <def[deposited]> {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.notenoughmoney]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - if <def[deposited]> < 0 {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.nonegative]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - take money quantity:<def[deposited]>
                # - define flag Teams_Group_<def[team]>_Bank
                # - define total <server.flag[<def[flag]>].add_int[<def[deposited]>]>
                # - flag server "<def[flag]>:<def[total]>"
                # - define flag "Teams_Group_<def[team]>_Members"
                # - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.moneydeposit1]> <&b><def[deposited]> <&3><s@Teams_Data.yaml_key[config.lang.moneydeposit2]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            # }
            # else {
                # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            # }
        # }
        # # Withdraw
        # else if <context.args.get[1]> == "<s@Teams_Data.yaml_key[config.commands.args.withdraw]>" {
            # - if <def[team]> == null {
                # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                # - queue clear
            # }
            # - if <context.args.size> >= 2 {
                # - define flag Teams_Group_<def[team]>_Leaders
                # - define flag1 Teams_Group_<def[team]>_Owner
                # - if <server.flag[<def[flag]>].as_list.contains[<player>].not||true> && <server.flag[<def[flag1]>].is[EQUALS].to[<player>].not> {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noleader]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - define flag Teams_Group_<def[team]>_Bank
                # - define withdrew <context.args.get[2].as_int||null>
                # - if <def[withdrew]> == null {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - if <server.flag[<def[flag]>]> < <def[withdrew]> {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.notenoughmoney]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - if <def[withdrew]> < 0 {
                    # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.nonegative]> <proc[Teams_Help_Message]>"
                    # - queue clear
                # }
                # - define total <server.flag[<def[flag]>].sub_int[<def[withdrew]>]>
                # - give money quantity:<def[withdrew]>
                # - flag server "<def[flag]>:<def[total]>"
                # - define flag "Teams_Group_<def[team]>_Members"
                # - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.moneywithdraw1]> <&b><def[withdrew]> <&3><s@Teams_Data.yaml_key[config.lang.moneywithdraw2]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            # }
            # else {
                # - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            # }
        # }
        # Rename
        else if <context.args.get[1]> == "rename" {
            - if <player.has_flag[Teams_Player_Spam]> {
                - narrate FORMAT:Util_FF "<s@Teams_Data.yaml_key[config.lang.spamming]> <player.flag[Teams_Player_Spam].expiration.formatted>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - define newteam "<context.args.get[2]>"
                - if <def[team]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag Teams_Group_<def[team]>_Leaders
                - define flag1 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag]>].as_list.contains[<player>].not||true> && <server.flag[<def[flag1]>].is[EQUALS].to[<player>].not||true> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noleader]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define oldteam <def[team]>
                - inject Teams_Rename_Team
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # Promote
        else if <context.args.get[1]> == "promote" {
            - if <def[team]> == null {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - define flag1 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag1]>]> != <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noowner]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag1 Teams_Group_<def[team]>_Leaders
                - define target <server.match_offline_player[<context.args.get[2]>]||null>
                - if <def[target]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.noplayerfound]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[target]> == <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag2 Teams_Group_<def[team]>_Members
                - if <server.flag[<def[flag2]>].as_list.contains[<def[target]>].not> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.notyourside]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <server.flag[<def[flag1]>].as_list.contains[<def[target]>]||false> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.alreadyleader]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                # Give promotion
                - flag server "<def[flag1]>:->:<def[target]>"
                - define flag "Teams_Group_<def[team]>_Members"
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.promoted]> <&b><def[target].name>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # Demote
        else if <context.args.get[1]> == "demote" {
            - if <def[team]> == null {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - define flag1 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag1]>]> != <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noowner]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag1 Teams_Group_<def[team]>_Leaders
                - define target <server.match_offline_player[<context.args.get[2]>]||null>
                - if <def[target]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.noplayerfound]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[target]> == <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag2 Teams_Group_<def[team]>_Members
                - if <server.flag[<def[flag2]>].as_list.contains[<def[target]>].not> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.notyourside]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <server.flag[<def[flag1]>].as_list.contains[<def[target]>].not||true> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.noleader]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                # Demote target
                - flag server "<def[flag1]>:<-:<def[target]>"
                - define flag "Teams_Group_<def[team]>_Members"
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.demoted]> <&b><def[target].name>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # SetOwner
        else if <context.args.get[1]> == "setowner" {
            - if <def[team]> == null {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - define flag1 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag1]>]> != <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noowner]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define target <server.match_offline_player[<context.args.get[2]>]||null>
                - if <def[target]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.noplayerfound]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[target]> == <player> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag2 Teams_Group_<def[team]>_Members
                - if <server.flag[<def[flag2]>].as_list.contains[<def[target]>].not> {
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.notyourside]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag1 Teams_Group_<def[team]>_Leaders
                - if <server.flag[<def[flag1]>].as_list.contains[<def[target]>]||false> {
                    - flag server "<def[flag1]>:<-:<def[target]>"
                }
                # Give Owner
                - define flag1 Teams_Group_<def[team]>_Owner
                - flag server "<def[flag1]>:<def[target]>"
                - define flag "Teams_Group_<def[team]>_Members"
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.gaveowner]> <&b><def[target].name>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # kick
        else if <context.args.get[1]> == "kick" {
            - if <def[team]> == null {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - if <context.args.size||false> >= 2 {
                - define flag1 Teams_Group_<def[team]>_Leaders
                - if <server.flag[<def[flag1]>].as_list.contains[<player>].not||true> {
                    - define flag2 Teams_Group_<def[team]>_Owner
                    - if <server.flag[<def[flag2]>]> != <player> {
                        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noleader]> <proc[Teams_Help_Message]>"
                        - queue clear
                    }
                }
                - define target <server.match_offline_player[<context.args.get[2]>]||null>
                - if <def[target]> == null {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.noplayerfound]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <def[target]> == <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - define flag2 Teams_Group_<def[team]>_Members
                - if <server.flag[<def[flag2]>].as_list.contains[<def[target]>].not||true> {
                    ## HOTFIX
                    - if <server.has_flag[<def[flag1]>]> {
                        - if <server.flag[<def[flag1]>].as_list.contains[<def[target]>]||true> {
                            - announce "<&c><def[target].name> er leder på <def[team]> men ikke member!" to_flagged:Show_Errors
                            - flag server "<def[flag1]>:<-:<def[target]>"
                            - narrate FORMAT:Util_FF "<&e>En fejl opstod. Skriv venligst på forummet i detajler omkring fejlen..."
                            - queue clear
                        }
                    }
                    ##
                    - narrate FORMAT:Util_FF "<&c><def[target].name> <s@Teams_Data.yaml_key[config.lang.notyourside]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
                - if <server.flag[<def[flag1]>].as_list.contains[<def[target]>]||true> {
                    - define flag2 Teams_Group_<def[team]>_Owner
                    - if <server.flag[<def[flag2]>]> != <player> {
                        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.cannotkickleader]> <proc[Teams_Help_Message]>"
                        - queue clear
                    }
                }
                - define flag2 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag2]>]> == <def[target]> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.cannotkickleader]> <proc[Teams_Help_Message]>"
                    - queue clear
                }                   
                - define flag2 Teams_Group_<def[team]>_Members
                - flag server "<def[flag2]>:<-:<def[target]>"
                - flag <def[target]> Teams_Player_Group:!
                - run Teams_Kicked_player player:<def[target]>
                - define flag3 Teams_Group_<def[team]>_Leaders
                - if <server.flag[<def[flag3]>].as_list.contains[<def[target]>]||false> {
                    - flag server "<def[flag3]>:<-:<def[target]>"
                }
                - if <def[target].is_online||false> {
                    - narrate FORMAT:Util_FF "<&3><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.gotkicked]> <&b><def[team]>" targets:<def[target]>
                }
                - define flag "Teams_Group_<def[team]>_Members"
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.waskicked1]> <&b><def[target].name> <&3><s@Teams_Data.yaml_key[config.lang.waskicked2]> <&b><def[team]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            }
            else {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.missargs]> <proc[Teams_Help_Message]>"
            }
        }
        # Shop
        else if <context.args.get[1]> == "shop" {
            - if <def[team]> == null {
                - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
                - queue clear
            }
            - define flag1 Teams_Group_<def[team]>_Leaders
            - if <server.flag[<def[flag1]>].as_list.contains[<player>].not||true> {
                - define flag2 Teams_Group_<def[team]>_Owner
                - if <server.flag[<def[flag2]>]> != <player> {
                    - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noleader]> <proc[Teams_Help_Message]>"
                    - queue clear
                }
            }
            - flag server Upgrades_Target_Menu:<player>
            - inventory open d:in@Team_Upgrades_Menu
        }
        else {
            - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.unknown]> <proc[Teams_Help_Message]>"
        }
    }
    else {
        - if <def[team]> != null {
            - flag server Teams_Target_Menu:<player>
            - inventory open d:in@Teams_Menu_v2
            # - inventory open d:in@Teams_Menu
            # - inject Teams_Help_List
        }
        else {
            - inject Teams_Help_List
        }
    }

Teams_Rename_Team:
    type: task
    script:
    - narrate FORMAT:Util_FF "<&7>Checker..."
    - wait 1t
    - if <server.has_flag[Teams_Group_<def[newteam]>_Created]> {
        - narrate FORMAT:Util_FF "<&c><def[newteam]> <s@Teams_Data.yaml_key[config.lang.teamalreadyexist]> <proc[Teams_Help_Message]>"
        - queue clear
    }
    - if <def[newteam].length> > <s@Teams_Data.yaml_key[config.namemaxlength]> {
        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.nametoolong]> <proc[Teams_Help_Message]>"
        - queue clear
    }
    - if <def[newteam].length> < <s@Teams_Data.yaml_key[config.nameminlength]> {
        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.nametooshort]> <proc[Teams_Help_Message]>"
        - queue clear
    }
    - if <def[newteam].matches[^[a-zA-Z0-9_]+$].not> {
        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.notvalid]> <proc[Teams_Help_Message]>"
        - queue clear
    }
    - flag player Teams_Player_Spam:True duration:30s
    - narrate FORMAT:Util_FF "<&7>Dit hold bliver renamed... vent venligst..."
    - wait 1t
    - define flag1new "Teams_Group_<def[newteam]>_Kills"
    - define flag1old "Teams_Group_<def[oldteam]>_Kills"
    - flag server "<def[flag1new]>:<server.flag[<def[flag1old]>]>"
    - define flag2new "Teams_Group_<def[newteam]>_Deaths"
    - define flag2old "Teams_Group_<def[oldteam]>_Deaths"
    - flag server "<def[flag2new]>:<server.flag[<def[flag2old]>]>"
    - define flag3new "Teams_Group_<def[newteam]>_Bank"
    - define flag3old "Teams_Group_<def[oldteam]>_Bank"
    - flag server "<def[flag3new]>:<server.flag[<def[flag3old]>]>"
    - define flag4new "Teams_Group_<def[newteam]>_Rank"
    - define flag4old "Teams_Group_<def[oldteam]>_Rank"
    - flag server "<def[flag4new]>:<server.flag[<def[flag4old]>]>"
    - define flag5new "Teams_Group_<def[newteam]>_Members"
    - define flag5old "Teams_Group_<def[oldteam]>_Members"
    - foreach <server.flag[<def[flag5old]>].as_list> {
        - flag server "<def[flag5new]>:->:<def[value]>"
        - flag <def[value]> Teams_Player_Group:<def[newteam]>
        - run Teams_Changed_Team player:<def[value]> context:<def[newteam]>
    }
    - wait 1t
    - define flag6new "Teams_Group_<def[newteam]>_Leaders"
    - define flag6old "Teams_Group_<def[oldteam]>_Leaders"
    - if <server.has_flag[<def[flag6old]>]> {
        - foreach <server.flag[<def[flag6old]>].as_list> {
            - flag server "<def[flag6new]>:->:<def[value]>"
        }
    }
    - wait 1t
    - define flag7new "Teams_Group_<def[newteam]>_Created"
    - define flag7old "Teams_Group_<def[oldteam]>_Created"
    - flag server "<def[flag7new]>:<server.flag[<def[flag7old]>]>"
    - flag server Teams_Groups:->:<def[newteam]>
    - flag server Teams_Groups:<-:<def[oldteam]>
    - define flag "Teams_Group_<def[oldteam]>_Kills"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[oldteam]>_Deaths"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[oldteam]>_Members"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[oldteam]>_Leaders"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[oldteam]>_Rank"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[oldteam]>_Bank"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[oldteam]>_Created"
    - flag server "<def[flag]>:!"
    - wait 1t
    - define flag8new "Teams_Group_<def[newteam]>_Owner"
    - define flag8old "Teams_Group_<def[oldteam]>_Owner"
    - flag server "<def[flag8new]>:<server.flag[<def[flag8old]>]>"
    - flag server "<def[flag8old]>:!"
    - define flag9new "Teams_Group_<def[newteam]>_MaxMembers"
    - define flag9old "Teams_Group_<def[oldteam]>_MaxMembers"
    - flag server "<def[flag9new]>:<server.flag[<def[flag9old]>]>"
    - flag server "<def[flag9old]>:!"
    - announce FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.renamedteam1]> <&b><def[oldteam]> <&3><s@Teams_Data.yaml_key[config.lang.renamedteam2]> <&b><def[newteam]>"
    - narrate "<server.flag[teams_topkills]>"
    - if <server.has_flag[teams_topkills]> {
        - foreach <server.flag[teams_topkills]> {
            - narrate "<def[loop_index]> <def[value]>"
            - if <def[value]> == <def[oldteam]> {
                - flag server teams_topkills_cooldown:!
                # - define list <server.flag[teams_topkills]>
                # - define new_list <def[list].set[<def[list].get[<def[loop_index]>]>].at[<def[oldteam]>]>
                # - flag server "teams_topkills:<def[new_list]>"
            }
        }
    }
    - wait 1t
    # Additional team flags
    - if <server.list_scripts.contains[s@Kit_Quest_Team_Data]> {
        - define flag9new "Kit_Quest_<def[newteam]>_Rank"
        - define flag9old "Kit_Quest_<def[oldteam]>_Rank"
        - if <server.has_flag[<def[flag9old]>]> {
            - if <server.flag[<def[flag9old]>].starts_with[server.flag]> {
                - flag server "<def[flag9new]>:!"
            }
            else {
                - flag server "<def[flag9new]>:<server.flag[<def[flag9old]>]>"
            }
            - flag server "<def[flag9old]>:!"
        }
        - define flag9new Kit_Quest_<def[newteam]>_Type
        - define flag9old Kit_Quest_<def[oldteam]>_Type
        - if <server.has_flag[<def[flag9old]>]> {
            - if <server.flag[<def[flag9old]>].starts_with[server.flag]> {
                - flag server "<def[flag9new]>:!"
            }
            else {
                - flag server "<def[flag9new]>:<server.flag[<def[flag9old]>]>"
            }
            - flag server "<def[flag9old]>:!"
        }
        - define flag9new Kit_Quest_<def[newteam]>_Current
        - define flag9old Kit_Quest_<def[oldteam]>_Current
        - if <server.has_flag[<def[flag9old]>]> {
            - if <server.flag[<def[flag9old]>].starts_with[server.flag]> {
                - flag server "<def[flag9new]>:!"
            }
            else {
                - flag server "<def[flag9new]>:<server.flag[<def[flag9old]>]>"
            }
            - flag server "<def[flag9old]>:!"
        }
        - wait 1t
        - define flag9new Kit_Quest_<def[newteam]>_Goal
        - define flag9old Kit_Quest_<def[oldteam]>_Goal
        - if <server.has_flag[<def[flag9old]>]> {
            - if <server.flag[<def[flag9old]>].starts_with[server.flag]> {
                - flag server "<def[flag9new]>:!"
            }
            else {
                - flag server "<def[flag9new]>:<server.flag[<def[flag9old]>]>"
            }
            - flag server "<def[flag9old]>:!"
        }
        - define flag9new Kit_Quest_<def[newteam]>_Quest_Active
        - define flag9old Kit_Quest_<def[oldteam]>_Quest_Active
        - if <server.has_flag[<def[flag9old]>]> {
            - if <server.flag[<def[flag9old]>].starts_with[server.flag]> {
                - flag server "<def[flag9new]>:!"
            }
            else {
                - flag server "<def[flag9new]>:<server.flag[<def[flag9old]>]>"
            }
            - flag server "<def[flag9old]>:!"
        }
    }
    - wait 1t
    - define team <def[oldteam]>
    - inject Teams_Remove_Team

Teams_Changed_Team:
    type: task
    definitions: team
    script:
    - flag player Teams_Player_Group:<def[team]>

Teams_Kicked_player:
    type: task
    script:
    - flag player Teams_Player_Group:!

Teams_Inject_Leave:
    type: task
    script:
    - if <player.has_flag[Teams_Player_Spam]> {
        - narrate FORMAT:Util_FF "<s@Teams_Data.yaml_key[config.lang.spamming]> <player.flag[Teams_Player_Spam].expiration.formatted>"
        - queue clear
    }
    # Groups.Group.<def[team]>.Created
    - define team <player.flag[Teams_Player_Group]||null>
    - if <def[team]> != null {
        - narrate FORMAT:Util_FF "<&3><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.leftteam]> <&b><def[team]>"
        - flag player Teams_Player_Group:!
        - define flag Teams_Group_<def[team]>_Members
        - flag server "<def[flag]>:<-:<player>"
        - if <server.has_flag[<def[flag]>]> {
            - if <server.flag[<def[flag]>].as_list.is_empty.not||false> {
                - narrate FORMAT:Util_FF "<&b><player.name> <&3><s@Teams_Data.yaml_key[config.lang.leftteam]> <&b><def[team]>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>
            }
        }
        - define flag Teams_Group_<def[team]>_Leaders
        - if <server.flag[<def[flag]>].as_list||null> != null {
            - if <server.flag[<def[flag]>].as_list.contains[<player>]||false> {
                - flag server "<def[flag]>:<-:<player>"
            }
        }
        - define flag Teams_Group_<def[team]>_Owner
        - if <server.flag[<def[flag]>]> == <player> {
            - flag player Teams_Player_Spam:True duration:30s
            # Remove team
            - inject Teams_Remove_Team
            - announce FORMAT:Util_FF "<&3><s@Teams_Data.yaml_key[config.lang.teamdisband1]> <&b><def[team]> <&3><s@Teams_Data.yaml_key[config.lang.teamdisband2]> <&b><player.name>"
        }
    }
    else {
        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
    }

Teams_Remove_Team:
    type: task
    script:
    # Remove team
    # - define team "something"
    - foreach <server.flag[]>
    - define flag Teams_Group_<def[team]>_Kills
    - flag server "<def[flag]>:!"
    - define flag Teams_Group_<def[team]>_Deaths
    - flag server "<def[flag]>:!"
    - define flag Teams_Group_<def[team]>_Members
    - if <server.has_flag[<def[flag]>]> {
        - foreach <server.flag[<def[flag]>].as_list> {
            - run Teams_Remove_Team_Individual player:<def[value]>
        }
    }
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[team]>_MaxMembers"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[team]>_Leaders"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[team]>_Rank"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[team]>_Bank"
    - flag server "<def[flag]>:!"
    - define flag "Teams_Group_<def[team]>_Created"
    - flag server "<def[flag]>:!"
    - flag server "Teams_Groups:<-:<def[team]>"
    # Additional team flags
    - if <server.list_scripts.contains[s@Kit_Quest_Team_Data]> {
        - define flag "Kit_Quest_<def[team]>_Rank"
        - flag server "<def[flag]>:!"
        - define flag "Kit_Quest_<def[team]>_Type"
        - flag server "<def[flag]>:!"
        - define flag "Kit_Quest_<def[team]>_Current"
        - flag server "<def[flag]>:!"
        - define flag "Kit_Quest_<def[team]>_Goal"
        - flag server "<def[flag]>:!"
        - define flag "Kit_Quest_<def[team]>_Quest_Active"
        - flag server "<def[flag]>:!"
    }
    - if <server.has_flag[teams_topkills]> {
        - foreach <server.flag[teams_topkills].as_list> {
            - if <def[value]> == <def[team]> {
                - flag server teams_topkills_cooldown:!
            }
        }
    }

Teams_Remove_Team_Individual:
    type: task
    script:
    - flag player Teams_Player_Group:!

Teams_Chat:
    type: command
    name: teamchat
    description: Commands for teams.
    usage: /teamchat
    aliases:
    - tc
    script:
    - define team <def[target].flag[Teams_Player_group]||null>
    - if <def[team]> == null {
        - narrate FORMAT:Util_FF "<&c><s@Teams_Data.yaml_key[config.lang.you]> <s@Teams_Data.yaml_key[config.lang.noteam]> <proc[Teams_Help_Message]>"
        - queue clear
    }
    - define flag "Teams_Group_<def[team]>_Members"
    - narrate FORMAT:Util_FF "<&8>[<&c>Team-Chat<&8>] <&b><player.name><&co> <&e><context.raw_args>" targets:<server.flag[<def[flag]>].as_list.filter[is_online]>

# Menu

# Groups.Group.Name.Members
# Groups.Group.Name.MaxMembers
# Groups.Group.Name.Leaders
# Groups.Group.Name.Owner
# Groups.Group.Name.Created

# Groups.Group.Name.Description
# Groups.Group.Name.BannerLogo
Teams_Main_Menu:
    type: inventory
    inventory: CHEST
    title: <&3>Gruppe<&co> <player.flag[ProfileSystem_Group_Target]>
    size: 45
    definitions: 
        Wall_A: ProfileSystem_Profile_Item_Wall_A
        Wall_B: ProfileSystem_Profile_Item_Wall_B
        Info: Teams_Menu_Item_Info
        Members: Teams_Menu_Item_Members
    slots:
    - "[Wall_A] [Wall_B] [Wall_A] [Wall_B] [Back] [Wall_B] [Wall_A] [Wall_B] [Wall_A]"
    - "[] [] [] [] [Info] [] [] [] []"
    - "[] [] [] [] [] [] [] [] []"
    - "[] [] [] [] [Members] [] [] [] []"
    - "[Wall_A] [Wall_B] [Wall_A] [Wall_B] [Wall_A] [Wall_B] [Wall_A] [Wall_B] [Wall_A]"

Teams_Menu_Members_Menu:
    type: inventory
    inventory: CHEST
    title: <&3>Medlemmer<&co> <player.flag[ProfileSystem_Group_Target]>
    size: 45
    definitions: 
        Wall_A: ProfileSystem_Profile_Item_Wall_A
        Wall_B: ProfileSystem_Profile_Item_Wall_B
        Back: Teams_Menu_Item_Back
    slots:
    - "[Wall_A] [Wall_B] [Wall_A] [Wall_B] [Back] [Wall_B] [Wall_A] [Wall_B] [Wall_A]"
    - "[] [] [] [] [] [] [] [] []"
    - "[] [] [] [] [] [] [] [] []"
    - "[] [] [] [] [] [] [] [] []"
    - "[Wall_A] [Wall_B] [Wall_A] [Wall_B] [Wall_A] [Wall_B] [Wall_A] [Wall_B] [Wall_A]"
    procedural items:
    - define text ""
    - define owner <server.flag[Groups.Group.<player.flag[ProfileSystem_Group_Target]>.Owner]>
    - define leaders <server.flag[Groups.Group.<player.flag[ProfileSystem_Group_Target]>.Members].as_list>
    - foreach <server.flag[Groups.Group.<player.flag[ProfileSystem_Group_Target]>.Members].as_list.parse[as_player]||li@> {
        - define lore "<&a>Klik for at se profil"
        # TODO: Fælles venner
        # TODO: Online
        - if <def[owner]> == <def[value]> {
            - define rank "Ejer"
        }
        else if <def[leaders].contains[<def[value]>]> {
            - define rank "Leder"
        }
        else {
            - define rank "Medlem"
        }
        - define text "<def[text]>human_skull[skull_skin=<def[value].uuid>;display_name=<&b><&l><def[rank]><&co> <def[value].name>;lore=<def[lore]>]|"
    }
    - determine <def[text].before_last[|]>
    # - define text "human_skull[skull_skin=<player.uuid>;display_name=<&a><player.name>;lore=<def[lore]>]"

Teams_Menu_Item_Info:
    type: item
    material: PAPER
    display name: <&b><&l>Info
    lore:
    - "<&3>Oprettet<&co> <&a><server.flag[Groups.Group.<player.flag[ProfileSystem_Group_Target]>.Created]>"
    - "<&7>"
    - "Gruppe Beskrivelse<&co>"
    - "<&a><server.flag[Groups.Group.<player.flag[ProfileSystem_Group_Target]>.Description]||<&7>Ingen>"

Teams_Menu_Item_Back:
    type: item
    material: BARRIER
    display name: <&b>Gå Tilbage

Teams_Menu_Item_Members:
    type: item
    material: BOOK
    display name: <&b><&l>Medlemmer
    lore:
    - "<&3>Vis medlemmerne af denne gruppe"


Teams_Close:
    type: item
    material: BARRIER
    display name: <&a>Luk Menu