Bulundu Daireden son çıkan kazanır

options:
    # Performans ayarları (tick = 50ms)
    check-interval: 5           
    batch-size: 32               
    max-radius-check-per-tick: 4

    default-radius: 25
    shrink-amount: 2
    shrink-interval: 60

    ltc-prefix: &a[LTC]&r

# ----------------------------------------------------------------------------
# {ltc.arenas::*}                      = arena listesi
# {ltc.%A%.center}                     = location (merkez)
# {ltc.%A%.radius}                     = number
# {ltc.%A%.players::*}                 = oyuncu listesi
# {ltc.%A%.state}                      = "idle" / "running"
# {ltc.%A%.async.task}                 = BukkitRunnable (reflect objesi)
# {ltc.%A%.async.queue::*}             = ASYNC hesap sonuç kuyruğu (player -> flag)
# {ltc.%A%.nextShrink}                 = timestamp
# ----------------------------------------------------------------------------

import:
    org.bukkit.Bukkit
    org.bukkit.Location
    org.bukkit.entity.Player
    org.bukkit.plugin.Plugin
    org.bukkit.scheduler.BukkitRunnable

function ltc-ensure(arena: string) :: boolean:
    loop {ltc.arenas::*}:
        if loop-value is {_arena}:
            return true
    return false

function ltc-setup(arena: string):
    if {ltc.%{_arena}%.radius} is not set:
        set {ltc.%{_arena}%.radius} to {@default-radius}
    if {ltc.%{_arena}%.state} is not set:
        set {ltc.%{_arena}%.state} to "idle"

function ltc-async-start(arena: string):
    if {ltc.%{_arena}%.async.task} is set:
        stop

    set {_pl} to Bukkit.getPluginManager().getPlugin("Skript")
    set {_task} to new BukkitRunnable:
        run():
            if {ltc.%{_arena}%.state} != "running":
                return

            set {_center} to {ltc.%{_arena}%.center}
            set {_radius} to {ltc.%{_arena}%.radius}
            set {_list::*} to {ltc.%{_arena}%.players::*}

            set {_toCheck::*} to {_list::*}
            while size of {_toCheck::*} > 0:
                set {_batch::*} to first {@batch-size} elements out of {_toCheck::*}
                delete first {@batch-size} elements out of {_toCheck::*}

                loop {_batch::*}:
                    set {_pName} to "%loop-value%"
                    add "check::%{_pName}%" to {ltc.%{_arena}%.async.queue::*}

            if {ltc.%{_arena}%.nextShrink} is set:
                if difference between now and {ltc.%{_arena}%.nextShrink} >= {@shrink-interval} seconds:
                    # Daraltma kararını kuyrukla, uygulamayı SYNC yap
                    add "shrink" to {ltc.%{_arena}%.async.queue::*}
                    set {ltc.%{_arena}%.nextShrink} to now
            else:
                set {ltc.%{_arena}%.nextShrink} to now

    {_task}.runTaskTimerAsynchronously({_pl}, 0L, {@check-interval}L)
    set {ltc.%{_arena}%.async.task} to {_task}

function ltc-async-stop(arena: string):
    if {ltc.%{_arena}%.async.task} is set:
        {_task} cancel
        delete {ltc.%{_arena}%.async.task}
    delete {ltc.%{_arena}%.async.queue::*}

every 1 tick:
    loop {ltc.arenas::*}:
        set {_a} to loop-value
        if {ltc.%{_a}%.state} is not "running":
            continue

        if "shrink" is in {ltc.%{_a}%.async.queue::*}:
            remove "shrink" from {ltc.%{_a}%.async.queue::*}
            remove {@shrink-amount} from {ltc.%{_a}%.radius}
            if {ltc.%{_a}%.radius} < 3:
                set {ltc.%{_a}%.radius} to 3
            send action bar "Yeni yarıçap: %{ltc.%{_a}%.radius}%" to {ltc.%{_a}%.players::*}
        set {_processed} to 0
        loop {ltc.%{_a}%.async.queue::*}:
            if {_processed} >= {@max-radius-check-per-tick}:
                stop loop
            if loop-value starts with "check::":
                set {_pName} to substring of loop-value from 8
                remove loop-value from {ltc.%{_a}%.async.queue::*}
                add 1 to {_processed}

                set {_p} to player({_pName})
                if {_p} is not set or {_p} is offline:
                    continue
                set {_c} to {ltc.%{_a}%.center}
                set y-coordinate of {_c} to y-coordinate of {_p}'s location
                set {_dist} to distance between location of {_p} and {_c}
                if {_dist} > {ltc.%{_a}%.radius}:
                    # remove {_p} from {ltc.%{_a}%.players::*}
                    # teleport {_p} to {ltc.%{_a}%.lobby}
                    # show title "ELENDİN" to {_p}
                    pass

        if size of {ltc.%{_a}%.players::*} <= 1:
            # ltc-async-stop({_a})
            pass

command /ltca [<text>] [<text>]:
    permission: ltc.use
    trigger:
        if arg-1 is "create":
            if arg-2 is not set:
                send "{@ltc-prefix} &7/ltca create <arena>" to player
                stop
            set {_a} to arg-2
            if ltc-ensure({_a}) is true:
                send "{@ltc-prefix} &eZaten var." to player
                stop
            add {_a} to {ltc.arenas::*}
            set {ltc.%{_a}%.center} to location of player
            set {ltc.%{_a}%.radius} to {@default-radius}
            set {ltc.%{_a}%.state} to "idle"
            send "{@ltc-prefix} &aOluşturuldu: &e%{_a}%" to player
            stop

        if arg-1 is "start":
            if arg-2 is not set:
                send "{@ltc-prefix} &7/ltca start <arena>" to player
                stop
            set {_a} to arg-2
            if ltc-ensure({_a}) is false:
                send "{@ltc-prefix} &cArena yok." to player
                stop
            set {ltc.%{_a}%.state} to "running"
            call ltc-setup({_a})
            call ltc-async-start({_a})
            send "{@ltc-prefix} &aBaşladı (ASYNC çekirdek)." to player
            stop

        if arg-1 is "stop":
            if arg-2 is not set:
                send "{@ltc-prefix} &7/ltca stop <arena>" to player
                stop
            set {_a} to arg-2
            if ltc-ensure({_a}) is false:
                send "{@ltc-prefix} &cArena yok." to player
                stop
            set {ltc.%{_a}%.state} to "idle"
            call ltc-async-stop({_a})
            send "{@ltc-prefix} &cDurduruldu." to player
            stop

        send "{@ltc-prefix} &7Komutlar: &e/ltca create <a>, /ltca start <a>, /ltca stop <a>" to player

on load:
    if yaml "ltc-async.yml" exists:
        load yaml "ltc-async.yml" into {ltc::*}

on shutdown:
    save yaml "ltc-async.yml" from {ltc::*}