chat_handler:
    type: world
    debug: false
    events:
        on player steps on block:
        - if !<player.is_op> && <player.flag[nation]> != wt && <player.has_flag[wtchannel_joined]> {
            - flag player wtchannel_joined:!
            - flag player channel:!
            - flag player wtchannel_passed:!
            - narrate "<&b>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != ek && <player.has_flag[ekchannel_joined]> {
            - flag player ekchannel_joined:!
            - flag player channel:!
            - flag player ekchannel_passed:!
            - narrate "<&a>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != fn && <player.has_flag[fnchannel_joined]> {
            - flag player fnchannel_joined:!
            - flag player channel:!
            - flag player fnchannel_passed:!
            - narrate "<&c>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != an && <player.has_flag[anchannel_joined]> {
            - flag player anchannel_joined:!
            - flag player channel:!
            - flag player anchannel_passed:!
            - narrate "<&7>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != bht && <player.has_flag[bhtchannel_joined]> {
            - flag player bhtchannel_joined:!
            - flag player channel:!
            - flag player bhtchannel_passed:!
            - narrate "<&4>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != bhs && <player.has_flag[bhschannel_joined]> {
            - flag player bhschannel_joined:!
            - flag player channel:!
            - flag player bhschannel_passed:!
            - narrate "<&e>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != fst && <player.has_flag[fstchannel_joined]> {
            - flag player fstchannel_joined:!
            - flag player channel:!
            - flag player fstchannel_passed:!
            - narrate "<&a>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != sw && <player.has_flag[swchannel_joined]> {
            - flag player swchannel_joined:!
            - flag player channel:!
            - flag player swchannel_passed:!
            - narrate "<&6>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if <player.flag[rank]> != leader && <player.has_flag[nlchannel_joined]> {
            - flag player nlchannel_joined:!
            - flag player channel:!
            - narrate "<&8>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        on player chats:
        - if !<player.is_op> && <player.flag[nation]> != wt && <player.has_flag[wtchannel_joined]> {
            - flag player wtchannel_joined:!
            - flag player channel:!
            - flag player wtchannel_passed:!
            - narrate "<&b>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != ek && <player.has_flag[ekchannel_joined]> {
            - flag player ekchannel_joined:!
            - flag player channel:!
            - flag player ekchannel_passed:!
            - narrate "<&a>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != fn && <player.has_flag[fnchannel_joined]> {
            - flag player fnchannel_joined:!
            - flag player channel:!
            - flag player fnchannel_passed:!
            - narrate "<&c>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != an && <player.has_flag[anchannel_joined]> {
            - flag player anchannel_joined:!
            - flag player channel:!
            - flag player anchannel_passed:!
            - narrate "<&7>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != bht && <player.has_flag[bhtchannel_joined]> {
            - flag player bhtchannel_joined:!
            - flag player channel:!
            - flag player bhtchannel_passed:!
            - narrate "<&4>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != bhs && <player.has_flag[bhschannel_joined]> {
            - flag player bhschannel_joined:!
            - flag player channel:!
            - flag player bhschannel_passed:!
            - narrate "<&e>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != fst && <player.has_flag[fstchannel_joined]> {
            - flag player fstchannel_joined:!
            - flag player channel:!
            - flag player fstchannel_passed:!
            - narrate "<&a>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.is_op> && <player.flag[nation]> != sw && <player.has_flag[swchannel_joined]> {
            - flag player swchannel_joined:!
            - flag player channel:!
            - flag player swchannel_passed:!
            - narrate "<&6>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if <player.flag[rank]> != leader && <player.has_flag[nlchannel_joined]> {
            - flag player nlchannel_joined:!
            - flag player channel:!
            - narrate "<&8>We detected that you were able to see messages from a channel that you shouldn't have been able to, so we kicked you to global."
        }
        - if !<player.has_flag[channel]> {
            - queue clear
        }
        - if <player.flag[channel].is[==].to[wtchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:wtchannel_joined format:wtformat
        }
        - if <player.flag[channel].is[==].to[ekchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:ekchannel_joined format:ekformat
        }
        - if <player.flag[channel].is[==].to[fnchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:fnchannel_joined format:fnformat
        }
        - if <player.flag[channel].is[==].to[anchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:anchannel_joined format:anformat
        }
        - if <player.flag[channel]> == rpchannel {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - narrate format:rpformat "<context.message>" targets:<player.location.find.players.within[20]>
        }
        - if <player.flag[channel].is[==].to[bhtchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:bhtchannel_joined format:bhtformat
        }
        - if <player.flag[channel].is[==].to[bhschannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:bhschannel_joined format:bhsformat
        }
        - if <player.flag[channel].is[==].to[fstchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:fstchannel_joined format:fstformat
        }
        - if <player.flag[channel].is[==].to[swchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - announce <context.message> to_flagged:swchannel_joined format:swformat
        }
        - if <player.flag[channel].is[==].to[whisperchannel]> {
            - if <player.has_flag[bct]> queue clear
            - determine passively cancelled
            - narrate <context.message> format:whisperformat targets:<player.location.find.players.within[5]>
        }
        - if <player.flag[channel].is[==].to[nlchannel]> {
            - determine passively cancelled
            - announce <context.message> format:nlformat to_flagged:nlchannel_joined
        }
        - if <player.flag[channel].is[==].to[lcchannel]> {
            - determine passively cancelled
            - announce <context.message> format:lcformat to_flagged:lcchannel_joined
        }
        - if <player.flag[channel].is[==].to[staffchannel]> {
            - determine passively cancelled
            - announce <context.message> format:staffformat to_flagged:staffchannel_joined
        }
        - if <player.flag[channel].is[==].to[builderchannel]> {
            - determine passively cancelled
            - announce <context.message> format:builderformat to_flagged:builderchannel_joined
        }
        - if <player.flag[channel].is[==].to[tpchannel]> {
            - determine passively cancelled
            - announce <context.message> format:tpformat to_flagged:tpchannel_joined
        }
        - if <player.flag[channel].is[==].to[amaguqchannel]> {
            - determine passively cancelled
            - announce <context.message> format:amaguqformat to_flagged:amaguqchannel_joined
        }

wtformat:
    type: format
    format: "<&b>[WT Chat] <player.name.display><&f><&b><&co> <&b><text>"

ekformat:
    type: format
    format: "<&a>[EK Chat] <player.name.display><&f><&a><&co> <&a><text>"

fnformat:
    type: format
    format: "<&c>[FN Chat] <player.name.display><&c><&c><&co> <&c><text>"

anformat:
    type: format
    format: "<&7>[AN Chat] <player.name.display><&f><&7><&co> <&7><text>"

rpformat:
    type: format
    format: "<&e>[RP Chat] <player.name.display><&e><&co> <&e><text>"

bhtformat:
    type: format
    format: "<&4>[BhT Chat] <player.name.display><&4><&co> <text>"

bhsformat:
    type: format
    format: "<&e>[SB Chat] <player.name.display><&e><&co> <text>"

fstformat:
    type: format
    format: "<&a>[FST Chat] <player.name.display><&a><&co> <text>"

swformat:
    type: format
    format: "<&6>[SW Chat] <player.name.display><&6><&co> <text>"

whisperformat:
    type: format
    format: "<&5>[Whisper] <player.name.display><&d><&co> <&d><text>"

nlformat:
    type: format
    format: "<&8>[Nation Leaders] <player.name.display><&7><&co> <&7><text>"

lcformat:
    type: format
    format: "<&5>[Lore Council] <player.name.display><&d><&co> <text>"

staffformat:
    type: format
    format: "<&3>[Staff Chat] <player.name.display><&3><&co> <text>"

builderformat:
    type: format
    format: "<&2>[Builder Chat] <player.name.display><&2><&co> <text>"

tpformat:
    type: format
    format: "<&b>[Team Palladian] <player.name.display><&b><&co> <text>"

amaguqformat:
    type: format
    format: "<&9>[Amaguq] <player.name.display><&9><&co> <text>"

wtchannel_item:
    type: item
    material: i@water_bucket
    display name: <&3><&l>Water Tribe
    lore:
    - <&3>Click me to
    - <&3>join the WT
    - <&3>chat channel!

ekchannel_item:
    type: item
    material: i@grass
    display name: <&2><&l>Earth Kingdom
    lore:
    - <&2>Click me to
    - <&2>join the EK
    - <&2>chat channel!

fnchannel_item:
    type: item
    material: i@blaze_powder
    display name: <&4><&l>Fire Nation
    lore:
    - <&4>Click me to
    - <&4>join the FN
    - <&4>chat channel!

anchannel_item:
    type: item
    material: i@string
    display name: <&7><&l>Air Nomads
    lore:
    - <&7>Click me to
    - <&7>join the AN
    - <&7>chat channel!

bhtchannel_item:
    type: item
    material: i@red_wool
    display name: <&c><&l>Bhanti Tribe
    lore:
    - <&c>Click me to
    - <&c>join the BhT
    - <&c>chat channel!

bhschannel_item:
    type: item
    material: i@sand
    display name: <&e><&l>Sandbender Tribe
    lore:
    - <&e>Click me to
    - <&e>join the SB
    - <&e>chat channel!

fstchannel_item:
    type: item
    material: i@vine
    display name: <&a><&l>Foggy Swamp Tribe
    lore:
    - <&a>Click me to
    - <&a>join the FST
    - <&a>chat channel!

swchannel_item:
    type: item
    material: i@blaze_rod
    display name: <&6><&l>Sun Warriors
    lore:
    - <&6>Click me to
    - <&6>join the SW
    - <&6>chat channel!

rpchannel_item:
    type: item
    material: i@torch
    display name: <&e><&l>RP Channel
    lore:
    - <&e>Click me to
    - <&e>join the Roleplay
    - <&e>chat channel!

globalchannel_item:
    type: item
    material: i@workbench
    display name: <&f><&l>Global Channel
    lore:
    - <&b>Click me to
    - <&b>join the Global
    - <&b>chat channel!

whisperchannel_item:
    type: item
    material: i@painting
    display name: <&5><&l>Whisper Channel
    lore:
    - <&5>Click me to
    - <&5>join the Whisper
    - <&5>chat channel!

maniluuq_credit:
    type: item
    material: i@sign
    display name: <&3>dChannels
    lore:
    - <&b>Created by
    - <&b>Maniluuq

channel_exit_gui_item:
    type: item
    material: i@barrier
    display name: <&4><&l>Menu To Exit Channels
    lore:
    - <&4>Click me to
    - <&4>find the channel
    - <&4>exit page!

########################################################
##                 Broadcast Toggle                   ##
########################################################

bct:
    type: command
    debug: false
    description: Toggle broadcast (Ops Only)
    name: bct
    usage: /bct
    permission: maniluuq.bct
    script:
    - if !<player.has_permission[maniluuq.bct]> {
        - narrate "<&c>Sorry <player.name>, but you need the permisison maniluuq.bct to use this command!"
    }
    - if <player.has_flag[bct]> {
        - flag player bct:!
        - narrate "<&c>Broadcast Mode<&co> Off"
        - queue clear
    }
    - if !<player.has_flag[bct]> {
        - flag player bct
        - narrate "<&c>Broadcast Mode<&co> On"
    }


bct_chathandler:
    type: world
    debug: false
    events:
        on player chats:
        - if <player.has_flag[bct]> {
            - if !<player.has_flag[channel]> {
                - determine passively cancelled
                - announce <context.message> format:bctformat
            }
            - if <player.flag[channel]> == wtchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:wtchannel_joined format:wtbct
            }
            - if <player.flag[channel]> == ekchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:ekchannel_joined format:ekbct
            }
            - if <player.flag[channel]> == fnchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:fnchannel_joined format:fnbct
            }
            - if <player.flag[channel]> == anchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:anchannel_joined format:anbct
            }
            - if <player.flag[channel]> == rpchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:rpchannel_joined
            }
            - if <player.flag[channel]> == bhtchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:bhtchannel_joined format:bhtbct
            }
            - if <player.flag[channel]> == bhschannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:bhschannel_joined format:bhsbct
            }
            - if <player.flag[channel]> == fstchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:fstchannel_joined format:fstbct
            }
            - if <player.flag[channel]> == swchannel {
                - determine passively cancelled
                - announce <context.message> to_flagged:swchannel_joined format:swbct
            }
        }

bctformat:
    type: format
    format: "<&7><&l><text>"

wtbct:
    type: format
    format: "<&3>[WT Announcement] <text>"

ekbct:
    type: format
    format: "<&2>[EK Announcement] <text>"

fnbct:
    type: format
    format: "<&4>[FN Announcement] <&c><text>"

anbct:
    type: format
    format: "<&7>[AN Announcement] <text>"

rpbct:
    type: format
    format: "<&e><&l><text>"

bhtbct:
    type: format
    format: "<&c>[BhT Announcement] <text>"

bhsbct:
    type: format
    format: "<&e>[SB Announcement] <text>"

fstbct:
    type: format
    format: "<&a>[FST Announcement] <text>"

swbct:
    type: format
    format: "<&6>[SW Announcement] <text>"

########################################################
##                 Channel Commands                   ##
########################################################
channel_command:
    type: command
    debug: false
    name: channel
    aliases:
    - ch
    - chan
    - channel
    script:
    - choose "<context.args.get[1]>":
        - case "help":
            - narrate "<&3>---------------------"
            - narrate "<&b>  dChannels by Maniluuq"
            - narrate "<&3>---------------------"
            - narrate "<&3>/ch (channel)<&co> <&b>Join the specified channel."
            - narrate "<&3>/ch leave (channel)<&co> <&b>Leave the specified channel."
            - narrate "<&3>/ch list<&co> <&b>List all available channels."
            - narrate "<&3>/ch password (password)<&co> <&b>change the password of your nation's channel if you are the leader."
        - case "list":
            - narrate "<&b>Water Tribe (wt)"
            - narrate "<&a>Earth Kingdom (ek)"
            - narrate "<&c>Fire Nation (fn)"
            - narrate "<&7>Air Nomads (an)"
            - narrate "<&e>RP Channel (rp)"
            - narrate "<&4>Bhanti Tribe (bht)"
            - narrate "<&e>Sandbender Tribe (bhs)"
            - narrate "<&a>Foggy Swamp Tribe (fst)"
            - narrate "<&6>Sun Warriors (sw)"
            - narrate "<&5>Whisper (w)"
            - narrate "<&b>Please note that you must use the abbreviation in parentheisis to join a channel."
            - narrate "<&c>Private Channels<&co>"
            - narrate "<&8>Nation Leaders (nl)"
            - narrate "<&5>Lore Council (lc)"
            - narrate "<&3>Staff Channel (staff)"
            - narrate "<&2>Builder Channel (builder)"
            - narrate "<&b>Team Palladian (tp)"
            - narrate "<&9>Amaguq (amaguq)"
        - case "leave":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "wt":
                            - if <player.has_flag[wtchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&b>Water Tribe <&a>channel." to_flagged:wtchannel_joined
                                - flag player wtchannel_joined:!
                                - flag player channel:!
                                - flag player wtchannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the WT Channel in the first place!"
                            }
                        - case "ek":
                            - if <player.has_flag[ekchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&a>Earth Kingdom <&a>channel." to_flagged:ekchannel_joined
                                - flag player ekchannel_joined:!
                                - flag player channel:!
                                - flag player ekchannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the EK Channel in the first place!"
                            }
                        - case "fn":
                            - if <player.has_flag[fnchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&c>Fire Nation <&a>channel." to_flagged:fnchannel_joined
                                - flag player fnchannel_joined:!
                                - flag player channel:!
                                - flag player fnchannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the FN Channel in the first place!"
                            }
                        - case "an":
                            - if <player.has_flag[anchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&7>Air Nomads <&a>channel." to_flagged:anchannel_joined
                                - flag player anchannel_joined:!
                                - flag player channel:!
                                - flag player anchannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the AN Channel in the first place!"
                            }
                        - case "bht":
                            - if <player.has_flag[bhtchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&4>Bhanti Tribe <&a>channel." to_flagged:bhtchannel_joined
                                - flag player bhtchannel_joined:!
                                - flag player channel:!
                                - flag player bhtchannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the BhT Channel in the first place!"
                            }
                        - case "bhs":
                            - if <player.has_flag[bhschannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&e>Sandbender Tribe <&a>channel." to_flagged:bhschannel_joined
                                - flag player bhschannel_joined:!
                                - flag player channel:!
                                - flag player bhschannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the BhS Channel in the first place!"
                            }
                        - case "fst":
                            - if <player.has_flag[fstchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&a>Foggy Swamp Tribe <&a>channel." to_flagged:fstchannel_joined
                                - flag player fstchannel_joined:!
                                - flag player channel:!
                                - flag player fstchannel_passed:!
                            }
                            else {
                                - narrate "<&c>You weren't in the FST Channel in the first place!"
                            }
                        - case "sw":
                            - if <player.has_flag[swchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&6>Sun Warriors <&a>channel." to_flagged:swchannel_joined
                                - flag player swchannel_joined:!
                                - flag player channel:!
                                - flag player swchannel_joined:!
                            }
                            else {
                                - narrate "<&c>You weren't in the SW Channel in the first place!"
                            }
                        - case "nl":
                            - if <player.has_flag[nlchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&8>Nations <&a>channel." to_flagged:nlchannel_joined
                                - flag player nlchannel_joined:!
                                - flag player channel:!
                            }
                            else {
                                - narrate "<&c>You weren't in the NL Channel in the first place!"
                            }
                        - case "lc":
                            - if <player.has_flag[lcchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&5>Lore Council <&a>channel." to_flagged:lcchannel_joined
                                - flag player lcchannel_joined:!
                                - flag player channel:!
                            }
                            else {
                                - narrate "<&c>You weren't in the LC Channel in the first place!"
                            }
                        - case "builder":
                            - if <player.has_flag[builderchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&2>Builder <&a>channel." to_flagged:builderchannel_joined
                                - flag player builderchannel_joined:!
                                - flag player channel:!
                            }
                            else {
                                - narrate "<&c>You weren't in the Builder Channel in the first place!"
                            }
                        - case "tp":
                            - if <player.has_flag[tpchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&b>Team Palladian <&a>channel." to_flagged:tpchannel_joined
                                - flag player tpchannel_joined:!
                                - flag player channel:!
                            }
                            else {
                                - narrate "<&c>You weren't in the TP Channel in the first place!"
                            }
                        - case "amaguq":
                            - if <player.has_flag[amaguqchannel_joined]> {
                                - announce "<&a><player.name.display> has left the <&9>Amaguq <&a>channel." to_flagged:amaguqchannel_joined
                                - flag player amaguqchannel_joined:!
                                - flag player channel:!
                            }
                            else {
                                - narrate "<&c>You weren't in the Amaguq Channel in the first place!"
                            }
        - case "wt":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[wtpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[wtchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:wtchannel
                                    - flag player wtchannel_joined
                                    - flag player wtchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&3>Water Tribe <&a>channel for the first time." to_flagged:wtchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[wtchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:wtchannel
                                    - narrate "<&a>You are now chatting in <&3>Water Tribe"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != wt {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[wtchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:wtchannel
                                - flag player wtchannel_joined
                                - flag player wtchannel_passed
                                - announce "<&a><player.name.display> just joined the <&3>Water Tribe <&a>channel for the first time." to_flagged:wtchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[wtchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:wtchannel
                                - narrate "<&a>You are now chatting in <&3>Water Tribe"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[wtchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:wtchannel
                    - flag player wtchannel_joined
                    - announce "<&a><player.name.display> just joined the <&3>Water Tribe <&a>channel for the first time." to_flagged:wtchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[wtchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:wtchannel
                    - narrate "<&a>You are now chatting in <&3>Water Tribe"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[wtchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[wtchannel_joined]> {
                - flag player channel:!
                - flag player channel:wtchannel
                - flag player wtchannel_joined
                - announce "<&a><player.name.display> just joined the <&3>Water Tribe <&a>channel for the first time." to_flagged:wtchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[wtchannel_joined]> {
                - flag player channel:!
                - flag player channel:wtchannel
                - narrate "<&a>You are now chatting in <&3>Water Tribe"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "ek":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[ekpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[ekchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:ekchannel
                                    - flag player ekchannel_joined
                                    - flag player ekchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&a>Earth Kingdom <&a>channel for the first time." to_flagged:ekchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[ekchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:ekchannel
                                    - narrate "<&a>You are now chatting in <&a>Earth Kingdom"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != ek {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[ekchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:ekchannel
                                - flag player ekchannel_joined
                                - flag player ekchannel_passed
                                - announce "<&a><player.name.display> just joined the <&a>Earth Kingdom <&a>channel for the first time." to_flagged:ekchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[ekchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:ekchannel
                                - narrate "<&a>You are now chatting in <&a>Earth Kingdom"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[ekchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:ekchannel
                    - flag player ekchannel_joined
                    - announce "<&a><player.name.display> just joined the <&a>Earth Kingdom <&a>channel for the first time." to_flagged:ekchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[ekchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:ekchannel
                    - narrate "<&a>You are now chatting in <&a>Earth Kingdom"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[ekchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[ekchannel_joined]> {
                - flag player channel:!
                - flag player channel:ekchannel
                - flag player ekchannel_joined
                - announce "<&a><player.name.display> just joined the <&a>Earth Kingdom <&a>channel for the first time." to_flagged:ekchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[ekchannel_joined]> {
                - flag player channel:!
                - flag player channel:ekchannel
                - narrate "<&a>You are now chatting in <&a>Earth Kingdom"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "fn":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[fnpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[fnchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:fnchannel
                                    - flag player fnchannel_joined
                                    - flag player fnchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&c>Fire Nation <&a>channel for the first time." to_flagged:fnchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[fnchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:fnchannel
                                    - narrate "<&a>You are now chatting in <&c>Fire Nation"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != fn {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[fnchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:fnchannel
                                - flag player fnchannel_joined
                                - flag player fnchannel_passed
                                - announce "<&a><player.name.display> just joined the <&c>Fire Nation <&a>channel for the first time." to_flagged:fnchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[fnchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:fnchannel
                                - narrate "<&a>You are now chatting in <&c>Fire Nation"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[fnchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:fnchannel
                    - flag player fnchannel_joined
                    - announce "<&a><player.name.display> just joined the <&c>Fire Nation <&a>channel for the first time." to_flagged:fnchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[fnchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:fnchannel
                    - narrate "<&a>You are now chatting in <&c>Fire Nation"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[fnchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[fnchannel_joined]> {
                - flag player channel:!
                - flag player channel:fnchannel
                - flag player fnchannel_joined
                - announce "<&a><player.name.display> just joined the <&c>Fire Nation <&a>channel for the first time." to_flagged:fnchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[fnchannel_joined]> {
                - flag player channel:!
                - flag player channel:fnchannel
                - narrate "<&a>You are now chatting in <&c>Fire Nation"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "an":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[anpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[anchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:anchannel
                                    - flag player anchannel_joined
                                    - flag player anchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&7>Air Nomads <&a>channel for the first time." to_flagged:anchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[anchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:anchannel
                                    - narrate "<&a>You are now chatting in <&7>Air Nomads"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != an {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[anchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:anchannel
                                - flag player anchannel_joined
                                - flag player anchannel_passed
                                - announce "<&a><player.name.display> just joined the <&7>Air Nomads <&a>channel for the first time." to_flagged:anchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[anchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:anchannel
                                - narrate "<&a>You are now chatting in <&7>Air Nomads"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[anchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:anchannel
                    - flag player anchannel_joined
                    - announce "<&a><player.name.display> just joined the <&7>Air Nomads <&a>channel for the first time." to_flagged:anchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[anchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:anchannel
                    - narrate "<&a>You are now chatting in <&7>Air Nomads"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[anchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[anchannel_joined]> {
                - flag player channel:!
                - flag player channel:anchannel
                - flag player anchannel_joined
                - announce "<&a><player.name.display> just joined the <&7>Air Nomads <&a>channel for the first time." to_flagged:anchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[anchannel_joined]> {
                - flag player channel:!
                - flag player channel:anchannel
                - narrate "<&a>You are now chatting in <&7>Air Nomads"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "rp":
            - flag player channel:!
            - flag player channel:rpchannel
            - flag player rpchannel_joined
            - inventory close d:in@channel_gui
            - narrate "<&a>You are now chatting in <&e>RP"
            - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
        - case "bht":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[bhtpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[bhtchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:bhtchannel
                                    - flag player bhtchannel_joined
                                    - flag player bhtchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&4>Bhanti Tribe <&a>channel for the first time." to_flagged:bhtchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[bhtchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:bhtchannel
                                    - narrate "<&a>You are now chatting in <&4>Bhanti Tribe"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != bht {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[bhtchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:bhtchannel
                                - flag player bhtchannel_joined
                                - flag player bhtchannel_passed
                                - announce "<&a><player.name.display> just joined the <&4>Bhanti Tribe <&a>channel for the first time." to_flagged:bhtchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[bhtchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:bhtchannel
                                - narrate "<&a>You are now chatting in <&4>Bhanti Tribe"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[bhtchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:bhtchannel
                    - flag player bhtchannel_joined
                    - announce "<&a><player.name.display> just joined the <&4>Bhanti Tribe <&a>channel for the first time." to_flagged:bhtchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[bhtchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:bhtchannel
                    - narrate "<&a>You are now chatting in <&4>Bhanti Tribe"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[bhtchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[bhtchannel_joined]> {
                - flag player channel:!
                - flag player channel:bhtchannel
                - flag player bhtchannel_joined
                - announce "<&a><player.name.display> just joined the <&4>Bhanti Tribe <&a>channel for the first time." to_flagged:bhtchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[bhtchannel_joined]> {
                - flag player channel:!
                - flag player channel:bhtchannel
                - narrate "<&a>You are now chatting in <&4>Bhanti Tribe"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "bhs":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[bhspassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[bhschannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:bhschannel
                                    - flag player bhschannel_joined
                                    - flag player bhschannel_passed
                                    - announce "<&a><player.name.display> just joined the <&e>Sandbender Tribe <&a>channel for the first time." to_flagged:bhschannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[bhschannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:bhschannel
                                    - narrate "<&a>You are now chatting in <&e>Sandbender Tribe"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != bhs {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[bhschannel_joined]> {
                                - flag player channel:!
                                - flag player channel:bhschannel
                                - flag player bhschannel_joined
                                - flag player bhschannel_passed
                                - announce "<&a><player.name.display> just joined the <&e>Sandbender Tribe <&a>channel for the first time." to_flagged:bhschannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[bhschannel_joined]> {
                                - flag player channel:!
                                - flag player channel:bhschannel
                                - narrate "<&a>You are now chatting in <&e>Sandbender Tribe"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[bhschannel_joined]> {
                    - flag player channel:!
                    - flag player channel:bhschannel
                    - flag player bhschannel_joined
                    - announce "<&a><player.name.display> just joined the <&e>Sandbender Tribe <&a>channel for the first time." to_flagged:bhschannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[bhschannel_joined]> {
                    - flag player channel:!
                    - flag player channel:bhschannel
                    - narrate "<&a>You are now chatting in <&e>Sandbender Tribe"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[bhschannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[bhschannel_joined]> {
                - flag player channel:!
                - flag player channel:bhschannel
                - flag player bhschannel_joined
                - announce "<&a><player.name.display> just joined the <&e>Sandbender Tribe <&a>channel for the first time." to_flagged:bhschannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[bhschannel_joined]> {
                - flag player channel:!
                - flag player channel:bhschannel
                - narrate "<&a>You are now chatting in <&e>Sandbender Tribe"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "fst":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[fstpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[fstchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:fstchannel
                                    - flag player fstchannel_joined
                                    - flag player fstchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&a>Foggy Swamp Tribe <&a>channel for the first time." to_flagged:fstchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[fstchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:fstchannel
                                    - narrate "<&a>You are now chatting in <&a>Foggy Swamp Tribe"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != fst {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[fstchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:fstchannel
                                - flag player fstchannel_joined
                                - flag player fstchannel_passed
                                - announce "<&a><player.name.display> just joined the <&a>Foggy Swamp Tribe <&a>channel for the first time." to_flagged:fstchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[fstchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:fstchannel
                                - narrate "<&a>You are now chatting in <&a>Foggy Swamp Tribe"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[fstchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:fstchannel
                    - flag player fstchannel_joined
                    - announce "<&a><player.name.display> just joined the <&a>Foggy Swamp Tribe <&a>channel for the first time." to_flagged:fstchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[fstchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:fstchannel
                    - narrate "<&a>You are now chatting in <&a>Foggy Swamp Tribe"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[fstchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[fstchannel_joined]> {
                - flag player channel:!
                - flag player channel:fstchannel
                - flag player fstchannel_joined
                - announce "<&a><player.name.display> just joined the <&a>Foggy Swamp Tribe <&a>channel for the first time." to_flagged:fstchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[fstchannel_joined]> {
                - flag player channel:!
                - flag player channel:fstchannel
                - narrate "<&a>You are now chatting in <&a>Foggy Swamp Tribe"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "sw":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[swpassword]>":
                            - if <player.is_op> {
                                - if !<player.has_flag[swchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:swchannel
                                    - flag player swchannel_joined
                                    - flag player swchannel_passed
                                    - announce "<&a><player.name.display> just joined the <&6>Sun Warriors <&a>channel for the first time." to_flagged:swchannel_joined
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                                - if <player.has_flag[swchannel_joined]> {
                                    - flag player channel:!
                                    - flag player channel:swchannel
                                    - narrate "<&a>You are now chatting in <&6>Sun Warriors"
                                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                    - queue clear
                                }
                            }
                            - if <player.flag[nation]> != sw {
                                - narrate "<&c>You cannot join this channel!"
                                - queue clear
                            }
                            - if !<player.has_flag[swchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:swchannel
                                - flag player swchannel_joined
                                - flag player swchannel_passed
                                - announce "<&a><player.name.display> just joined the <&6>Sun Warriors <&a>channel for the first time." to_flagged:swchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[swchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:swchannel
                                - narrate "<&a>You are now chatting in <&6>Sun Warriors"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
            - if <player.is_op> {
                - if !<player.has_flag[swchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:swchannel
                    - flag player swchannel_joined
                    - announce "<&a><player.name.display> just joined the <&6>Sun Warriors <&a>channel for the first time." to_flagged:swchannel_joined
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
                - if <player.has_flag[swchannel_joined]> {
                    - flag player channel:!
                    - flag player channel:swchannel
                    - narrate "<&a>You are now chatting in <&6>Sun Warriors"
                    - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                    - queue clear
                }
            }
            - if !<player.has_flag[swchannel_passed]> {
                - narrate "<&c>Incorrect password."
                - queue clear
            }
            - if !<player.has_flag[swchannel_joined]> {
                - flag player channel:!
                - flag player channel:swchannel
                - flag player swchannel_joined
                - announce "<&a><player.name.display> just joined the <&6>Sun Warriors <&a>channel for the first time." to_flagged:swchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[swchannel_joined]> {
                - flag player channel:!
                - flag player channel:swchannel
                - narrate "<&a>You are now chatting in <&6>Sun Warriors"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "nl":
            - if <player.flag[rank]> != leader {
                - narrate "<&c>You cannot join this channel!"
                - queue clear
            }
            - if !<player.has_flag[nlchannel_joined]> {
                - flag player channel:!
                - flag player channel:nlchannel
                - flag player nlchannel_joined
                - inventory close d:in@channel_gui
                - announce "<&a><player.name.display> just joined the <&8>Nation Leaders <&a>channel for the first time." to_flagged:nlchannel_joined
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
            - if <player.has_flag[nlchannel_joined]> {
                - flag player channel:!
                - flag player channel:nlchannel
                - inventory close d:in@channel_gui
                - narrate "<&a>You are now chatting in <&8>Nation Leaders"
                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                - queue clear
            }
        - case "lc":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[lcpassword]>":
                            - if !<player.has_flag[lcchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:lcchannel
                                - flag player lcchannel_joined
                                - inventory close d:in@channel_gui
                                - announce "<&a><player.name.display> just joined the <&5>Lore Council <&a>channel for the first time." to_flagged:lcchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[lcchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:lcchannel
                                - inventory close d:in@channel_gui
                                - narrate "<&a>You are now chatting in <&5>Lore Council"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
        - case "staff":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[staffpassword]>":
                            - if !<player.has_flag[staffchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:staffchannel
                                - flag player staffchannel_joined
                                - inventory close d:in@channel_gui
                                - announce "<&a><player.name.display> just joined the <&3>Staff <&a>channel for the first time." to_flagged:staffchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[staffchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:staffchannel
                                - inventory close d:in@channel_gui
                                - narrate "<&a>You are now chatting in <&3>Staff"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
        - case "builder":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[builderpassword]>":
                            - if !<player.has_flag[builderchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:builderchannel
                                - flag player builderchannel_joined
                                - inventory close d:in@channel_gui
                                - announce "<&a><player.name.display> just joined the <&2>Builders <&a>channel for the first time." to_flagged:builderchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[builderchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:builderchannel
                                - inventory close d:in@channel_gui
                                - narrate "<&a>You are now chatting in <&2>Builders"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
        - case "tp":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[tppassword]>":
                            - if !<player.has_flag[tpchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:tpchannel
                                - flag player tpchannel_joined
                                - inventory close d:in@channel_gui
                                - announce "<&a><player.name.display> just joined the <&b>Team Palladian <&a>channel for the first time." to_flagged:tpchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[tpchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:tpchannel
                                - inventory close d:in@channel_gui
                                - narrate "<&a>You are now chatting in <&b>Team Palladian"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
        - case "amaguq":
            - choose "<context.args.size>":
                - case "2":
                    - choose "<context.args.get[2]>":
                        - case "<yaml[channelpasswords].read[amaguqpassword]>":
                            - if !<player.has_flag[amaguqchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:amaguqchannel
                                - flag player amaguqchannel_joined
                                - inventory close d:in@channel_gui
                                - announce "<&a><player.name.display> just joined the <&9>Amaguq <&a>channel for the first time." to_flagged:amaguqchannel_joined
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
                            - if <player.has_flag[amaguqchannel_joined]> {
                                - flag player channel:!
                                - flag player channel:amaguqchannel
                                - inventory close d:in@channel_gui
                                - narrate "<&a>You are now chatting in <&9>Amaguq"
                                - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
                                - queue clear
                            }
        - case "password":
            - choose "<context.args.size>":
                - case "3":
                    - choose "<context.args.get[2]>":
                        - case "wt":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set wtpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&b>The WT Channel's password is now <yaml[channelpasswords].read[wtpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == wt {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set wtpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&b>The WT Channel's password is now <yaml[channelpasswords].read[wtpassword]>"
                                    }
                        - case "ek":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set ekpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&2>The EK Channel's password is now <yaml[channelpasswords].read[ekpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == ek {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set ekpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&2>The EK Channel's password is now <yaml[channelpasswords].read[ekpassword]>"
                                    }
                        - case "fn":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set fnpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&c>The FN Channel's password is now <yaml[channelpasswords].read[fnpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == fn {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set fnpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&c>The FN Channel's password is now <yaml[channelpasswords].read[fnpassword]>"
                                    }
                        - case "an":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set anpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&7>The AN Channel's password is now <yaml[channelpasswords].read[anpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == an {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set anpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&7>The AN Channel's password is now <yaml[channelpasswords].read[anpassword]>"
                                    }
                        - case "bht":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set bhtpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&4>The BhT Channel's password is now <yaml[channelpasswords].read[bhtpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == bht {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set bhtpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&4>The BhT Channel's password is now <yaml[channelpasswords].read[bhtpassword]>"
                                    }
                        - case "bhs":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set bhspassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&e>The BhS Channel's password is now <yaml[channelpasswords].read[bhspassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == bhs {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set bhspassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&e>The BhS Channel's password is now <yaml[channelpasswords].read[bhspassword]>"
                                    }
                        - case "fst":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set fstpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&a>The FST Channel's password is now <yaml[channelpasswords].read[fstpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == fst {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set fstpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&a>The FST Channel's password is now <yaml[channelpasswords].read[fstpassword]>"
                                    }
                        - case "sw":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.flag[rank]> != leader && !<player.is_op> {
                                        - narrate "<&c>You cannot change the channel's password because you are not a nation leader!"
                                        - queue clear
                                    }
                                    - if <player.is_op> {
                                        - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - yaml id:channelpasswords set swpassword:<context.args.get[3]>
                                        - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                        - narrate "<&6>The SW Channel's password is now <yaml[channelpasswords].read[swpassword]>"
                                        - queue clear
                                    }
                                    - if <player.flag[nation]> == sw {
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set swpassword:<context.args.get[2]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&6>The SW Channel's password is now <yaml[channelpasswords].read[swpassword]>"
                                    }
                        - case "tp":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.name> != TeamPalladian {
                                        - narrate "<&c>You are not TeamPalladian, therefore you cannot change the password!"
                                        - queue clear
                                    }
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set tppassword:<context.args.get[3]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&b>The TP Channel password has been set to <yaml[channelpasswords].read[tppassword]>"
                        - case "amaguq":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if <player.name> != Tornak {
                                        - narrate "<&c>You are not Tornak, so you can't change the Amaguq channel password."
                                        - queue clear
                                    }
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set amaguqpassword:<context.args.get[3]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&9>The Amaguq Channel password has been set to <yaml[channelpasswords].read[amaguqpassword]>"
                        - case "staff":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if !<player.is_op> {
                                        - narrate "<&c>Sorry, only OPs can change this channel's password!"
                                        - queue clear
                                    }
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set staffpassword:<context.args.get[3]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&3>The Staff Channel password has been set to <yaml[channelpasswords].read[staffpassword]>"
                        - case "builder":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if !<player.is_op> {
                                        - narrate "<&c>Sorry, only OPs can change this channel's password!"
                                        - queue clear
                                    }
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set builderpassword:<context.args.get[3]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&2>The Builder Channel password has been set to <yaml[channelpasswords].read[builderpassword]>"
                        - case "lc":
                            - choose "<context.args.get[3]>":
                                - case "<context.args.get[3]>":
                                    - if !<player.is_op> {
                                        - narrate "<&c>Sorry, only OPs can change this channel's password!"
                                        - queue clear
                                    }
                                    - yaml "load:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - yaml id:channelpasswords set lcpassword:<context.args.get[3]>
                                    - yaml "savefile:/channelpasswords/channelpasswords.yml" id:channelpasswords
                                    - narrate "<&5>The LC Channel password has been set to <yaml[channelpasswords].read[lcpassword]>"
        - case "g":
            - flag player channel:!
            - narrate "<&a>You are now chatting in <&b>Global"
        - case "w":
            - flag player channel:!
            - flag player channel:whisperchannel
            - inventory close d:in@channel_gui
            - narrate "<&a>You are now chatting in <&5>Whisper"
            - narrate "<&f><&l>Type /ch g to exit the channel and return to global."
        - case "gui":
            - inventory open d:in@channel_gui
        - default:
            - narrate "<&c>Unknown command! Use /channel help to list possible commands."