#
# Season 1 Remix
#
# I wanna be, the very best
# like no one ever was
# to script them, was my real test
# to replace them was my cause
# I will travel across the net
# searching for-docs and vids
# Each Scripter, must understand
# The power that's inside
# Denizen!
# Gotta' script it'all
# (It what I have)
# I know its my destiny
# Denizen! oh its all I need
# In a world that makes it square
# Denizen!
# Gotta' script it'all
# A plugin so true
# A high-power script engine
# On I-R-C we will teach you
# Denizen!
# Gotta' script it'all
# Gotta' script it'all
# Denizen!
#

#
# Season 2 Remix
# 
# It's a whole new code we hav' her', (here)
# Denizen point 2!
# Do-Do-Do, Do, Do-Do
# Do-Do-Do, Do, Do-Do
# Everybody wants to be a scripter.
# Everybody wants show their scripts.
# Everybody wants to make it faster.
# Make their way to the top of the ranks.
# Each time, You fail...
# Quick help to get little bit better...
# Each queue, You run...
# Is one more step up the tracker!
# It's a whole new code we hav' her',
# Do-Do-Do, Do, Do-Do
# It's a whole new engin' to see,
# Do-Do-Do, Do, Do-Do
# It's a whole new plugin, with a brand new clean design,
# But you still 'Gotta script 'it all!'
# And be a part of our forum!
# Do-Do-Do, Do, Do-Do
# It's a whole new code we hav' her',
# But you still 'Gotta script 'it all!'
# And be a part of our forum!
# Do-Do-Do, Do, Do-Do
# Denizen point 2!
# Do-Do-Do, Do, Do-Do
# Denizen point 2!

# CTF_Red_Team
# CTF_Blue_Team
# CTF_None_Team
# CTF_Playing
# CTF_Coins
# CTF_Earned

# CTF_Current_Lobby
# CTF_Current_Red_Spawns
# CTF_Current_Red_Flag
# CTF_Current_Blue_Spawns
# CTF_Current_Blue_Flag

# CTF_Current_Red_Spawn_Class
# CTF_Current_Blue_Spawn_Class

## TODO
# Make scenarios work (unlockAll, PvAI, sameClass, Defense)

## Classes
# Engineer
# Ninja
# Fighter
# Demolition
# Pyro
# Heavy

# <s@CTF_Data.yaml_key[config.teams.Red.wool_data]>
CTF_Data:
    type: yaml data
    debug: false
    config:
        teams:
            Red:
                color: "&c"
                wool_data: "14"

            Blue: 
                color: "&9"
                wool_data: "11"



CTF_Main_Events:
    type: world
    events:
        on player right clicks at armor_stand:
        - determine cancelled

        on player chats:
        - if <server.has_flag[CTF_LockChat]> {
            - determine cancelled
        }
        - if <server.has_flag[CTF_Playing]> {
            - determine cancelled passively
            - if <player.has_flag[CTF_Team]> {
                - define team <player.flag[CTF_Team]>
                - define color <s@CTF_Data.yaml_key[config.teams.<def[team]>.color].parse_color>
                - narrate "<&8>[<def[color]>Team<&8>] <def[color]><player.name> <&8><&chr[00BB]> <&r><context.message>" targets:<server.flag[CTF_<def[team]>_Team].as_list>
            }
            - announce to_flagged:CTF_AllChat "<&d><player.name><&co> <context.message>"
        }
        # - determine "<&7><player.name.display> <&8><&chr[00BB]> <&r><text>"

        on entity enters vehicle:
        - determine cancelled

        on player unequips armor:
        - if <player.gamemode.id> == 1 {
            - if <player.is_op> {
                - queue clear
            }
        }
        - determine cancelled

        on player drops item:
        - determine cancelled

        on player breaks hanging:
        - if <player.gamemode.id> == 1 {
            - if <player.is_op> {
                - queue clear
            }
        }
        - determine cancelled

        on player breaks block:
        - if <player.gamemode.id> == 1 {
            - if <player.is_op> {
                - queue clear
            }
        }
        - determine cancelled passively
        - if <server.flag[CTF_Turrets].as_list.contains[<context.location.simple>]||false> {
            - if <context.location.material.data> == <s@CTF_Data.yaml_key[config.teams.<player.flag[CTF_Team]>.wool_data]> {
                - narrate format:util_ff "<&c>Hey, den turret er på dit hold!"
                - queue clear
            }
            - remove <context.location.find.entities[armor_stand].within[2]>
        }

        on player places block:
        - if <player.gamemode.id> == 1 {
            - if <player.is_op> {
                - queue clear
            }
        }
        - determine cancelled passively
        - if <context.item_in_hand.scriptname||null> == Turret_Placer {
            - define loc <context.location>
            - if <context.old_material> != m@air {
                - queue clear
            }
            - if <def[loc].above.material> != m@air {
                - queue clear
            }
            - if <def[loc].above.above.material> != m@air {
                - queue clear
            }
            - if <player.has_flag[CTF_Turret_Cooldown]> {
                - narrate format:util_ff "<&c>Vent <player.flag[CTF_Turret_Cooldown].expiration.formatted> for at placere en ny turret"
                - queue clear
            }
            - flag player CTF_Turret_Cooldown duration:3m
            - take <context.item_in_hand>
            - narrate <player.flag[CTF_Team]>
            - run CTF_Turret_Spawn instantly context:<def[loc]>|<player.flag[CTF_Team]>
        }

        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 CTF_FriendlyFire
        }
        else if <context.projectile.shooter.is_player||false> {
            - define player <context.projectile.shooter>
            - inject CTF_FriendlyFire
        }
        # - if <context.final_damage> >= <player.health> {
            # - determine cancelled passively
            # - define inventory <player.inventory>
            # - define armor <player.equipment.parse[full]>
            # # - equip <player> head:i@air chest:i@air legs:i@air boots:i@air 
            # - define health <player.health>
            # - define hunger <player.food_level>
            # # - drop <def[inventory].list_contents.full.include[<def[armor]>]> <player.location>
            # - inventory clear
            # - hurt 0
            # - feed amount:20
            # - heal 20
            # - event "player death" context:<def[health]>|<def[hunger]>|<def[inventory]>|<def[armor]>
            # - event "player respawns"
            # - wait 1t
            # - equip <player> head:i@air chest:i@air legs:i@air boots:i@air 
        # }

        on player quit:
        - if <player.has_flag[CTF_Base_Flag]> {
            - run CTF_Return_Flag player:<player> context:<player.flag[CTF_Base_Flag]> instantly
        }
        - flag player CTF_Playing:!
        - if <player.has_flag[CTF_Team]> {
            - execute as_server "scoreboard teams leave <player.name>"
            - define team <player.flag[CTF_Team]>
            - flag player CTF_Team:!
            - define flag "CTF_<def[team]>_Team"
            - flag server <def[flag]>:<-:<player>
        }

        on player logs in:
        - if <server.has_flag[CTF_Preparing]> {
            - determine "KICKED CTF er i gang med at starte... vent <server.flag[CTF_Preparing].expiration.formatted||0>"
        }
        else if <server.has_flag[CTF_Config_Whitelist]> {
            - if <player.is_op.not> {
                - determine "KICKED CTF er whitelisted."
            }
        }
        else if <server.list_online_players.size> >= <server.flag[CTF_Config_Slots]||200> {
            - if <player.is_op.not> {
                - determine "KICKED CTF er fuld. Slots reseveret kun til VIP."
            }
        }

        on player join:
        - wait 4t
        - if <player.has_flag[CTF_Coins].not> {
            - flag server CTF_Coins:0
        }
        - inject CTF_JoinGame_Task

        on player respawns:
        # - inject CTF_Respawn
        - wait 4t
        - if <player.has_flag[CTF_Base_Flag]> {
            - run CTF_Return_Flag player:<player> context:<player.flag[CTF_Base_Flag]> instantly
        }
        - inject CTF_Respawn
        - if <server.has_flag[CTF_Playing]> {
            - wait 2t
            - inject KitSystem_Give
        }
        else {
            - if <player.is_op||false> {
                - inventory set d:<player.inventory> o:in@CTF_LobbyMenu_Admin_Inventory
            }
            else {
                - inventory set d:<player.inventory> o:in@CTF_LobbyMenu_Player_Inventory
            }
        }

        on player death:
        - determine NO_DROPS_OR_XP passively
        - if <server.has_flag[CTF_Config_ExplodePlayers]> {
            - define loc <player.location>
            - playeffect <def[loc]> effect:HUGE_EXPLOSION visibility:500 qty:3 offset:0.1
            - playsound sound:EXPLODE <def[loc]> volume:0.5
            - hurt 2 <def[loc].find.players.within[6].exclude[<player>]> cause:ENTITY_ATTACK source:<player>
            - foreach <def[loc].find.players.within[6]> {
                - adjust <def[value]> velocity:<def[loc].add[0,0,0].face[<def[value].eye_location>].direction.vector.mul[1.2]>
            }
        }
        - if <player.has_flag[CTF_Base_Flag]> {
            - run CTF_Return_Flag player:<player> context:<player.flag[CTF_Base_Flag]> instantly
        }

        on system time minutely:
        - if <server.has_flag[CTF_Playing]> {
            - foreach <server.get_online_players_flagged[CTF_Playing]> {
                - run CTF_Coins_Give_Earned player:<def[value]> instantly context:2
                - wait 1t
            }
        }

CTF_ToggleSpectator:
    type: task
    script:
    - if <player.has_flag[CTF_Playing]> {
        - flag player CTF_Playing:!
        - if <player.has_flag[CTF_Team]> {
            - execute as_server "scoreboard teams leave <player.name>"
            - define team <player.flag[CTF_Team]>
            - flag player CTF_Team:!
            - define flag "CTF_<def[team]>_Team"
            - flag server <def[flag]>:<-:<player>
        }
        - adjust <player> gamemode:Spectator
        - if <server.flag[CTF_Current_Lobby]||null> == null {
            - teleport <player> <w@world.spawn_location>
        }
        else {
            - teleport <player> <server.flag[CTF_Current_Lobby]>
        }
        - narrate format:util_ff "<&a>Du er nu en spectator"
    }
    else {
        - inject CTF_JoinGame_Task
        - narrate format:util_ff "<&a>Du er ikke længere en spectator"
    }

CTF_JoinGame_Task:
    type: task
    script:
    - adjust <player> gamemode:Survival
    - flag player CTF_Playing
    - if <server.has_flag[CTF_Playing].not> {
        - sidebar remove
        - if <server.flag[CTF_Current_Lobby]||null> == null {
            - teleport <player> <w@world.spawn_location>
        }
        else {
            - teleport <player> <server.flag[CTF_Current_Lobby]>
        }
        - if <player.is_op||false> {
            - inventory set d:<player.inventory> o:in@CTF_LobbyMenu_Admin_Inventory
        }
        else {
            - inventory set d:<player.inventory> o:in@CTF_LobbyMenu_Player_Inventory
        }
        # - if <server.flag[CTF_Red_Team].as_list.contains[<player>].not||true> {
            # - if <server.flag[CTF_Blue_Team].as_list.contains[<player>].not||true> {
                # - if <server.flag[CTF_None_Team].as_list.contains[<player>].not||true> {
                    # - flag server CTF_None_Team:->:<player>
                # }
            # }
        # }
    }
    else {
        - define red_size "<server.flag[CTF_Red_Team].as_list.size||0>"
        - define blue_size "<server.flag[CTF_Blue_Team].as_list.size||0>"
        - if <def[red_size]> > <def[blue_size]> {
            - ~run CTF_Team_Set instantly context:Blue
        }
        else {
            - ~run CTF_Team_Set instantly context:Red
        }
        - inject CTF_Respawn
        - inject KitSystem_Give
    }

CTF_Admin_Command:
    type: command
    name: admin
    debug: false
    description: Commands for Admin control panel.
    usage: /coin
    aliases:
    - admins
    - ad
    - as
    - kp
    - panel
    - kontrol
    - cp
    permission: ctf.admin
    permission message: <&c>Beklager, ingen adgang!
    script:
    - if <player.is_op||false> {
        - inventory open d:in@CTF_LobbyMenu_Admin_Menu
    }

CTF_AllChat:
    type: command
    name: allchat
    debug: false
    description: Commands for teams.
    usage: /teamchat
    aliases:
    - a
    - all
    - global
    - g
    # permission: ctf.vip
    # permission message: <&c>Beklager, du skal være <&6>VIP for at bruge dette!
    script:
    - define team <player.flag[CTF_Team]||null>
    - define color <s@CTF_Data.yaml_key[config.teams.<def[team]>.color]||&7>
    - announce "<&8>[<&r>G<&8>] <def[color].parse_color><player.name> <&8><&chr[00BB]> <&r><context.raw_args>"

CTF_Coins_Command:
    type: command
    name: coin
    debug: false
    description: Commands for coin system.
    usage: /coin
    aliases:
    - coins
    - mønter
    - penge
    - bal
    - balance
    - money
    - mon
    # permission: ctf.vip
    # permission message: <&c>Beklager, du skal være <&6>VIP for at bruge dette!
    script:
    - if <context.args.size> > 0 {
        - define Target <server.match_offline_player[<context.args.get[1]>]||null>
        - if <def[Target]> == null {
            - narrate FORMAT:util_ff "Ingen spiller fundet!"
            - queue clear
        }
        - narrate FORMAT:util_ff "<&a><def[Target].name>'s Coins<&8><&co> <&6><def[Target].flag[CTF_Coins]||0>"
    }
    else {
        - narrate FORMAT:util_ff "<&a>Dine Coins<&8><&co> <&6><player.flag[CTF_Coins]||0>"
    }

CTF_Coins_Convert_Earned:
    type: task
    script:
    - if <player.has_flag[CTF_Earned]> {
        - define earned <player.flag[CTF_Earned].round||0>
        - define total_coins <player.flag[CTF_Coins].add_int[<def[earned]||0>]||0>
        - flag player CTF_Coins:<def[total_coins]>
        - narrate format:util_ff "<&e>Du modtog <&6><def[earned]> <&e>coins for denne kamp!"
    }

CTF_Coins_Give_Earned:
    type: task
    definitions: amount
    script:
    - define old_earn <player.flag[CTF_Earned].round||0>
    - define new_earn <player.flag[CTF_Earned].add_int[<def[amount]||0>]||0>
    - flag player CTF_Earned:<def[new_earn]> duration:5m

CTF_FriendlyFire:
    type: task
    debug: false
    script:
    - if <server.has_flag[CTF_Playing].not> {
        - determine CANCELLED
    }
    - if <player.has_flag[CTF_Team]> && <def[player].as_player.has_flag[CTF_Team]> {
        - if <player.flag[CTF_Team]> == <def[player].as_player.flag[CTF_Team]> {
            - determine CANCELLED
        }
    }

CTF_Turret_Spawn:
    type: task
    definitions: loc|team
    script:
    - wait 1t
    - define block <def[loc].material>
    - define aboveblock <def[loc].above.material>
    - if <def[team]> == Red {
        - modifyblock <def[loc]> wool,14
    }
    else if <def[team]> == Blue {
        - modifyblock <def[loc]> wool,11
    }
    else {
        - queue clear
    }
    - modifyblock <def[loc].add[0,1,0]> fence
    - flag server CTF_Turrets:->:<def[loc].simple>
    ## ArmorStand 
    - spawn CTF_Turret_Entity <def[loc].simple.as_location.add[0.5,0.6,0.5]> save:gunner
    - define npc <entry[gunner].spawned_entities.get[1]>
    - adjust <def[npc]> equipment:air|air|air|fence
    ## NPC
    # - create player Turret <def[loc].simple.as_location.add[0.5,2,0.5]> save:npc
    # - execute as_server "npc select <entry[npc].created_npc.id>"
    # - execute as_server "npc type minecart"
    # - define npc <entry[npc].created_npc>
    - define ammo 30
    - while <def[npc].is_spawned||false> {
        - inject CTF_Turret_Action
    }
    - remove <def[npc]>
    - flag server CTF_Turrets:<-:<def[loc].simple>
    - modifyblock <def[loc]> <def[block]>
    - modifyblock <def[loc].add[0,1,0]> <def[aboveblock]>

CTF_Turret_Entity:
    type: entity
    entity_type: e@armor_stand
    gravity: false
    visible: false

CTF_Turret_Action:
    type: task
    script:
    - define players <def[npc].location.find.players.within[20].filter[can_see[<def[npc]>]].filter[has_flag[CTF_Team]].filter[flag[CTF_Team].is[EQUALS].to[<def[team]>].not]||null>
    # - narrate "<def[players].parse[name]||null> <def[team]> <def[npc].location.find.players.within[20]>"
    # - narrate "<def[cooldown]||null>"
    - playeffect <def[npc].location> effect:MOB_SPELL visibility:500 qty:5 data:0 offset:0.2
    - if <def[players].is_empty.not||false> {
        - define random <def[players].random>
        ## ArmorStand
        - look <def[npc]> <def[random].location>
        - adjust <def[npc]> armor_pose:body|0,0,0|head|1.55,0,1.55
        ## Npc Minecart
        # - define npcy <def[random].location.y.sub[<def[npc].location.y>].mul[-2]>
        # - look <def[npc]> <def[random].location.add[0,<def[npcy]>,0]>
        # - rotate <def[npc]> yaw:90 frequency:2t duration:2t
        ## Shoot arrow
        - if <def[cooldown]||0> == 0 {
            - define loc2 <def[npc].location>
            - define loc1 <def[random].location>
            - define len <def[loc1].as_location.distance[<def[loc2]>]>
            - define jump <def[loc1].sub[<def[loc2]>].div[<def[len]>]>
            - define pointer <def[loc2].add[<def[jump].mul[2]>]>
            - playeffect <def[pointer].add[0,0.5,0]> effect:Smoke visibility:500 qty:20 data:0 offset:0.1
            - if <player||null> == null {
                - shoot arrow spread:3.0 speed:2.5 origin:<def[pointer].add[0,1.5,0]> destination:<def[random].location.add[0,1,0]>
            }
            else {
                - shoot arrow spread:3.0 speed:2.5 origin:<def[pointer].add[0,1.5,0]> destination:<def[random].location.add[0,1,0]> shooter:<player>
            }
            - playsound <def[npc].location> sound:SHOOT_ARROW volume:5
            - define cooldown 4
        }
        else {
            - define cooldown <def[cooldown].sub_int[1]||0>
        }
    }
    else {
        - if <def[cooldown]||0> != 0 {
            - define cooldown <def[cooldown].sub_int[1]||0>
        }
    }
    - wait 4t

CTF_Scoreboard:
    type: task
    script:
    - while <server.has_flag[CTF_Playing]> {
        - sidebar set "title:<&3><&l>GGPVP <&7><&l>- <&6><&l>CTF" "values:<&8><&l>--------|<&9><server.flag[CTF_Blue_Team].as_list.size||0>|<&9>Blue Points<&co> <&e><server.flag[CTF_Blue_Point].round||0>|<&9>Blue Flag<&co>|<server.flag[CTF_Blue_Flag_Holder]||<&7>Basen><&sp>|<&sp><&sp>|<&c><server.flag[CTF_Red_Team].as_list.size||0>|<&c>Red Points<&co> <&e><server.flag[CTF_Red_Point].round||0>|<&c>Red Flag<&co>|<server.flag[CTF_Red_Flag_Holder]||<&7>Basen>||<&8><&l>--------<&sp>" "players:<server.list_online_players>"
        - wait 2s
    }

CTF_Respawn:
    type: task
    debug: false
    script:
    - if <server.has_flag[CTF_Playing].not> {
        - if <server.flag[CTF_Current_Lobby]||null> == null {
            - teleport <player> <w@world.spawn_location>
        }
        else {
            - teleport <player> <server.flag[CTF_Current_Lobby]>
        } 
    }
    else if <player.has_flag[CTF_Playing]> {
        - if <server.flag[CTF_Blue_Team].as_list.contains[<player>]> {
            - teleport <player> <server.flag[CTF_Current_Blue_Spawns].as_list.random.as_location.add[0.5,0,0.5]>
        }
        else if <server.flag[CTF_Red_Team].as_list.contains[<player>]> {
            - teleport <player> <server.flag[CTF_Current_Red_Spawns].as_list.random.as_location.add[0.5,0,0.5]>
        }
    }

CTF_End:
    type: task
    debug: false
    script:
    - flag server CTF_Playing:!
    - if <server.flag[CTF_Red_Point].round||0> > <server.flag[CTF_Blue_Point].round||0> {
        - title "title:<&a>Game over!" "subtitle:<&c>Red hold har vundet!" stay:7s targets:<server.list_online_players> 
    }
    else {
        - title "title:<&a>Game over!" "subtitle:<&9>Blue hold har vundet!" stay:7s targets:<server.list_online_players> 
    }
    - if <server.has_flag[CTF_Turrets]> {
        - foreach <server.flag[CTF_Turrets].as_list> {
            - remove <def[value].as_location.find.entities[armor_stand].within[2]>
        }
    }
    - flag server CTF_Turrets:!
    - execute as_server "difficulty peaceful"
    - flag server CTF_Red_Team:!
    - flag server CTF_Blue_Team:!
    - adjust <server.get_online_players_flagged[CTF_Playing]> equipment:air|air|air|air
    - foreach <server.get_online_players_flagged[CTF_Playing]> {
        - run CTF_Coins_Convert_Earned player:<def[value]> instantly
        - inventory clear d:<def[value].inventory>
    }
    - sidebar remove "players:<server.list_online_players>"
    - inject CTF_Team_TabList_Reset
    - foreach <server.get_players_flagged[CTF_Base_Flag]> {
        - run CTF_Return_Flag player:<def[value]> context:<def[value].flag[CTF_Base_Flag]> instantly
    }
    - foreach <server.flag[CTF_Class_NPCs].as_list> {
        - execute as_server "npc select <def[value]>"
        - execute as_server "npc remove"
    }
    - wait 5s
    - foreach <server.list_online_players> {
        - if <def[value].is_op||false> {
            - inventory set d:<def[value].inventory> o:in@CTF_LobbyMenu_Admin_Inventory
        }
        else {
            - inventory set d:<def[value].inventory> o:in@CTF_LobbyMenu_Player_Inventory
        }
    }

CTF_Start:
    type: task
    definitions: count
    debug: false
    script:
    - if <def[count].exists.not||true> {
        - define count 10
    }
    - flag server CTF_LockChat
    - narrate format:util_ff "<&a>Starter spillet op. Chatten er låst."
    - flag server CTF_Preparing duration:<def[count]>s
    - repeat <def[count]> {
        - title "title:<&3><def[count].sub_int[<def[value]>]>" fade_in:5t targets:<server.list_online_players> 
        - if <def[count].sub_int[<def[value]>]> == 115 {
            - narrate format:util_ff "<&a>Vi vil nu gå igennem information af CTF!"
        }
        else if <def[count].sub_int[<def[value]>]> == 110 {
            - narrate format:util_ff "<&a>CTF står for Capture The Flag!"
        }
        else if <def[count].sub_int[<def[value]>]> == 100 {
            - narrate format:util_ff "<&a>Det er <&c>Red Team <&a>mod <&9>Blue Team<&a>! Hvert hold har et flag i sin base!"
        }
        else if <def[count].sub_int[<def[value]>]> == 85 {
            - narrate format:util_ff "<&a>Målet er at du skal stjæle modstanderens flag!"
        }
        else if <def[count].sub_int[<def[value]>]> == 75 {
            - narrate format:util_ff "<&a>Når du har modstanderens flag, skal du tilbage til dit eget flag!"
        }
        else if <def[count].sub_int[<def[value]>]> == 65 {
            - narrate format:util_ff "<&a>CTF er Team baseret! I skal arbejde sammen!"
        }
        else if <def[count].sub_int[<def[value]>]> == 55 {
            - run CTF_Show_Scenarios instantly context:30
        }
        else if <def[count].sub_int[<def[value]>]> == 25 {
            - run CTF_Show_Map_Credits instantly context:15
        }
        else if <def[count].sub_int[<def[value]>]> == 15 {
            - narrate format:util_ff "<&a>Husk at du kan skifte class med <&e>/class"
        }
        - wait 1s
    }
    - foreach <server.flag[CTF_Current_NPC_Class].as_list> {
        - define name "<&b>Class Selector"
        - create player <def[name]> <def[value].as_location.add[0.5,0,0.5]> save:npc<def[loop_index]>
        - execute as_server "npc select <entry[npc<def[loop_index]>].created_npc.id>"
        - execute as_server "npc type Villager"
        - execute as_server "npc look"
        - execute as_server "npc assignment --set CTF_Class_NPC_Assign"
    } 
    - inject CTF_Team_SplitUp
    - flag server CTF_Playing
    - flag server CTF_Red_Point:0
    - flag server CTF_Blue_Point:0
    - flag server CTF_Base_Red_Flag
    - flag server CTF_Base_Blue_Flag
    ## Teleport players
    ## Give Class Kits
    - foreach <server.get_online_players_flagged[CTF_Playing]> {
        - run CTF_Respawn instantly player:<def[value]>
        - run KitSystem_Give instantly player:<def[value]>
    }
    - execute as_server "difficulty normal"
    - run CTF_Scoreboard instantly
    - narrate format:util_ff "<&a>Game on! Første team til <&e><server.flag[CTF_Config_PointsWin].round> <&a>point vinder!"
    - flag server CTF_LockChat:!
    - if <server.has_flag[CTF_Config_BaseDefense]> {
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Red_Flag].as_location.add[1,0,1]>|Red
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Red_Flag].as_location.add[-1,0,1]>|Red
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Red_Flag].as_location.add[1,0,-1]>|Red
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Red_Flag].as_location.add[-1,0,-1]>|Red
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Blue_Flag].as_location.add[1,0,1]>|Blue
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Blue_Flag].as_location.add[-1,0,1]>|Blue
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Blue_Flag].as_location.add[1,0,-1]>|Blue
        - wait 1s
        - run CTF_Turret_Spawn instantly context:<server.flag[CTF_Current_Blue_Flag].as_location.add[-1,0,-1]>|Blue
        # <def[Red_Flag].as_location.add[-1,-1,-1]>|<def[Red_Flag].as_location.add[1,2,1]>
    }
    - wait 10s
    - narrate format:util_ff "<&a>Husk at din chat er for dit team."
    - narrate format:util_ff "<&a>Du kan snakke til alle via <&e>/g"

CTF_Class_NPC_Assign:
    type: assignment
    debug: false
    actions:
        on assignment:
        - trigger name:click state:true
        - flag server CTF_Class_NPCs:->:<npc.id>
    interact scripts:
    - 10 CTF_Class_NPC_Main

CTF_Class_NPC_Main:
    type: interact
    debug: false
    steps:
        1:
            click trigger:
                script:
                - execute as_player "class"


CTF_Show_Scenarios:
    type: task
    definitions: total_time
    script:
    - narrate format:util_ff "<&7>Indlæser scenarios..."
    - flag server CTF_Configs:!
    - if <server.has_flag[CTF_Config_TeamChoice]> {
        - flag server CTF_Configs:->:TeamChoice
    }
    - if <server.has_flag[CTF_Config_DebuffFlag]> {
        - flag server CTF_Configs:->:DebuffFlag
    }
    - if <server.has_flag[CTF_Config_ExplodePlayers]> {
        - flag server CTF_Configs:->:ExplodePlayers
    }
    - if <server.has_flag[CTF_Config_SameClass]> {
        - flag server CTF_Configs:->:SameClass
    }
    - if <server.has_flag[CTF_Config_AllUnlock]> {
        - flag server CTF_Configs:->:AllUnlock
    }
    - if <server.has_flag[CTF_Config_BaseDefense]> {
        - flag server CTF_Configs:->:BaseDefense
    }
    - if <server.has_flag[CTF_Config_PvAI]> {
        - flag server CTF_Configs:->:PvAI
    }
    - if <server.has_flag[CTF_Config_Hitman]> {
        - flag server CTF_Configs:->:Hitman
    }
    - define configs <server.flag[CTF_Configs].as_list>
    - define wait_each <def[total_time].div[<def[configs].size>].round_down>
    - foreach <def[configs]> {
        - narrate format:util_ff "<&6><def[value]>"
        - wait <wait_each]>s
    }
    # CTF_Config_TeamChoice
    # CTF_Config_DebuffFlag
    # CTF_Config_ExplodePlayers
    # CTF_Config_SameClass
    # CTF_Config_AllUnlock
    # CTF_Config_BaseDefense
    # CTF_Config_PvAI
    # CTF_Config_Hitman

CTF_Show_Map_Credits:
    type: task
    definitions: total_time
    script:
    - define creators <server.flag[CTF_Current_Creators].as_list>
    - define wait_each <def[total_time].div[<def[creators].size>].round_down>
    - foreach <def[creators]> {
        - define creator <def[value]>
        - narrate format:util_ff "<&b>Map lavet af <def[creator]>"
        - repeat <def[wait_each]> {
            - actionbar "<&b>Map lavet af <def[creator]>" targets:<server.list_online_players>
            - wait 1s
        }
    }


CTF_Team_PreJoin:
    type: task
    debug: false
    definitions: team
    script:
    - if <server.flag[CTF_<def[team]>_Team].as_list.contains[<player>]||false> {
            - narrate format:util_ff "<&e>Du er allerede på det team!"
            - queue clear
    }
    - define red_size "<server.flag[CTF_Red_Team].as_list.size||0>"
    - define blue_size "<server.flag[CTF_Blue_Team].as_list.size||0>"
    - define none_size "<server.get_online_players_flagged[CTF_Playing].size.div_int[2]||0>"
    - if <def[team]> == "Red" {
        - if <def[red_size]> < <def[none_size]> {
            - run CTF_Team_Set instantly player:<player> context:Red
        }
        else {
            - narrate format:util_ff "<&e>Det team er fuld!"
        }
    }
    else {
        - if <def[blue_size]> < <def[none_size]> {
            - run CTF_Team_Set instantly player:<player> context:Blue
        }
        else {
            - narrate format:util_ff "<&e>Det team er fuld!"
        }
    }

CTF_Team_Set:
    type: task
    definitions: team
    script:
    - if <server.flag[CTF_Blue_Team].as_list.contains[<player>]||false> {
        - if <def[team]> == Blue {
            - narrate format:util_ff "<&e>Du er allerede på det team!"
            - queue clear
        }
        - flag server CTF_Blue_Team:<-:<player>
    }
    - if <server.flag[CTF_Red_Team].as_list.contains[<player>]||false> {
        - if <def[team]> == Red {
            - narrate format:util_ff "<&e>Du er allerede på det team!"
            - queue clear
        }
        - flag server CTF_Red_Team:<-:<player>
    }
    - define flag "CTF_<def[team]>_Team"
    - flag server <def[flag]>:->:<player>
    - flag player CTF_Team:<def[team]>
    - execute as_server "scoreboard teams join <def[team]> <player.name>"
    - narrate format:util_ff "<&a>Du joinede <def[team]> team!"

CTF_Team_SplitUp:
    type: task
    debug: false
    script:
    - flag server CTF_None_Team:!
    - foreach <server.get_players_flagged[CTF_Playing]> {
        - if <server.flag[CTF_Red_Team].as_list.contains[<def[value]>].not||true> {
            - if <server.flag[CTF_Blue_Team].as_list.contains[<def[value]>].not||true> {
                - flag server CTF_None_Team:->:<def[value]>
            }
        }
    }
    # - narrate "<server.flag[CTF_None_Team].as_list.size>"
    # - foreach <server.flag[CTF_None_Team].as_list.random[40]> {
        # - flag server CTF_Red_Team:->:<def[value]>
        # - flag server CTF_None_Team:<-:<def[value]>
    # }
    ##
    - define none_size <server.flag[CTF_None_Team].as_list.size>
    - define red_needs <def[none_size].sub_int[<server.flag[CTF_Red_Team].as_list.size||0>].add_int[<server.flag[CTF_Blue_Team].as_list.size||0>].div_int[2]>
    - if <def[red_needs]> < 0 {
        - define red_needs 0
    }
    - foreach <server.flag[CTF_None_Team].as_list.random[<def[red_needs]>]> {
        - flag server CTF_None_Team:<-:<def[value]>
        - ~run CTF_Team_Set instantly player:<def[value]> context:Red
    }
    - foreach <server.flag[CTF_None_Team].as_list||li@> {
        - flag server CTF_None_Team:<-:<def[value]>
        - ~run CTF_Team_Set instantly player:<def[value]> context:Blue
    }
    # - narrate "<&c><server.flag[CTF_Red_Team].as_list.size||0>"
    # - narrate "<&9><server.flag[CTF_Blue_Team].as_list.size||0>"

CTF_Team_TabList_Reset:
    type: task
    debug: false
    script:
    - execute as_server "scoreboard teams remove Red"
    - execute as_server "scoreboard teams remove Blue"
    - wait 2t
    - execute as_server "scoreboard teams add Red Red"
    - execute as_server "scoreboard teams add Blue Blue"
    - execute as_server "scoreboard teams option Red color red"
    - execute as_server "scoreboard teams option Blue color blue"
    - execute as_server "scoreboard teams option Red friendlyfire false"
    - execute as_server "scoreboard teams option Blue friendlyfire false"
    - execute as_server "scoreboard teams option Red seeFriendlyInvisibles true"
    - execute as_server "scoreboard teams option Blue seeFriendlyInvisibles true"
    - execute as_server "scoreboard teams option Red nametagVisibility always"
    - execute as_server "scoreboard teams option Blue nametagVisibility always"
    - execute as_server "scoreboard teams option Red deathMessageVisibility never"
    - execute as_server "scoreboard teams option Blue deathMessageVisibility never"