code.skript.pl - kod UKip8uYM

#       SSSSSSSSSSSSSSS                     iiii          tttt                                           AAA                  CCCCCCCCCCCCC
#     SS:::::::::::::::S                   i::::i      ttt:::t                                          A:::A              CCC::::::::::::C
#    S:::::SSSSSS::::::S                    iiii       t:::::t                                         A:::::A           CC:::::::::::::::C
#    S:::::S     SSSSSSS                               t:::::t                                        A:::::::A         C:::::CCCCCCCC::::C
#    S:::::S            uuuuuu    uuuuuu  iiiiiiittttttt:::::ttttttt        eeeeeeeeeeee             A:::::::::A       C:::::C       CCCCCC
#    S:::::S            u::::u    u::::u  i:::::it:::::::::::::::::t      ee::::::::::::ee          A:::::A:::::A     C:::::C              
#     S::::SSSS         u::::u    u::::u   i::::it:::::::::::::::::t     e::::::eeeee:::::ee       A:::::A A:::::A    C:::::C              
#      SS::::::SSSSS    u::::u    u::::u   i::::itttttt:::::::tttttt    e::::::e     e:::::e      A:::::A   A:::::A   C:::::C              
#        SSS::::::::SS  u::::u    u::::u   i::::i      t:::::t          e:::::::eeeee::::::e     A:::::A     A:::::A  C:::::C              
#           SSSSSS::::S u::::u    u::::u   i::::i      t:::::t          e:::::::::::::::::e     A:::::AAAAAAAAA:::::A C:::::C              
#                S:::::Su::::u    u::::u   i::::i      t:::::t          e::::::eeeeeeeeeee     A:::::::::::::::::::::AC:::::C              
#                S:::::Su:::::uuuu:::::u   i::::i      t:::::t    tttttte:::::::e             A:::::AAAAAAAAAAAAA:::::AC:::::C       CCCCCC
#    SSSSSSS     S:::::Su:::::::::::::::uui::::::i     t::::::tttt:::::te::::::::e           A:::::A             A:::::AC:::::CCCCCCCC::::C
#    S::::::SSSSSS:::::S u:::::::::::::::ui::::::i     tt::::::::::::::t e::::::::eeeeeeee  A:::::A               A:::::ACC:::::::::::::::C
#    S:::::::::::::::SS   uu::::::::uu:::ui::::::i       tt:::::::::::tt  ee:::::::::::::e A:::::A                 A:::::A CCC::::::::::::C
#     SSSSSSSSSSSSSSS       uuuuuuuu  uuuuiiiiiiii         ttttttttttt      eeeeeeeeeeeeeeAAAAAAA                   AAAAAAA   CCCCCCCCCCCCC

# ===    ╔═╗┬ ┬┌─┐┌┐┌┌─┐┌─┐┬  ┌─┐┌─┐   === #
# ===    ║  ├─┤├─┤││││ ┬├┤ │  │ ││ ┬   === #
# ===    ╚═╝┴ ┴┴ ┴┘└┘└─┘└─┘┴─┘└─┘└─┘   === #

#    ENG:                                            PL:
#
#    v1.0.2 BETA
#    + Removed a huge amount of event callbacks      + Usunieto ogromna ilosc wywolan zdarzen
#    + Fixed Move detection check                    + Naprawiono sprawdzanie detekcji Move
#    + Dodano wyjatek dla funkcji Move podczas       + Added exception for Move function
#    teleportacji (np. nether, komenda)              on teleport event (ex. nether, command)
#
#    v1.0.1 BETA
#    + Added new permissions                         + Dodano nowe uprawnienia
#    + More messages for misspelled commands         + Wiecej wiadomosci w przypadku blednych komend
#
#    v1.0 BETA
#    + Initial release                               + Pierwsze wydanie

# ===    ╔═╗┌─┐┌┐┌┌─┐┬┌─┐   === #
# ===    ║  │ ││││├┤ ││ ┬   === #
# ===    ╚═╝└─┘┘└┘└  ┴└─┘   === #

options:

# Generic:
    SuiteAC.Name: SuiteAC
    SuiteAC.Version: v1.0.2 BETA
    SuiteAC.Tag: &6&l[&f&oSAC&6&l]
    Notify.Toggle: true
    Notify.Delay: 3

# Custom:
    Break.Range.Value: 4.99
    Chat.Spam.Delay: 0.99
    Combat.Range.Value: 4.25
    Combat.Speed.Delay: 0.12
    Item.Bow.Delay: 0.22
    Item.Inventory.Delay: 0.05
    Item.Projectile.Delay: 0.12
    Move.DownY.Value: 17
    Move.UpY.Value: 1.26
    Move.Sneak.XZ.Value: 0.52
    Move.Standard.XZ.Value: 2.61
    Move.Standard.XZ.Hunger.Value: 1.19
    Move.Vehicle.Value: 2
    Place.Range.Value: 4.76
    Place.Speed.Delay: 0.12

# Detection:
    Break.Aim: true
    Break.Range: true
    Break.Speed: false
    Chat.Ad: true
    Chat.Spam: true
    Combat.Aim: true
    Combat.Knockback: true
    Combat.Range: true
    Combat.Speed: true
    Item.Bow: true
    Item.Inventory: true
    Item.Projectile: true
    Move.Sneak: true
    Move.Standard: true
    Move.Vehicle: true
    Place.Aim: true
    Place.Range: true
    Place.Speed: true

# VL Settings:
    Reduction.VL.Delay: 30

Break.Aim.Red: 3
    Break.Range.Red: 3
    Break.Speed.Red: 3
    Chat.Ad.Red: 3
    Chat.Spam.Red: 3
    Combat.Aim.Red: 3
    Combat.Knockback.Red: 3
    Combat.Range.Red: 3
    Combat.Speed.Red: 3
    Item.Bow.Red: 3
    Item.Inventory.Red: 3
    Item.Projectile.Red: 3
    Move.Sneak.Red: 3
    Move.Standard.Red: 3
    Move.Vehicle.Red: 3
    Place.Aim.Red: 3
    Place.Range.Red: 3
    Place.Speed.Red: 3

Break.Aim.Max: 20
    Break.Range.Max: 20
    Break.Speed.Max: 20
    Chat.Ad.Max: 20
    Chat.Spam.Max: 20
    Combat.Aim.Max: 20
    Combat.Knockback.Max: 20
    Combat.Range.Max: 20
    Combat.Speed.Max: 20
    Item.Bow.Max: 20
    Item.Inventory.Max: 20
    Item.Projectile.Max: 20
    Move.Sneak.Max: 20
    Move.Standard.Max: 20
    Move.Vehicle.Max: 20
    Place.Aim.Max: 20
    Place.Range.Max: 20
    Place.Speed.Max: 20

# ===    ╔═╗┌─┐┬─┐┌─┐   === #
# ===    ║  │ │├┬┘├┤    === #
# ===    ╚═╝└─┘┴└─└─┘   === #

command /sac [<text>] [<offline player>] [<text>] [<timespan>]:
    description: SuiteAC global command.
    permission: sac.command
    permission message: Unknown command. Type "/help" for help.
    executable by: players and console
    aliases: /suiteac
    trigger:
        send ""
        if arg 1 is "ad":
            if executor has permission "sac.ad":
                if arg 2 is "add":
                    if arg 3 is set:
                        add arg 3 to {ads::list::*}
                        broadcast "{@SuiteAC.Tag} &7Added &e%arg 3% &7to list of advertisements."
                        stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter a phrase." to executor
                        stop
                else if arg 2 is "remove":
                    if arg 3 is set:
                        remove arg 3 from {ads::list::*}
                        broadcast "{@SuiteAC.Tag} &7Removed &e%arg 3% &7from list of advertisements."
                        stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter the correct phrase." to executor
                        stop
                else if arg 2 is "list":
                    send "{@SuiteAC.Tag} &7List of advertisements:" to executor
                    send "{@SuiteAC.Tag} &f%{ads::list::*}%:" to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
        if arg 1 is "avoid":
            if executor has permission "sac.avoid":
                if arg 2 is set:
                    if arg 3 is set:
                        set {%arg 3%.avoid.%arg 2%} to true
                        send "{@SuiteAC.Tag} &7Enabled &f%arg 3% &7avoidance for &e%arg 2%&7." to executor
                        stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter a mod name (ex. &6break.aim&7)." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "unavoid":
            if executor has permission "sac.unavoid":
                if arg 2 is set:
                    if arg 3 is set:
                        set {%arg 3%.avoid.%arg 2%} to false
                        send "{@SuiteAC.Tag} &7Disabled &f%arg 3% &7avoidance for &e%arg 2%&7." to executor
                        stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter a mod name (ex. &6break.aim&7)." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "ban":
            if executor has permission "sac.ban":
                if arg 2 is set:
                    if arg 3 is set:
                        if arg 4 is set:
                            set {banned.%arg 2%} to true
                            set {bantimer.%arg 2%} to arg 4
                            set {tempban.%arg 2%} to now
                            set {banreason.%arg 2%} to arg 3
                            add arg 2 to {banned::list::*}
                            kick the arg 2 due to "{@SuiteAC.Tag} &7Temporary banned for &6%{banreason.%arg 2%}%&7."
                            broadcast "{@SuiteAC.Tag} &e%arg 2% &7has been banned due to &6%arg 3% &7for %arg 4%."
                            stop
                        else:
                            set {banned.%arg 2%} to true
                            set {banreason.%arg 2%} to arg 3
                            add arg 2 to {banned::list::*}
                            kick the arg 2 due to "{@SuiteAC.Tag} &7Banned for &6%{banreason.%arg 2%}%&7."
                            broadcast "{@SuiteAC.Tag} &e%arg 2% &7has been banned due to &6%arg 3%&7."
                            stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter the ban reason." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "banip":
            if executor has permission "sac.banip":
                if arg 2 is set:
                    if arg 3 is set:
                        set {banreason.%arg 2%} to arg 3
                        add arg 2 to {bannedip::list::*}
                        ban "arg 2" because "{@SuiteAC.Tag} &7%arg 3%"
                        broadcast "{@SuiteAC.Tag} &7IP &e%arg 2% &7has been banned due to &6%arg 3%&7."
                        stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter the ban reason." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct IP address." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "banlist":
            if executor has permission "sac.banlist":
                send "{@SuiteAC.Tag} &7Banned players:" to executor
                loop {banned::list::*}:
                    if {banned.%loop-value%} is true:
                        send "{@SuiteAC.Tag} &f%loop-value%  &6[&7&o%{banreason.%loop-value%}%&6]" to executor
                send "{@SuiteAC.Tag} &7Banned IPs:" to executor
                loop {bannedip::list::*}:
                    send "{@SuiteAC.Tag} &f%loop-value%  &6[&7&o%{banreason.%loop-value%}%&6]" to executor
                stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "unban":
            if executor has permission "sac.unban":
                if arg 2 is set:
                    if {banned.%arg 2%} is true:
                        remove arg 2 from {banned::list::*}
                        set {banned.%arg 2%} to false
                        set {bantimer.%arg 2%} to now
                        clear {bantimer.%arg 2%}
                        clear {banreason.%arg 2%}
                        broadcast "{@SuiteAC.Tag} &e%arg 2% &7has been unbanned."
                        stop
                    else:
                        send "{@SuiteAC.Tag} &e%arg 2% &7is not banned on this server." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "unbanip":
            if executor has permission "sac.unbanip":
                if arg 2 is set:
                    remove arg 2 from {bannedip::list::*}
                    unban "arg 2"
                    broadcast "{@SuiteAC.Tag} &7IP &e%arg 2% &7has been unbanned."
                    stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct IP address." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "check":
            if executor has permission "sac.check":
                if arg 2 is set:
                    send "{@SuiteAC.Tag} &7Player: &e%arg 2%" to executor
                    if {@Break.Aim} is true:
                        if {break.aim.%arg 2%} is smaller than {@Break.Aim.Max}:
                            send "{@SuiteAC.Tag} &7Break.Aim &6[&f%{break.aim.%arg 2%}%/{@Break.Aim.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Break.Aim &6[&f%{break.aim.%arg 2%}%/{@Break.Aim.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Break.Range} is true:
                        if {break.range.%arg 2%} is smaller than {@Break.Range.Max}:
                            send "{@SuiteAC.Tag} &7Break.Range &6[&f%{break.range.%arg 2%}%/{@Break.Range.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Break.Range &6[&f%{break.range.%arg 2%}%/{@Break.Range.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Break.Speed} is true:
                        if {break.speed.%arg 2%} is smaller than {@Break.Speed.Max}:
                            send "{@SuiteAC.Tag} &7Break.Speed &6[&f%{break.speed.%arg 2%}%/{@Break.Speed.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Break.Speed &6[&f%{break.speed.%arg 2%}%/{@Break.Speed.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Chat.Ad} is true:
                        if {chat.ad.%arg 2%} is smaller than {@Chat.Ad.Max}:
                            send "{@SuiteAC.Tag} &7Chat.Ad &6[&f%{chat.ad.%arg 2%}%/{@Chat.Ad.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Chat.Ad &6[&f%{chat.ad.%arg 2%}%/{@Chat.Ad.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Chat.Spam} is true:
                        if {chat.spam.%arg 2%} is smaller than {@Chat.Spam.Max}:
                            send "{@SuiteAC.Tag} &7Chat.Spam &6[&f%{chat.spam.%arg 2%}%/{@Chat.Spam.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Chat.Spam &6[&f%{chat.spam.%arg 2%}%/{@Chat.Spam.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Combat.Aim} is true:
                        if {combat.aim.%arg 2%} is smaller than {@Combat.Aim.Max}:
                            send "{@SuiteAC.Tag} &7Combat.Aim &6[&f%{combat.aim.%arg 2%}%/{@Combat.Aim.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Combat.Aim &6[&f%{combat.aim.%arg 2%}%/{@Combat.Aim.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Combat.Knockback} is true:
                        if {combat.knockback.%arg 2%} is smaller than {@Combat.Knockback.Max}:
                            send "{@SuiteAC.Tag} &7Combat.Knockback &6[&f%{combat.knockback.%arg 2%}%/{@Combat.Knockback.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Combat.Knockback &6[&f%{combat.knockback.%arg 2%}%/{@Combat.Knockback.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Combat.Range} is true:
                        if {combat.range.%arg 2%} is smaller than {@Combat.Range.Max}:
                            send "{@SuiteAC.Tag} &7Combat.Range &6[&f%{combat.range.%arg 2%}%/{@Combat.Range.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Combat.Range &6[&f%{combat.range.%arg 2%}%/{@Combat.Range.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Combat.Speed} is true:
                        if {combat.speed.%arg 2%} is smaller than {@Combat.Speed.Max}:
                            send "{@SuiteAC.Tag} &7Combat.Speed &6[&f%{combat.speed.%arg 2%}%/{@Combat.Speed.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Combat.Speed &6[&f%{combat.speed.%arg 2%}%/{@Combat.Speed.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Item.Bow} is true:
                        if {item.bow.%arg 2%} is smaller than {@Item.Bow.Max}:
                            send "{@SuiteAC.Tag} &7Item.Bow &6[&f%{item.bow.%arg 2%}%/{@Item.Bow.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Item.Bow &6[&f%{item.bow.%arg 2%}%/{@Item.Bow.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Item.Inventory} is true:
                        if {item.inventory.%arg 2%} is smaller than {@Item.Inventory.Max}:
                            send "{@SuiteAC.Tag} &7Item.Inventory &6[&f%{item.inventory.%arg 2%}%/{@Item.Inventory.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Item.Inventory &6[&f%{item.inventory.%arg 2%}%/{@Item.Inventory.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Item.Projectile} is true:
                        if {item.projectile.%arg 2%} is smaller than {@Item.Projectile.Max}:
                            send "{@SuiteAC.Tag} &7Item.Projectile &6[&f%{item.projectile.%arg 2%}%/{@Item.Projectile.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Item.Projectile &6[&f%{item.projectile.%arg 2%}%/{@Item.Projectile.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Move.Sneak} is true:
                        if {move.sneak.%arg 2%} is smaller than {@Move.Sneak.Max}:
                            send "{@SuiteAC.Tag} &7Move.Sneak &6[&f%{move.sneak.%arg 2%}%/{@Move.Sneak.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Move.Sneak &6[&f%{move.sneak.%arg 2%}%/{@Move.Sneak.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Move.Standard} is true:
                        if {move.standard.%arg 2%} is smaller than {@Move.Standard.Max}:
                            send "{@SuiteAC.Tag} &7Move.Standard &6[&f%{move.standard.%arg 2%}%/{@Move.Standard.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Move.Standard &6[&f%{move.standard.%arg 2%}%/{@Move.Standard.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Move.Vehicle} is true:
                        if {move.vehicle.%arg 2%} is smaller than {@Move.Vehicle.Max}:
                            send "{@SuiteAC.Tag} &7Move.Vehicle &6[&f%{move.vehicle.%arg 2%}%/{@Move.Vehicle.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Move.Vehicle &6[&f%{move.vehicle.%arg 2%}%/{@Move.Vehicle.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Place.Aim} is true:
                        if {place.aim.%arg 2%} is smaller than {@Place.Aim.Max}:
                            send "{@SuiteAC.Tag} &7Place.Aim &6[&f%{place.aim.%arg 2%}%/{@Place.Aim.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Place.Aim &6[&f%{place.aim.%arg 2%}%/{@Place.Aim.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Place.Range} is true:
                        if {place.range.%arg 2%} is smaller than {@Place.Range.Max}:
                            send "{@SuiteAC.Tag} &7Place.Range &6[&f%{place.range.%arg 2%}%/{@Place.Range.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Place.Range &6[&f%{place.range.%arg 2%}%/{@Place.Range.Max}&6] &8[&c&l✘&8]" to executor
                    if {@Place.Speed} is true:
                        if {place.speed.%arg 2%} is smaller than {@Place.Speed.Max}:
                            send "{@SuiteAC.Tag} &7Place.Speed &6[&f%{place.speed.%arg 2%}%/{@Place.Speed.Max}&6] &8[&a&l✔&8]" to executor
                        else:
                            send "{@SuiteAC.Tag} &7Place.Speed &6[&f%{place.speed.%arg 2%}%/{@Place.Speed.Max}&6] &8[&c&l✘&8]" to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "clear":
            if executor has permission "sac.clear":
                if arg 2 is set:
                    ClearVLs(arg 2)
                    send "{@SuiteAC.Tag} &7Successfully cleared violations for &e%arg 2%&7." to executor
                    stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "kick":
            if executor has permission "sac.kick":
                if arg 2 is set:
                    if arg 3 is set:
                        kick the arg 2 due to "{@SuiteAC.Tag} &7Kicked for &6%arg 3%&7."
                        broadcast "{@SuiteAC.Tag} &e%arg 2% &7has been kicked due to &6%arg 3%&7."
                        stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter the kick reason." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "mute":
            if executor has permission "sac.mute":
                if arg 2 is set:
                    if arg 3 is set:
                        if arg 4 is set:
                            set {muted.%arg 2%} to true
                            set {mutetimer.%arg 2%} to arg 4
                            set {tempmute.%arg 2%} to now
                            set {mutereason.%arg 2%} to arg 3
                            add arg 2 to {muted::list::*}
                            send "{@SuiteAC.Tag} &e%arg 2% &7has been temporary muted for &6%arg 3%&7." to executor
                            send "{@SuiteAC.Tag} &7You have been muted due to &6%arg 3% &7for %arg 4%." to arg 2
                            stop
                        else:
                            set {muted.%arg 2%} to true
                            set {mutereason.%arg 2%} to arg 3
                            add arg 2 to {muted::list::*}
                            send "{@SuiteAC.Tag} &e%arg 2% &7has been muted for &6%arg 3%&7." to executor
                            send "{@SuiteAC.Tag} &7You have been muted due to &6%arg 3%&7." to arg 2
                            stop
                    else:
                        send "{@SuiteAC.Tag} &7Please enter the mute reason." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "mutelist":
            if executor has permission "sac.mutelist":
                send "{@SuiteAC.Tag} &7Muted players:" to executor
                loop {muted::list::*}:
                    if {muted.%loop-value%} is true:
                        send "{@SuiteAC.Tag} &f%loop-value%  &6[&7&o%{mutereason.%loop-value%}%&6]" to executor
                stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "unmute":
            if executor has permission "sac.unmute":
                if arg 2 is set:
                    if {muted.%arg 2%} is true:
                        remove arg 2 from {muted::list::*}
                        set {muted.%arg 2%} to false
                        set {mutetimer.%arg 2%} to now
                        clear {mutetimer.%arg 2%}
                        clear {mutereason.%arg 2%}
                        broadcast "{@SuiteAC.Tag} &e%arg 2% &7has been unmuted."
                        stop
                    else:
                        send "{@SuiteAC.Tag} &e%arg 2% &7is not muted on this server." to executor
                        stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        if arg 1 is "whois":
            if executor has permission "sac.whois":
                if arg 2 is set:
                    send "{@SuiteAC.Tag} &7Player: &e%arg 2%" to executor
                    send "{@SuiteAC.Tag} &7UUID: &f%arg 2's UUID%" to executor
                    send "{@SuiteAC.Tag} &7First-Join IP: &f%{firstip.%arg 2%}%" to executor
                    send "{@SuiteAC.Tag} &7Actual IP: &f%{actualip.%arg 2%}%" to executor
                    if player is online:
                        send "{@SuiteAC.Tag} &7Online: &atrue" to executor
                    else:
                        send "{@SuiteAC.Tag} &7Online: &cfalse" to executor
                    if {banned.%arg 2%} is true:
                        send "{@SuiteAC.Tag} &7Banned: &ctrue  &6[&7&o%{banreason.%arg 2%}%&6]" to executor
                    else:
                        send "{@SuiteAC.Tag} &7Banned: &afalse" to executor
                    if {muted.%arg 2%} is true:
                        send "{@SuiteAC.Tag} &7Muted: &ctrue  &6[&7&o%{mutereason.%arg 2%}%&6]" to executor
                    else:
                        send "{@SuiteAC.Tag} &7Muted: &afalse" to executor
                    stop
                else:
                    send "{@SuiteAC.Tag} &7Please enter a correct player name." to executor
                    stop
            else:
                send "{@SuiteAC.Tag} &7No permission to use that command." to executor
                stop
        else:
            send "{@SuiteAC.Tag} &f&o{@SuiteAC.Name} {@SuiteAC.Version}"
            send "{@SuiteAC.Tag} &7&oDeveloper: &e&oArk223"
            send "{@SuiteAC.Tag} &7&oContact: &e&oArk223Neww@gmail.com"
            send "{@SuiteAC.Tag} &7&oCommand list:"
            send "{@SuiteAC.Tag} &7&o/sac ad add/remove/list <text>"
            send "{@SuiteAC.Tag} &7&o/sac avoid <player> <mod>"
            send "{@SuiteAC.Tag} &7&o/sac unavoid <player> <mod>"
            send "{@SuiteAC.Tag} &7&o/sac ban <player> <reason> <time>"
            send "{@SuiteAC.Tag} &7&o/sac banip <ip> <reason>"
            send "{@SuiteAC.Tag} &7&o/sac banlist <data>"
            send "{@SuiteAC.Tag} &7&o/sac unban <player>"
            send "{@SuiteAC.Tag} &7&o/sac unbanip <ip>"
            send "{@SuiteAC.Tag} &7&o/sac check <player>"
            send "{@SuiteAC.Tag} &7&o/sac clear <player>"
            send "{@SuiteAC.Tag} &7&o/sac kick <player> <reason>"
            send "{@SuiteAC.Tag} &7&o/sac mute <player> <reason> <time>"
            send "{@SuiteAC.Tag} &7&o/sac mutelist <data>"
            send "{@SuiteAC.Tag} &7&o/sac unmute <player>"
            send "{@SuiteAC.Tag} &7&o/sac whois <player>"
            stop

function ClearVLs(p: player):
    set {break.aim.%{_p}%} to 0
    set {break.range.%{_p}%} to 0
    set {break.speed.%{_p}%} to 0
    set {chat.ad.%{_p}%} to 0
    set {chat.spam.%{_p}%} to 0
    set {combat.aim.%{_p}%} to 0
    set {combat.knockback.%{_p}%} to 0
    set {combat.range.%{_p}%} to 0
    set {combat.speed.%{_p}%} to 0
    set {item.bow.%{_p}%} to 0
    set {item.inventory.%{_p}%} to 0
    set {item.projectile.%{_p}%} to 0
    set {move.sneak.%{_p}%} to 0
    set {move.standard.%{_p}%} to 0
    set {move.vehicle.%{_p}%} to 0
    set {place.aim.%{_p}%} to 0
    set {place.range.%{_p}%} to 0
    set {place.speed.%{_p}%} to 0

function ClearAvoids(p: player):
    set {break.aim.avoid.%{_p}%} to false
    set {break.range.avoid.%{_p}%} to false
    set {break.speed.avoid.%{_p}%} to false
    set {chat.ad.avoid.%{_p}%} to false
    set {chat.spam.avoid.%{_p}%} to false
    set {combat.aim.avoid.%{_p}%} to false
    set {combat.knockback.avoid.%{_p}%} to false
    set {combat.range.avoid.%{_p}%} to false
    set {combat.speed.avoid.%{_p}%} to false
    set {item.bow.avoid.%{_p}%} to false
    set {item.inventory.avoid.%{_p}%} to false
    set {item.projectile.avoid.%{_p}%} to false
    set {move.sneak.avoid.%{_p}%} to false
    set {move.standard.avoid.%{_p}%} to false
    set {move.vehicle.avoid.%{_p}%} to false
    set {place.aim.avoid.%{_p}%} to false
    set {place.range.avoid.%{_p}%} to false
    set {place.speed.avoid.%{_p}%} to false

function ReduceVLs(p: player):
    if {break.aim.%{_p}%} is more than or equal to {@Break.Aim.Red}:
        subtract {@Break.Aim.Red} from {break.aim.%{_p}%}
    if {break.range.%{_p}%} is more than or equal to {@Break.Range.Red}:
        subtract {@Break.Range.Red} from {break.range.%{_p}%}
    if {break.speed.%{_p}%} is more than or equal to {@Break.Speed.Red}:
        subtract {@Break.Speed.Red} from {break.speed.%{_p}%}
    if {chat.ad.%{_p}%} is more than or equal to {@Chat.Ad.Red}:
        subtract {@Chat.Ad.Red} from {chat.ad.%{_p}%}
    if {chat.spam.%{_p}%} is more than or equal to {@Chat.Spam.Red}:
        subtract {@Chat.Spam.Red} from {chat.spam.%{_p}%}
    if {combat.aim.%{_p}%} is more than or equal to {@Combat.Aim.Red}:
        subtract {@Combat.Aim.Red} from {combat.aim.%{_p}%}
    if {combat.knockback.%{_p}%} is more than or equal to {@Combat.Knockback.Red}:
        subtract {@Combat.Knockback.Red} from {combat.knockback.%{_p}%}
    if {combat.range.%{_p}%} is more than or equal to {@Combat.Range.Red}:
        subtract {@Combat.Range.Red} from {combat.range.%{_p}%}
    if {combat.speed.%{_p}%} is more than or equal to {@Combat.Speed.Red}:
        subtract {@Combat.Speed.Red} from {combat.speed.%{_p}%}
    if {item.bow.%{_p}%} is more than or equal to {@Item.Bow.Red}:
        subtract {@Item.Bow.Red} from {item.bow.%{_p}%}
    if {item.inventory.%{_p}%} is more than or equal to {@Item.Inventory.Red}:
        subtract {@Item.Inventory.Red} from {item.inventory.%{_p}%}
    if {item.projectile.%{_p}%} is more than or equal to {@Item.Projectile.Red}:
        subtract {@Item.Projectile.Red} from {item.projectile.%{_p}%}
    if {move.sneak.%{_p}%} is more than or equal to {@Move.Sneak.Red}:
        subtract {@Move.Sneak.Red} from {move.sneak.%{_p}%}
    if {move.standard.%{_p}%} is more than or equal to {@Move.Standard.Red}:
        subtract {@Move.Standard.Red} from {move.standard.%{_p}%}
    if {move.vehicle.%{_p}%} is more than or equal to {@Move.Vehicle.Red}:
        subtract {@Move.Vehicle.Red} from {move.vehicle.%{_p}%}
    if {place.aim.%{_p}%} is more than or equal to {@Place.Aim.Red}:
        subtract {@Place.Aim.Red} from {place.aim.%{_p}%}
    if {place.range.%{_p}%} is more than or equal to {@Place.Range.Red}:
        subtract {@Place.Range.Red} from {place.range.%{_p}%}
    if {place.speed.%{_p}%} is more than or equal to {@Place.Speed.Red}:
        subtract {@Place.Speed.Red} from {place.speed.%{_p}%}

function SetXYZ1(p: player):
    set {loc.x1.%{_p}%} to x-coordinate of {_p}
    set {loc.y1.%{_p}%} to y-coordinate of {_p}
    set {loc.z1.%{_p}%} to z-coordinate of {_p}

function SetXYZ2(p: player):
    set {loc.x2.%{_p}%} to x-coordinate of {_p}
    set {loc.y2.%{_p}%} to y-coordinate of {_p}
    set {loc.z2.%{_p}%} to z-coordinate of {_p}

on script load:
    loop all entities:
        set {_name} to 99
        loop 900 times:
            set {_name} to ({_name}+1)
            if name of loop-entity is "%{_name}%":
                hide loop-entity to all players
                kill loop-entity
    if {@Notify.Toggle} is true:
        set {notify} to true
    if {ads::list::*} is not set:
        add "csrv" to {ads::list::*}
        add "fhmc" to {ads::list::*}
        add "fsrv" to {ads::list::*}
        add "hostmc" to {ads::list::*}
        add "srvmc" to {ads::list::*}
        add "www" to {ads::list::*}
        add ".com" to {ads::list::*}
        add ".craft" to {ads::list::*}
        add ".de" to {ads::list::*}
        add ".ench" to {ads::list::*}
        add ".eu" to {ads::list::*}
        add ".mc" to {ads::list::*}
        add ".net" to {ads::list::*}
        add ".pl" to {ads::list::*}
        add ".ru" to {ads::list::*}

on join:
    wait tick
    SetXYZ1(player)
    SetXYZ2(player)
    if {vls.%player%} is not set:
        set {firstip.%player%} to player's IP
        ClearVLs(player)
        set {vls.%player%} to true
    if {vls.%player%} is true:
        set {actualip.%player%} to player's IP
        set {blockmining.%player%} to false
        set {blockplace.%player%} to false
        set {bowshoot.%player%} to false
        set {citizen.%player%} to false
        set {itemclick.%player%} to false
        set {projshoot.%player%} to false
        ClearAvoids(player)

every {@Reduction.VL.Delay} seconds:
    loop players:
        if {vls.%loop-player%} is true:
            ReduceVLs(loop-player)

on connect:
    if {bantimer.%player%} is set:
        set {_tempban} to difference between now and {tempban.%player%}
        reduce {_tempban} by {bantimer.%player%}
        if difference between now and {tempban.%player%} is bigger than {bantimer.%player%}:
            set {banned.%player%} to false
            clear {tempban.%player%}
            clear {bantimer.%player%}
            remove player from {banned::list::*}
        if difference between now and {tempban.%player%} is smaller than {bantimer.%player%}:
            set {_timecomplete} to {tempban.%player%}
            add {bantimer.%player%} to {_timecomplete}
            set {_expire} to difference between now and {_timecomplete}
            wait tick
            kick the player due to "{@SuiteAC.Tag} &7Temporary banned for &6%{banreason.%player%}%&7. Expires in %{_expire}%."
    else if {banned.%player%} is true:
        wait tick
        kick the player due to "{@SuiteAC.Tag} &7Banned for &6%{banreason.%player%}%&7."

on chat:
    if {mutetimer.%player%} is set:
        set {_tempmute} to difference between now and {tempmute.%player%}
        reduce {_tempmute} by {mutetimer.%player%}
        if difference between now and {tempmute.%player%} is bigger than {mutetimer.%player%}:
            set {muted.%player%} to false
            clear {tempmute.%player%}
            clear {mutetimer.%player%}
            remove player from {muted::list::*}
        if difference between now and {tempmute.%player%} is smaller than {mutetimer.%player%}:
            cancel event
            set {_timecompleted} to {tempmute.%player%}
            add {mutetimer.%player%} to {_timecompleted}
            set {_expired} to difference between now and {_timecompleted}
            send "{@SuiteAC.Tag} &7You are muted for &6%{mutereason.%player%}%&7. Expires in %{_expired}%."
    else if {muted.%player%} is true:
        cancel event
        send "{@SuiteAC.Tag} &7You are muted for &6%{mutereason.%player%}%&7."

# ------------- #
# --- Break --- #

on break:
    if {@Break.Aim} is true:
        if {break.aim.avoid.%player%} is false:
            if player's gamemode is survival or adventure:
                if event-block is not grass or snow layer or torch:
                    if targeted block is not water or lava:
                        if location of event-block is not location of targeted block:
                            cancel event
                            add 1 to {break.aim.%player%}
                            if {@Notify.Toggle} is true:
                                if {notify} is true:
                                    loop players:
                                        if loop-player has permission "sac.notify":
                                            send "{@SuiteAC.Tag} &e%player% &7failed Break.Aim &6[&fVL %{break.aim.%player%}%&6]" to loop-player
                                            send "{@SuiteAC.Tag} &7Tried to break untargeted block." to loop-player
                                    set {notify} to false
                                    wait {@Notify.Delay} seconds
                                    set {notify} to true
    if {@Break.Range} is true:
        if {break.range.avoid.%player%} is false:
            if player's gamemode is survival or adventure:
                if distance between player and event-block is more than {@Break.Range.Value}:
                    cancel event
                    add 1 to {break.range.%player%}
                    if {@Notify.Toggle} is true:
                        if {notify} is true:
                            loop players:
                                if loop-player has permission "sac.notify":
                                    send "{@SuiteAC.Tag} &e%player% &7failed Break.Range &6[&fVL %{break.range.%player%}%&6]" to loop-player
                                    send "{@SuiteAC.Tag} &7Tried to break block at higher range than {@Break.Range.Value} blocks." to loop-player
                            set {notify} to false
                            wait {@Notify.Delay} seconds
                            set {notify} to true
    if {@Break.Speed} is true:
        if {break.speed.avoid.%player%} is false:
            if {blockmining.%player%} is true:
                cancel event
                add 1 to {break.speed.%player%}
                if {@Notify.Toggle} is true:
                    if {notify} is true:
                        loop players:
                            if loop-player has permission "sac.notify":
                                send "{@SuiteAC.Tag} &e%player% &7failed Break.Speed &6[&fVL %{break.speed.%player%}%&6]" to loop-player
                                send "{@SuiteAC.Tag} &7Tried to break block much faster than possible." to loop-player
                        set {notify} to false
                        wait {@Notify.Delay} seconds
                        set {notify} to true

on block damage:
    if {blockmining.%player%} is false:
        if player's tool is wooden pickaxe:
            if event-block is netherrack:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.2 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.2 real seconds
                set {blockmining.%player%} to false
            else if event-block is ice or packed ice or magma block:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.3 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.3 real seconds
                set {blockmining.%player%} to false
            else if event-block is sandstone or red sandstone:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.55 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.55 real seconds
                set {blockmining.%player%} to false
            else if event-block is stone or stone brick or prismarine or prismarine bricks or granite or diorite or dark prismarine or andesite:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (1 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 1 real seconds
                set {blockmining.%player%} to false
            else if event-block is nether brick block or red nether brick or moss cobble stone or cobble stone or brick block:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (1.15 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 1.15 real seconds
                set {blockmining.%player%} to false
            else if event-block is nether quartz ore or end stone or coal ore:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (1.75 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 1.75 real seconds
                set {blockmining.%player%} to false
        else if player's tool is stone pickaxe:
            if event-block is netherrack:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.07 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.07 real seconds
                set {blockmining.%player%} to false
            else if event-block is ice or packed ice or magma block:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.14 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.14 real seconds
                set {blockmining.%player%} to false
            else if event-block is sandstone or red sandstone:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.25 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.25 real seconds
                set {blockmining.%player%} to false
            else if event-block is stone or stone brick or prismarine or prismarine bricks or granite or diorite or dark prismarine or andesite:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.55 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.55 real seconds
                set {blockmining.%player%} to false
            else if event-block is nether brick block or red nether brick or moss cobble stone or cobble stone or brick block:
                set {blockmining.%player%} to true
                if player's tool is enchanted with efficiency:
                    set {_enchant} to level of efficiency of the tool
                    set {_waittime} to (0.6 * (1 - 0.4 * {_enchant}))
                    if {_waittime} is more than 0:
                        set {_score} to ("%{_waittime}% real seconds") parsed as timespan
                        wait {_score}
                    else:
                        set {blockmining.%player%} to false
                else:
                    wait 0.6 real seconds
                set {blockmining.%player%} to false
        else:
            if event-block is netherrack:
                set {blockmining.%player%} to true
                wait 1.85 real seconds
                set {blockmining.%player%} to false
            else if event-block is soul sand or sand or piston or packed ice or ice or wheat block or dirt or coarse dirt:
                set {blockmining.%player%} to true
                wait 0.7 real seconds
                set {blockmining.%player%} to false
            else if event-block is magma block:
                set {blockmining.%player%} to true
                wait 2.45 real seconds
                set {blockmining.%player%} to false
            else if event-block is wet sponge or sponge or mycelium or gravel or grass block or clay:
                set {blockmining.%player%} to true
                wait 0.75 real seconds
                set {blockmining.%player%} to false
            else if event-block is wool or note block:
                set {blockmining.%player%} to true
                wait 1.15 real seconds
                set {blockmining.%player%} to false
            else if event-block is sign or pumpkin or nether wart block or melon or jack o lantern:
                set {blockmining.%player%} to true
                wait 1.45 real seconds
                set {blockmining.%player%} to false

# -------------- #
# ---- Chat ---- #

on chat:
    if {@Chat.Ad} is true:
        if {chat.ad.avoid.%player%} is false:
            loop {ads::list::*}:
                if message contains loop-value:
                    set {_msg} to the message
                    set message to {_msg} hashed with MD5
                    add 1 to {chat.ad.%player%}
                    if {@Notify.Toggle} is true:
                        if {notify} is true:
                            loop players:
                                if loop-player has permission "sac.notify":
                                    send "{@SuiteAC.Tag} &e%player% &7failed Chat.Ad &6[&fVL %{chat.ad.%player%}%&6]" to loop-player
                                    send "{@SuiteAC.Tag} &7Tried to advertise a server or website." to loop-player
                            set {notify} to false
                            wait {@Notify.Delay} seconds
                            set {notify} to true
                            stop
    if {@Chat.Spam} is true:
        if {chat.spam.avoid.%player%} is false:
            if {spam.%player%} is not set:
                set {spam.%player%} to false
            if {spam.%player%} is true:
                cancel event
                send "{@SuiteAC.Tag} &7Please wait before sending next message." to player
                add 1 to {chat.spam.%player%}
                if {@Notify.Toggle} is true:
                    if {notify} is true:
                        loop players:
                            if loop-player has permission "sac.notify":
                                send "{@SuiteAC.Tag} &e%player% &7failed Chat.Spam &6[&fVL %{chat.spam.%player%}%&6]" to loop-player
                                send "{@SuiteAC.Tag} &7Tried to send next message too quickly." to loop-player
                        set {notify} to false
                        wait {@Notify.Delay} seconds
                        set {notify} to true
                        stop
            if {spam.%player%} is false:
                set {spam.%player%} to true
                wait {@Chat.Spam.Delay} seconds
                set {spam.%player%} to false

on command:
    if executor is player:
        if {@Chat.Spam} is true:
            if {chat.spam.avoid.%player%} is false:
                if {spam.%player%} is not set:
                    set {spam.%player%} to false
                if {spam.%player%} is true:
                    cancel event
                    send "{@SuiteAC.Tag} &7Please wait before executing next command." to player
                    add 1 to {chat.spam.%player%}
                    if {@Notify.Toggle} is true:
                        if {notify} is true:
                            loop players:
                                if loop-player has permission "sac.notify":
                                    send "{@SuiteAC.Tag} &e%player% &7failed Chat.Spam &6[&fVL %{chat.spam.%player%}%&6]" to loop-player
                                    send "{@SuiteAC.Tag} &7Tried to execute next command too quickly." to loop-player
                            set {notify} to false
                            wait {@Notify.Delay} seconds
                            set {notify} to true
                            stop
                if {spam.%player%} is false:
                    set {spam.%player%} to true
                    wait {@Chat.Spam.Delay} seconds
                    set {spam.%player%} to false

# -------------- #
# --- Combat --- #

on damage:
    if damage cause is attack:
        if victim is living entity:
            if {@Combat.Aim} is true:
                if {combat.aim.avoid.%attacker%} is false:
                    if {citizen.%attacker%} is false:
                        set {citizen.%attacker%} to true
                        set {citizenname.%attacker%} to random integer between 100 and 999
                        set {_pos} to position of block 2 meters above attacker's head
                        create a citizen named "%{citizenname.%attacker%}%" at {_pos}
                        wait 0.35 seconds
                        loop all entities:
                            loop 1 times:
                                if name of loop-entity is "%{citizenname.%attacker%}%":
                                    hide loop-entity to all players
                                    kill loop-entity
                        set {citizen.%attacker%} to false
                        stop
            if {@Combat.Speed} is true:
                if {combat.speed.avoid.%attacker%} is false:
                    if {combatd.%attacker%} is not set:
                        set {combatd.%attacker%} to false
                    if {combatd.%attacker%} is true:
                        cancel event
                        add 1 to {combat.speed.%attacker%}
                        if {@Notify.Toggle} is true:
                            if {notify} is true:
                                loop players:
                                    if loop-player has permission "sac.notify":
                                        send "{@SuiteAC.Tag} &e%attacker% &7failed Combat.Speed &6[&fVL %{combat.speed.%attacker%}%&6]" to loop-player
                                        send "{@SuiteAC.Tag} &7Tried to attack entity at higher frequency." to loop-player
                                set {notify} to false
                                wait {@Notify.Delay} seconds
                                set {notify} to true
                                stop
                    if {combatd.%attacker%} is false:
                        set {combatd.%attacker%} to true
                        wait {@Combat.Speed.Delay} seconds
                        set {combatd.%attacker%} to false
                        stop
            if {@Combat.Range} is true:
                if {combat.range.avoid.%attacker%} is false:
                    if distance between attacker and victim is more than {@Combat.Range.Value}:
                        cancel event
                        add 1 to {combat.range.%attacker%}
                        if {@Notify.Toggle} is true:
                            if {notify} is true:
                                loop players:
                                    if loop-player has permission "sac.notify":
                                        send "{@SuiteAC.Tag} &e%attacker% &7failed Combat.Range &6[&fVL %{combat.range.%attacker%}%&6]" to loop-player
                                        send "{@SuiteAC.Tag} &7Tried to attack entity at higher range than {@Combat.Range.Value} blocks." to loop-player
                                set {notify} to false
                                wait {@Notify.Delay} seconds
                                set {notify} to true
                                stop
    if damage cause is attack or projectile:
        if victim is player:
            if {@Combat.Knockback} is true:
                if {combat.knockback.avoid.%victim%} is false:
                    set {loc1.%victim%} to location of victim
                    wait 10 ticks
                    set {loc2.%victim%} to location of victim
                    if distance between {loc1.%victim%} and {loc2.%victim%} = 0:
                        add 1 to {combat.knockback.%victim%}
                        if {@Notify.Toggle} is true:
                            if {notify} is true:
                                loop players:
                                    if loop-player has permission "sac.notify":
                                        send "{@SuiteAC.Tag} &e%victim% &7failed Combat.Knockback &6[&fVL %{combat.knockback.%victim%}%&6]" to loop-player
                                        send "{@SuiteAC.Tag} &7Tried to avoid knockback while getting damage." to loop-player
                                set {notify} to false
                                wait {@Notify.Delay} seconds
                                set {notify} to true
                                stop

on leftclick:
    if {citizen.%player%} is true:
        if name of targeted entity is "%{citizenname.%player%}%":
            cancel event
            add 1 to {combat.aim.%player%}
            if {@Notify.Toggle} is true:
                if {notify} is true:
                    loop players:
                        if loop-player has permission "sac.notify":
                            send "{@SuiteAC.Tag} &e%player% &7failed Combat.Aim &6[&fVL %{combat.aim.%player%}%&6]" to loop-player
                            send "{@SuiteAC.Tag} &7Tried to attack untargeted entity." to loop-player
                    set {notify} to false
                    wait {@Notify.Delay} seconds
                    set {notify} to true
                    stop

# -------------- #
# ---- Item ---- #

on shoot:
    if {@Item.Bow} is true:
        if {item.bow.avoid.%shooter%} is false:
            if shooter's tool is bow:
                if {bowshoot.%shooter%} is false:
                    set {bowshoot.%shooter%} to true
                    wait {@Item.Bow.Delay} seconds
                    set {bowshoot.%shooter%} to false
                    stop
                if {bowshoot.%shooter%} is true:
                    cancel event
                    add 1 to {item.bow.%shooter%}
                    if {@Notify.Toggle} is true:
                        if {notify} is true:
                            loop players:
                                if loop-player has permission "sac.notify":
                                    send "{@SuiteAC.Tag} &e%shooter% &7failed Item.Bow &6[&fVL %{item.bow.%shooter%}%&6]" to loop-player
                                    send "{@SuiteAC.Tag} &7Tried to shoot with bow at higher frequency." to loop-player
                            set {notify} to false
                            wait {@Notify.Delay} seconds
                            set {notify} to true
                            stop
    if {@Item.Projectile} is true:
        if {item.projectile.avoid.%shooter%} is false:
            if shooter's held item is egg or ender pearl or eye of ender or snowball:
                if {projshoot.%shooter%} is false:
                    set {projshoot.%shooter%} to true
                    wait {@Item.Projectile.Delay} seconds
                    set {projshoot.%shooter%} to false
                    stop
                if {itemclick.%shooter%} is true:
                    cancel event
                    add 1 to {item.projectile.%shooter%}
                    if {@Notify.Toggle} is true:
                        if {notify} is true:
                            loop players:
                                if loop-player has permission "sac.notify":
                                    send "{@SuiteAC.Tag} &e%shooter% &7failed Item.Projectile &6[&fVL %{item.projectile.%shooter%}%&6]" to loop-player
                                    send "{@SuiteAC.Tag} &7Tried to shoot a projectile too quickly." to loop-player
                            set {notify} to false
                            wait {@Notify.Delay} seconds
                            set {notify} to true
                            stop

on inventory click:
    if {@Item.Inventory} is true:
        if {item.inventory.avoid.%player%} is false:
            if {itemclick.%player%} is false:
                set {itemclick.%player%} to true
                wait {@Item.Inventory.Delay} seconds
                set {itemclick.%player%} to false
                stop
            if {itemclick.%player%} is true:
                cancel event
                add 1 to {item.inventory.%player%}
                if {@Notify.Toggle} is true:
                    if {notify} is true:
                        loop players:
                            if loop-player has permission "sac.notify":
                                send "{@SuiteAC.Tag} &e%player% &7failed Item.Inventory &6[&fVL %{item.inventory.%player%}%&6]" to loop-player
                                send "{@SuiteAC.Tag} &7Tried to click in inventory too quickly." to loop-player
                        set {notify} to false
                        wait {@Notify.Delay} seconds
                        set {notify} to true
                        stop

# --------------- #
# ---- Move ---- #

function MoveSneakVL(p: player):
    add 1 to {move.sneak.%{_p}%}
    if {@Notify.Toggle} is true:
        if {notify} is true:
            loop players:
                if loop-player has permission "sac.notify":
                    send "{@SuiteAC.Tag} &e%{_p}% &7failed Move.Sneak &6[&fVL %{move.sneak.%{_p}%}%&6]" to loop-player
                    send "{@SuiteAC.Tag} &7Tried to make a modified movement while sneaking." to loop-player
            set {notify} to false
            wait {@Notify.Delay} seconds
            set {notify} to true
            stop

function MoveStandardVL(p: player):
    add 1 to {move.standard.%{_p}%}
    if {@Notify.Toggle} is true:
        if {notify} is true:
            loop players:
                if loop-player has permission "sac.notify":
                    send "{@SuiteAC.Tag} &e%{_p}% &7failed Move.Standard &6[&fVL %{move.standard.%{_p}%}%&6]" to loop-player
                    send "{@SuiteAC.Tag} &7Tried to make a modified movement at normal stage." to loop-player
            set {notify} to false
            wait {@Notify.Delay} seconds
            set {notify} to true
            stop

function MoveVehicleVL(p: player):
    add 1 to {move.vehicle.%{_p}%}
    if {@Notify.Toggle} is true:
        if {notify} is true:
            loop players:
                if loop-player has permission "sac.notify":
                    send "{@SuiteAC.Tag} &e%{_p}% &7failed Move.Vehicle &6[&fVL %{move.vehicle.%{_p}%}%&6]" to loop-player
                    send "{@SuiteAC.Tag} &7Tried to make a modified movement while riding." to loop-player
            set {notify} to false
            wait {@Notify.Delay} seconds
            set {notify} to true
            stop

on teleport:
    if {move.sneak.avoid.%player%} is false:
        set {move.sneak.avoid.%player%} to true
        wait 0.35 seconds
        set {move.sneak.avoid.%player%} to false
    if {move.standard.avoid.%player%} is false:
        set {move.standard.avoid.%player%} to true
        wait 0.35 seconds
        set {move.standard.avoid.%player%} to false
    if {move.vehicle.avoid.%player%} is false:
        set {move.vehicle.avoid.%player%} to true
        wait 0.35 seconds
        set {move.vehicle.avoid.%player%} to false

every 0.25 real seconds:
    loop players:
        if loop-player's gamemode is survival or adventure:
            if block 0.1 meter below the loop-player is not air or grass or torch or sugar cane:
                set {loc.safe.%loop-player%} to location of loop-player
            SetXYZ2(loop-player)
            if loop-player is riding:
                if {@Move.Vehicle} is true:
                    if {move.vehicle.avoid.%loop-player%} is false:
                        if {loc.x1.%loop-player%} is smaller than {loc.x2.%loop-player%}:
                            if ({loc.x2.%loop-player%}-{loc.x1.%loop-player%}) is more than {@Move.Vehicle.Value}:
                                MoveVehicleVL(loop-player)
                                teleport loop-player to {loc.safe.%loop-player%}
                                SetXYZ1(loop-player)
                                stop
                        if {loc.x1.%loop-player%} is bigger than {loc.x2.%loop-player%}:
                            if ({loc.x1.%loop-player%}-{loc.x2.%loop-player%}) is more than {@Move.Vehicle.Value}:
                                MoveVehicleVL(loop-player)
                                teleport loop-player to {loc.safe.%loop-player%}
                                SetXYZ1(loop-player)
                                stop
                        if {loc.z1.%loop-player%} is smaller than {loc.z2.%loop-player%}:
                            if ({loc.z2.%loop-player%}-{loc.z1.%loop-player%}) is more than {@Move.Vehicle.Value}:
                                MoveVehicleVL(loop-player)
                                teleport loop-player to {loc.safe.%loop-player%}
                                SetXYZ1(loop-player)
                                stop
                        if {loc.z1.%loop-player%} is bigger than {loc.z2.%loop-player%}:
                            if ({loc.z1.%loop-player%}-{loc.z2.%loop-player%}) is more than {@Move.Vehicle.Value}:
                                MoveVehicleVL(loop-player)
                                teleport loop-player to {loc.safe.%loop-player%}
                                SetXYZ1(loop-player)
                                stop
                        SetXYZ1(loop-player)
            else:
                if loop-player is sneaking:
                    if {@Move.Sneak} is true:
                        if {move.sneak.avoid.%loop-player%} is false:
                            if {loc.x1.%loop-player%} is smaller than {loc.x2.%loop-player%}:
                                if ({loc.x2.%loop-player%}-{loc.x1.%loop-player%}) is more than {@Move.Sneak.XZ.Value}:
                                    MoveSneakVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if {loc.x1.%loop-player%} is bigger than {loc.x2.%loop-player%}:
                                if ({loc.x1.%loop-player%}-{loc.x2.%loop-player%}) is more than {@Move.Sneak.XZ.Value}:
                                    MoveSneakVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if {loc.y1.%loop-player%} is smaller than {loc.y2.%loop-player%}:
                                if ({loc.y2.%loop-player%}-{loc.y1.%loop-player%}) is more than {@Move.UpY.Value}:
                                    MoveSneakVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if {loc.y1.%loop-player%} is bigger than {loc.y2.%loop-player%}:
                                if ({loc.y1.%loop-player%}-{loc.y2.%loop-player%}) is more than {@Move.DownY.Value}:
                                    MoveSneakVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if {loc.z1.%loop-player%} is smaller than {loc.z2.%loop-player%}:
                                if ({loc.z2.%loop-player%}-{loc.z1.%loop-player%}) is more than {@Move.Sneak.XZ.Value}:
                                    MoveSneakVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if {loc.z1.%loop-player%} is bigger than {loc.z2.%loop-player%}:
                                if ({loc.z1.%loop-player%}-{loc.z2.%loop-player%}) is more than {@Move.Sneak.XZ.Value}:
                                    MoveSneakVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            SetXYZ1(loop-player)
                else:
                    if {@Move.Standard} is true:
                        if {move.standard.avoid.%loop-player%} is false:
                            if {loc.y1.%loop-player%} is smaller than {loc.y2.%loop-player%}:
                                if ({loc.y2.%loop-player%}-{loc.y1.%loop-player%}) is more than {@Move.UpY.Value}:
                                    MoveStandardVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if {loc.y1.%loop-player%} is bigger than {loc.y2.%loop-player%}:
                                if ({loc.y1.%loop-player%}-{loc.y2.%loop-player%}) is more than {@Move.DownY.Value}:
                                    MoveStandardVL(loop-player)
                                    teleport loop-player to {loc.safe.%loop-player%}
                                    SetXYZ1(loop-player)
                                    stop
                            if loop-player's hunger is more than 3:
                                if {loc.x1.%loop-player%} is smaller than {loc.x2.%loop-player%}:
                                    if ({loc.x2.%loop-player%}-{loc.x1.%loop-player%}) is more than {@Move.Standard.XZ.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                                if {loc.x1.%loop-player%} is bigger than {loc.x2.%loop-player%}:
                                    if ({loc.x1.%loop-player%}-{loc.x2.%loop-player%}) is more than {@Move.Standard.XZ.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                                if {loc.z1.%loop-player%} is smaller than {loc.z2.%loop-player%}:
                                    if ({loc.z2.%loop-player%}-{loc.z1.%loop-player%}) is more than {@Move.Standard.XZ.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                                if {loc.z1.%loop-player%} is bigger than {loc.z2.%loop-player%}:
                                    if ({loc.z1.%loop-player%}-{loc.z2.%loop-player%}) is more than {@Move.Standard.XZ.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                            else:
                                if {loc.x1.%loop-player%} is smaller than {loc.x2.%loop-player%}:
                                    if ({loc.x2.%loop-player%}-{loc.x1.%loop-player%}) is more than {@Move.Standard.XZ.Hunger.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                                if {loc.x1.%loop-player%} is bigger than {loc.x2.%loop-player%}:
                                    if ({loc.x1.%loop-player%}-{loc.x2.%loop-player%}) is more than {@Move.Standard.XZ.Hunger.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                                if {loc.z1.%loop-player%} is smaller than {loc.z2.%loop-player%}:
                                    if ({loc.z2.%loop-player%}-{loc.z1.%loop-player%}) is more than {@Move.Standard.XZ.Hunger.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                                if {loc.z1.%loop-player%} is bigger than {loc.z2.%loop-player%}:
                                    if ({loc.z1.%loop-player%}-{loc.z2.%loop-player%}) is more than {@Move.Standard.XZ.Hunger.Value}:
                                        MoveStandardVL(loop-player)
                                        teleport loop-player to {loc.safe.%loop-player%}
                                        SetXYZ1(loop-player)
                                        stop
                            SetXYZ1(loop-player)

# --------------- #
# ---- Place ---- #

on place:
    if {@Place.Aim} is true:
        if {place.aim.avoid.%player%} is false:
            if location of event-block is not location of targeted block:
                if targeted block is not water or lava or snow layer or grass:
                    cancel event
                    add 1 to {place.aim.%player%}
                    if {@Notify.Toggle} is true:
                        if {notify} is true:
                            loop players:
                                if loop-player has permission "sac.notify":
                                    send "{@SuiteAC.Tag} &e%player% &7failed Place.Aim &6[&fVL %{place.aim.%player%}%&6]" to loop-player
                                    send "{@SuiteAC.Tag} &7Tried to place a block on untargeted location." to loop-player
                            set {notify} to false
                            wait {@Notify.Delay} seconds
                            set {notify} to true
    if {@Place.Range} is true:
        if {place.range.avoid.%player%} is false:
            if distance between event-block and player is more than {@Place.Range.Value}:
                cancel event
                add 1 to {place.range.%player%}
                if {@Notify.Toggle} is true:
                    if {notify} is true:
                        loop players:
                            if loop-player has permission "sac.notify":
                                send "{@SuiteAC.Tag} &e%player% &7failed Place.Range &6[&fVL %{place.range.%player%}%&6]" to loop-player
                                send "{@SuiteAC.Tag} &7Tried to place block at higher range than {@Place.Range.Value} blocks." to loop-player
                        set {notify} to false
                        wait {@Notify.Delay} seconds
                        set {notify} to true
    if {@Place.Speed} is true:
        if {place.speed.avoid.%player%} is false:
            if {blockplace.%player%} is false:
                set {blockplace.%player%} to true
                wait {@Place.Speed.Delay} seconds
                set {blockplace.%player%} to false
                stop
            if {blockplace.%player%} is true:
                cancel event
                add 1 to {place.speed.%player%}
                if {@Notify.Toggle} is true:
                    if {notify} is true:
                        loop players:
                            if loop-player has permission "sac.notify":
                                send "{@SuiteAC.Tag} &e%player% &7failed Place.Speed &6[&fVL %{place.speed.%player%}%&6]" to loop-player
                                send "{@SuiteAC.Tag} &7Tried to place blocks much faster than possible." to loop-player
                        set {notify} to false
                        wait {@Notify.Delay} seconds
                        set {notify} to true