ข้ามไปที่เนื้อหา

Task API

ทุกครั้งที่คำสั่งทำงาน ระบบจะสร้างงานหนึ่งงานให้กับเป้าหมายแต่ละคน งานนี้จะถูกส่งต่อเข้าไปใน run และเป็นตัวกำหนดว่าคำสั่งจะอยู่ได้นานแค่ไหน การเชื่อมต่อเครือข่าย การล้างข้อมูล และอื่นๆ อีกมาก

Methods

task:keep Server

task:keep(persistence: Persistence?)

ทำให้งานยังอยู่ต่อหลังจาก run ทำงานเสร็จ ถ้าไม่เรียก งานจะถูกทำลายทันที ตัวเลือกมี "UntilTargetRespawns", "UntilTargetLeaves", "UntilCallerRespawns", "UntilCallerLeaves" และ "Indefinitely" ถ้าเรียกหลายครั้ง เงื่อนไขจะรวมกัน งานจะจบเมื่อมีเงื่อนไขใดเงื่อนไขหนึ่งเกิดขึ้นก่อน ดู การคงอยู่


task:getArg Server

task:getArg(nameOrPosition: string | number, ignoreDefault: boolean?): any

อ่านค่าที่ผ่านการตรวจสอบแล้วของอาร์กิวเมนต์ตามชื่อหรือตำแหน่งที่ระบุ ค่านี้อาจมาจาก default ของอาร์กิวเมนต์นั้น ค่าที่ผู้ใช้คำสั่งใส่มาและผ่านการตรวจสอบแล้ว ค่าที่พรอมต์เปลี่ยนให้ หรือค่าที่ตั้งไว้ด้วย task:setArg()

ใส่ true เป็นอาร์กิวเมนต์ตัวที่สอง เพื่อให้ได้ nil เมื่อผู้ใช้คำสั่งไม่ได้ใส่ค่า และค่าที่มีมาจาก default ของอาร์กิวเมนต์เท่านั้น เหมาะกับอาร์กิวเมนต์ที่ไม่บังคับ เมื่อคุณอยากใช้พฤติกรรมของตัวเองแทน เช่น ;message ที่คำนวณระยะเวลาจากความยาวข้อความ ถ้าไม่ได้พิมพ์ระยะเวลามา


task:setArg Server

task:setArg(nameOrPosition: string | number, value: any)

เปลี่ยนค่าของอาร์กิวเมนต์ตามชื่อหรือตำแหน่งที่ระบุ


task:buff Server

task:buff(player: Player, group: string, priority: number?, callback: (hasEnded: boolean, original: any) -> any)

เปลี่ยนพร็อพเพอร์ตี้ แล้วใช้การเปลี่ยนแปลงกับพร็อพเพอร์ตี้นั้นอีกครั้งเมื่อบัฟในกลุ่มเดียวกันเปลี่ยน จากนั้นรีเซ็ตพร็อพเพอร์ตี้กลับเป็นค่าเดิมเมื่องานจบ ดู บัฟ


task:updateBuffs Server

task:updateBuffs(player: Player?, group: string?)

รันบัฟของผู้เล่นและกลุ่มนั้นใหม่ ส่วนใหญ่ระบบจัดการให้อัตโนมัติอยู่แล้ว จึงมีประโยชน์เฉพาะตอนที่คุณอยากบังคับให้ทุกอย่างในกลุ่มนั้นอัปเดตเท่านั้น


task:redo Server

task:redo(player: Player?, callback: () -> ())

รัน callback ของคุณทันที แล้วรันอีกทุกครั้งที่ผู้เล่นเกิดใหม่ระหว่างที่งานยังอยู่ เหมาะกับเอฟเฟกต์ที่ปกติจะหายไปเมื่อเกิดใหม่


task:bindPrompt Server

task:bindPrompt(config)

แสดงพรอมต์การทำงานที่ผูกกับคำสั่งให้ผู้ใช้คำสั่ง เช่น แถบเลื่อนของ ;speed หรือสีตาของ ;laserEyes:

run = function(task: CommandAPI.Task)
    task:keep("UntilCallerLeaves")
    task:bindPrompt({
        title = "Dangerous Script",
        text = "This script uses HttpService, are you sure you want to load it?",
        audience = task.caller,
        duration = 20,
        deactivate = false,
        endOnClose = true,
        buttons = {
            {
                label = "Load",
                onActivate = function()
                    --loadScript()
                    task:destroy()
                end,
            },
            {
                label = "Cancel",
                style = "Neutral",
                onActivate = function()
                    task:destroy()
                end,
            },
        },
    })
end,

ตัวเลือกใน config

Key Type What it does
title string หัวข้อของพรอมต์ ค่าเริ่มต้นคือชื่อคำสั่ง
text string ข้อความหลัก
subtext string บรรทัดเล็กๆ ใต้ข้อความหลัก
audience Player คนที่เห็นพรอมต์ ค่าเริ่มต้นคือ task.target
duration number จำนวนวินาทีก่อนที่พรอมต์จะปิดเอง ค่าเริ่มต้นคือ 0 ซึ่งหมายถึงไม่จำกัดเวลา
args table อาร์กิวเมนต์ของคำสั่งที่จะแสดงเป็นตัวควบคุม ดู การควบคุม
onChange function function(argName, value) ทำงานหลังจากตัวควบคุมเปลี่ยนอาร์กิวเมนต์
toggle table สวิตช์เปิด/ปิดเพิ่มเติมที่ไม่ผูกกับอาร์กิวเมนต์ใดๆ {label = "Trails", value = true, onChange = function(isOn) end}
buttons table ปุ่มสำหรับทำสิ่งใดสิ่งหนึ่ง ดู ปุ่ม
deactivate boolean ค่าเริ่มต้นคือ true ซึ่งจะมีสวิตช์สำหรับหยุดชั่วคราวและเล่นต่อคำสั่ง กับปุ่ม Stop ที่จบคำสั่ง ตั้งเป็น false ถ้าต้องการพรอมต์ที่มีแต่ปุ่ม
rerun boolean เพิ่มปุ่มรันใหม่ ซึ่งจะล้างข้อมูลแล้วรันคำสั่งอีกครั้ง แสดงเฉพาะเมื่อ deactivate เป็น false
endOnClose boolean ปกติการปิดพรอมต์จะจบงาน ถ้าตั้งเป็น false งานจะรันต่อจนกว่าไคลเอนต์จะปิดเอง

การควบคุม

ถ้าอยากให้อาร์กิวเมนต์ควบคุมได้จากพรอมต์การทำงาน ให้ใส่ชื่ออาร์กิวเมนต์นั้นไว้ใน args ภายใน bindPrompt Number จะกลายเป็นแถบเลื่อน Color เป็นตัวเลือกสี Bool เป็นสวิตช์ และอื่นๆ ทุกครั้งที่ไคลเอนต์เปลี่ยนค่า อาร์กิวเมนต์จะอัปเดตและ onChange จะทำงาน คุณแค่เรียก task:getArg อีกครั้งเพื่ออ่านค่าใหม่ ไม่ต้องตรวจสอบอะไรเพิ่มด้วย เพราะทุกค่าถูกเช็กเหมือนกับที่พิมพ์ในแชทเอง:

run = function(task: CommandAPI.Task)
    local function applySpinSpeed()
        local speed = task:getArg("Number")
        -- spin the character at this speed
    end
    applySpinSpeed()
    task:bindPrompt({
        args = {"Number"},
        onChange = applySpinSpeed,
    })
end,

ปุ่ม

ปุ่มก็ง่ายไม่แพ้กัน ใส่ label กับฟังก์ชัน onActivate ให้แต่ละปุ่ม แล้วฟังก์ชันนั้นจะรันบนเซิร์ฟเวอร์ทุกครั้งที่ไคลเอนต์กดปุ่ม จะให้รอ (yield) ในนี้ก็ได้ เช่น พรอมต์ซื้อของ หรือการเรียก DataStore เพราะปุ่มจะแสดงวงหมุนจนกว่าคุณจะทำเสร็จ:

Key Type What it does
label string ข้อความบนปุ่ม
onActivate function สิ่งที่เกิดขึ้นเมื่อกดปุ่ม
style string ค่าเริ่มต้นคือ "Primary" หรือ "Neutral" สำหรับปุ่มสีเทา เหมาะกับปุ่ม Cancel
confirm boolean เพิ่มขั้นตอน Confirm? ต้องกดสองครั้งปุ่มถึงจะทำงาน เหมาะกับสิ่งที่แรง เช่น การยืนยันแบน

ปุ่มสามารถจบงานของตัวเองได้ด้วย task:destroy() ซึ่งเป็นสิ่งที่พรอมต์ของคำสั่งที่ใช้ครั้งเดียวจบอย่าง ;teleport ทำ


task.client:run Server

task.client:run(player: Player?, ...)
task.client:runAll(...)
task.client:runOthers(originPlayer: Player, ...)
task.client:runNearby(originPlayer: Player?, radius: number, ...)

รันคำสั่งฝั่งไคลเอนต์ที่ตรงกันบนอุปกรณ์ของผู้เล่น โดยส่งค่าเพิ่มเติมที่ใส่มาต่อไปตรงๆ run ใช้กับผู้เล่นหนึ่งคน runAll ใช้กับทุกคน runOthers ใช้กับทุกคนยกเว้น originPlayer และ runNearby ใช้กับคนที่อยู่ในระยะ radius สตั๊ด ดู เครือข่าย


task.client:expose Server

task.client:expose(player: Player, instances: Instance | {Instance})
task.client:exposeAll(instances: Instance | {Instance})

ทำให้แน่ใจว่าอินสแตนซ์เหล่านั้นไปถึงผู้เล่นแล้วจริงๆ ก่อนที่โค้ดฝั่งไคลเอนต์จะไปหา การสตรีมอาจทำให้บางอย่างมาไม่ทัน ดังนั้นสิ่งที่คุณสร้างบนเซิร์ฟเวอร์แล้วจะใช้บนไคลเอนต์ ควรผ่านฟังก์ชันนี้ก่อนเสมอ


task.server:replicate Client

task.server:replicate(...)

ส่งค่าจากคำสั่งฝั่งไคลเอนต์กลับขึ้นไปที่เซิร์ฟเวอร์ ซึ่งจะไปอยู่ในงานเดียวกัน ตั้ง task.client.replicator บนเซิร์ฟเวอร์เพื่อเลือกว่าจะส่งต่อให้ใคร แล้วค่าจะมาถึงฟังก์ชัน replication ของคำสั่งนั้น ดู เครือข่าย


task:tween Shared

task:tween(instance: Instance, tweenInfo: TweenInfo, properties: {[string]: any}): Tween

เล่นทวีนที่จะถูกล้างไปพร้อมกับงาน จึงไม่มีทางอยู่นานกว่าคำสั่ง


task:createSound Shared

task:createSound(soundType: SoundType?): Sound

สร้าง Sound ที่งานเป็นเจ้าของและล้างให้เอง ผู้เล่นทุกคนปรับ Volume และ Pitch ของเสียงนี้ได้ใน YouSettings ถ้าไม่ได้ตั้ง SoundType ค่าเริ่มต้นคือ "Command"


task:onEnded Shared

task:onEnded(callback: () -> ())

รัน callback ของคุณทุกครั้งที่งานจบ เทียบเท่ากับการเรียก task.janitor:add(callback)


task:onEndedForGood Shared

task:onEndedForGood(callback: () -> ())

รัน callback ของคุณเฉพาะเมื่องานจบแล้ว และไม่มีงานที่เหมือนกันถูกสร้างตามมาทันที เหมาะกับคำสั่งอย่าง ;serverLock Admin ที่แสดงการแจ้งเตือนตอนคำสั่งเริ่ม ("This server has been locked for Admins") และตอนจบ ("This server has been unlocked") แต่ถ้าเราไปรัน ;serverLock Mod ต่อ เราไม่อยากให้คำสั่งก่อนหน้าแสดงการแจ้งเตือนตอนจบ เราอยากให้แสดงเฉพาะการแจ้งเตือนตอนเริ่มอันใหม่


task:destroy Shared

task:destroy()

จบงานทันทีและล้างทุกอย่างที่งานเป็นเจ้าของ นี่คือสิ่งที่ ;un เรียกอยู่เบื้องหลัง


Scheduling Shared

task.spawn(callback: () -> ())
task.defer(callback: () -> ())
task.delay(seconds: number, callback: (() -> ())?)
task.wait(seconds: number?)
task.iterate(count: number, callback: (index: number) -> ())
task.loop(callback: (stop: () -> (), index: number) -> ())

ฟังก์ชันเหล่านี้คือตัวห่อของ task ใน Roblox ที่รู้จักงานของ HD Admin ซึ่งจำเป็น เพื่อให้คำสั่งอยู่ได้ตลอดที่ยังทำงาน หรือให้ถูกยกเลิกอัตโนมัติเมื่องานถูกล้าง (เช่น มีคนใช้ undo ก่อนที่งานจะจบ) ใช้ได้เหมือนเมธอด task ปกติของ Roblox เลย HD Admin จัดการส่วนที่เหลือให้ภายใน

Properties

task.target Server

task.target: Player

ผู้เล่นที่คำสั่งกำลังทำงานกับเขา ถ้าอาร์กิวเมนต์แรกของคุณเป็น Player ค่านี้จะมีเสมอ เพราะ HD Admin แยกการรันเป็นงานแยกสำหรับผู้เล่นที่ตรงกันแต่ละคน คุณจึงใช้ได้เลยโดยไม่ต้องเช็ก ส่วนคำสั่งที่รับอาร์กิวเมนต์ Players แบบรวมจะไม่ถูกแยกแบบนี้ ค่านี้จึงว่างเปล่า task.targetUserId เก็บ UserId ของเป้าหมาย และมีให้แม้เขาจะออฟไลน์อยู่


task.qualifiers Server

task.qualifiers: {[string]: {string}}

เป้าหมายที่ผู้ใช้คำสั่งระบุไว้ในข้อความคำสั่งดั้งเดิม ;clone others จะให้ {others = {}} ส่วน ;clone เฉยๆ จะให้ตารางว่าง ค่านี้เป็นตารางเสมอ จึงอ่านตรงๆ ได้อย่างปลอดภัย


task.caller Server

task.caller: Player?

คนที่รันคำสั่ง หรือ nil เมื่อเซิร์ฟเวอร์เป็นคนรัน (หรือเมื่ออยู่ในเซิร์ฟเวอร์ที่รับคำสั่งแบบ global ซึ่งผู้ใช้คำสั่งไม่ได้อยู่ในเซิร์ฟเวอร์ของคุณ) task.callerUserId มีเสมอ ถ้าต้องการ UserId ของเขาให้ใช้ตัวนี้แทน


task.janitor Shared

task.janitor:add(item): typeof(item)

ออบเจกต์ Janitor ที่คุณส่งอินสแตนซ์ คอนเนกชัน และฟังก์ชันให้ได้ เพื่อให้ล้างให้อัตโนมัติ ตัวอย่างเช่น:

local fire = task.janitor:add(Instance.new("Fire"))
fire.Parent = targetsHumanoidRootPart


task.config Server

task.config: {[string]: any}

ตาราง config ของคำสั่งนั้นเอง รวมถึงสิ่งที่แพ็กเปลี่ยนผ่าน modify ใน Config > Commands คำสั่งใช้ตัวนี้อ่านการตั้งค่าที่เจ้าของเกมควรเปลี่ยนเองได้ เช่น รายการอนุญาตและรายการห้ามของ ;insert


task.extra Shared

task.extra: {[string]: any}

ตารางสำหรับเก็บข้อมูลเพิ่มเติมที่คุณใส่เองได้ และข้อมูลนี้จะอยู่ต่อแม้งานถูกปิดการทำงาน จนกว่างานจะจบสมบูรณ์


task.isActive Shared

task.isActive: boolean

เป็น true ตอนที่งานกำลังทำงาน และเป็น false เมื่อเริ่มจบ ใช้ในลูปเพื่อให้เอฟเฟกต์หยุดทันทีถ้างานถูกบังคับจบ


task.commandKey Shared

task.commandKey: string

ชื่อคำสั่งที่งานนี้กำลังรัน เป็นตัวพิมพ์เล็กทั้งหมด


task.isReplay Server

task.isReplay: boolean

เป็น true เมื่อคำสั่งถาวรที่บันทึกไว้ถูกรันซ้ำตอนเซิร์ฟเวอร์เริ่มทำงาน แทนที่จะเป็นการที่มีคนรันตอนนั้นจริงๆ มีประโยชน์ในการจำกัดพรอมต์ของคำสั่งถาวรที่เราไม่อยากให้ผู้ใช้คำสั่งเห็นซ้ำอัตโนมัติ (เช่น พรอมต์ของ ;music ตอนเข้าเซิร์ฟเวอร์ใหม่ทุกครั้ง)