← บล็อก

ทำเกม Godot ให้เล่นหลายคนได้ โดยไม่ต้องรันเกมเซิร์ฟเวอร์เอง

· Hibira

เราสร้างแอดออน Hibira สำหรับ Godot 4 ด้วย GDScript ล้วน มีห้อง แชท และการซิงก์ตำแหน่งผู้เล่น ใช้ได้แม้ส่งออกเป็นเว็บ ทำไมเราถึงสร้าง ทำงานอย่างไร และเดโมที่รันได้ในห้านาที

วันหนึ่งมีคนในทีมถามขึ้นมาว่า "Godot รองรับโปรโตคอล Pusher ไหม"

คำตอบคือไม่ Godot 4 มี WebSocket ในตัว และมี API มัลติเพลเยอร์ระดับสูงครบชุด แต่ทั้งสองอย่างคาดว่าคุณจะรันเกมเซิร์ฟเวอร์เอง หรือให้ผู้เล่นคนหนึ่งเป็นโฮสต์ สำหรับทีมเล็กจำนวนมาก นี่คือจุดที่มัลติเพลเยอร์ติดขัดที่สุด ตัวเกมเสร็จแล้ว แต่ยังต้องเรียนรู้วิธีตั้งเซิร์ฟเวอร์ เปิดพอร์ต จัดการ NAT แล้วยังต้องจ่ายค่าเครื่องทุกเดือนโดยไม่รู้ว่าจะมีคนเล่นกี่คน

เราอยากได้อีกวิธีหนึ่ง คือใส่แค่ไคลเอนต์ไว้ในเกม เชื่อมต่อกับบริการเรียลไทม์แบบโฮสต์ให้ แล้วให้บริการนั้นส่งต่อห้อง รายชื่อคนออนไลน์ และข้อความระหว่างผู้เล่น เราจึงสร้างแอดออน Hibira สำหรับ Godot ขึ้นมา เขียนด้วย GDScript ล้วน ไม่ต้องใช้ส่วนขยายแบบเนทีฟ จึงทำงานได้ทุกแพลตฟอร์มที่ Godot ส่งออกได้ รวมถึงเว็บด้วย

ห้องเดียวกัน ทางซ้ายเป็นผู้เล่นบน Godot ทางขวาเป็นผู้เล่นบนเบราว์เซอร์
ห้องเดียวกัน ทางซ้ายเป็นผู้เล่นบน Godot ทางขวาเป็นผู้เล่นบนเบราว์เซอร์

เกมมัลติเพลเยอร์ขนาดเล็กต้องการอะไรจริงๆ

ไม่ใช่ทุกเกมมัลติเพลเยอร์จะเป็นเกมยิง เมื่อเราดูเกมอินดี้และผลงานจากเกมแจมรอบตัว ส่วนมัลติเพลเยอร์ส่วนใหญ่เป็นแบบนี้

  • ล็อบบี้และห้อง: สร้างห้อง ได้รหัส ส่งให้เพื่อน แล้วรอให้ทุกคนกด "พร้อม"
  • ใครออนไลน์อยู่: ในห้องมีใครบ้าง ใครเพิ่งเข้ามา ใครออกไป ใครเป็นหัวห้อง
  • แชท: รวมถึง "อีกฝ่ายกำลังพิมพ์…"
  • การซิงก์เบาๆ: ตำแหน่งของทุกคนในเกมแบบร่วมมือ ใครกดก่อนในเกมปาร์ตี้ ตาถัดไปในเกมผลัดกันเล่น

สิ่งที่เหมือนกันคือข้อความมีขนาดเล็ก และความเร็วที่ต้องการคือ "เร็วอย่างที่คนรู้สึกได้" ไม่ใช่เร็วระดับมิลลิวินาทีแบบเกมยิง งานแบบนี้ใช้ WebSocket หนึ่งเส้นกับโมเดล "แชนเนล" ได้ดี ซึ่งเป็นสิ่งที่โปรโตคอล Pusher ถนัด

ทำไมต้องเป็นโปรโตคอล Pusher

โปรโตคอล Pusher ใช้กันมากว่าสิบปีแล้ว และโมเดลเรียบง่าย ไคลเอนต์สมัครรับแชนเนล ส่วนเซิร์ฟเวอร์หรือไคลเอนต์อื่นส่งอีเวนต์เข้าแชนเนลนั้น สำหรับเกม ส่วนที่มีประโยชน์คือ presence แชนเนล

  • แบ็กเอนด์ของคุณเป็นผู้เซ็นการสมัครรับ คุณจึงเป็นคนตัดสินว่าใครเข้าห้องไหนได้
  • แชนเนลจะบอกทุกคนว่าตอนนี้มีสมาชิกคือใคร ใครเข้ามาและใครออกไป
  • ผู้เล่นส่ง client อีเวนต์หากันได้โดยตรง และเซิร์ฟเวอร์จะประทับ user_id ของผู้ส่งลงบนทุกอีเวนต์

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

ข้อดีอีกอย่างคือ เมื่อโปรโตคอลเดียวกัน เว็บกับเกมก็คุยกันได้ SDK ล็อบบี้สำหรับเว็บของเรา @hibira-io/lobby ใช้อีเวนต์ชุดเดียวกัน ผู้เล่นบน Godot และผู้เล่นบนเบราว์เซอร์จึงนั่งอยู่ในห้องเดียวกันได้ อย่างในภาพด้านบน

ทำงานอย่างไร

เกม GodotHibiraClient
คำขอเซ็น
แบ็กเอนด์ของคุณเซ็น presence แชนเนลด้วย app secret
เกม GodotHibiraClient
WebSocket
Hibiraห้อง รายชื่อสมาชิก ส่งต่ออีเวนต์
WebSocket
ผู้เล่นอื่นGodot หรือเบราว์เซอร์
เกมเชื่อมต่อกับ Hibira เท่านั้น แบ็กเอนด์ของคุณมีหน้าที่แค่เซ็น

แอดออนมีส่วนหลักสี่ส่วน

  • HibiraClient: ไคลเอนต์โปรโตคอล Pusher v7 ที่สร้างบน WebSocketPeer ในตัวของ Godot ดูแลการเชื่อมต่อ การสมัครรับ ping/pong และเชื่อมต่อใหม่พร้อมสมัครรับอีกครั้งเมื่อหลุด
  • HibiraChannel: แชนเนลหนึ่งแชนเนล ใช้ bind() รับอีเวนต์ ใช้ trigger() ส่ง client อีเวนต์ และ presence แชนเนลจะมีรายชื่อสมาชิกกับ signal ตอนเข้าและออกเพิ่มมา
  • HibiraRoom: เปลี่ยน presence แชนเนลให้เป็นห้องเกม มีที่นั่ง หัวห้อง สถานะพร้อม การตั้งค่าห้อง เตะออก เริ่มเกม และแชทที่แสดงว่ากำลังพิมพ์
  • HibiraSync: โหนดใหม่ใน 0.2.0 วางไว้ใต้ตัวละคร แล้วตำแหน่งของมันจะไปปรากฏบนจอของผู้เล่นคนอื่น

app secret ไม่เคยอยู่ในเกมเลย ใครก็แกะไฟล์เกมที่ส่งออกแล้วได้ การเซ็นจึงต้องทำที่แบ็กเอนด์ของคุณ เหมือนกับ pusher-js หรือ Laravel Echo ทุกประการ ถ้ามีเวอร์ชันเว็บอยู่แล้ว ก็ใช้ endpoint ยืนยันตัวตนเดิมได้เลย

HibiraSync: วางแล้วซิงก์ทันที

ความต้องการที่พบบ่อยที่สุดในเกมแบบร่วมมือคือ "ให้คนอื่นเห็นว่าฉันอยู่ตรงไหน" เราอยากให้เรื่องนี้ใช้แค่โหนดเดียว ใน player.tscn ให้วาง HibiraSync ไว้ใต้ CharacterBody2D ตั้งชื่อแชนเนลเป็น presence-match-1 และพร็อพเพอร์ตีที่จะซิงก์เป็น position กับ rotation แล้วสร้างผู้เล่นแต่ละคนแบบนี้

func spawn(user_id: String) -> void:
	var p := PLAYER.instantiate()
	p.name = user_id
	p.get_node("HibiraSync").owner_id = user_id # ใครเป็นคนควบคุม
	add_child(p)

เบื้องหลังมีหลายอย่างเกิดขึ้น

  • มีแค่เจ้าของที่ขยับได้ ทุกโหนดมี owner_id ค่าที่มาจากคนอื่นที่ไม่ใช่เจ้าของจะถูกทิ้ง ซึ่งทำได้เพราะเซิร์ฟเวอร์ประทับ user_id ให้
  • ทั้งฉากรวมเป็นข้อความเดียว โหนดทุกตัวที่ซิงก์ในแชนเนลเดียวกันจะถูกรวมเป็น client อีเวนต์เดียวต่อหนึ่ง tick ค่าเริ่มต้นคือวินาทีละ 8 ครั้ง Hibira จำกัด client อีเวนต์ไว้ที่ 10 ครั้งต่อวินาทีต่อการเชื่อมต่อ ไม่ว่าฉากจะซิงก์กี่โหนดก็ไม่เกินขีดจำกัด
  • ส่งเฉพาะค่าที่เปลี่ยน ตัวละครยืนนิ่งก็ไม่ส่งอะไรเลย และเมื่อมีคนเข้าห้องใหม่ จะส่งค่าทั้งหมดให้อีกครั้ง
  • ค่าที่ได้รับจะเคลื่อนไหวอย่างนุ่มนวล ถ้านำการอัปเดตวินาทีละ 8 ครั้งไปใช้ตรงๆ ตัวละครจะกระโดดเป็นช่วงๆ จึงใช้ค่าที่ได้รับเป็นเป้าหมาย แล้วให้ตัวละครขยับเข้าใกล้ทีละนิดทุกเฟรม มีการประมาณค่าที่เหมาะกับมุมและควอเทอร์เนียนด้วย
เกมของผู้เล่น AHibiraเกมของผู้เล่น Bclient-hibira-sync{"s": {"A/Player": {"position": [...]}}}อีเวนต์เดิมพร้อม user_id: "A"ผู้เล่น B ตรวจว่า user_id เป็นเจ้าของโหนด แล้วจึงขยับตัวละครไปตำแหน่งใหม่อย่างนุ่มนวล
สิ่งที่เกิดขึ้นในหนึ่ง tick
Playground: หน้าต่างเบราว์เซอร์สองหน้าต่างในห้องเดียวกัน ต่างฝ่ายต่างควบคุมจุดของตัวเอง และจุดของอีกฝั่งจะตามมาอย่างนุ่มนวล

ต้องบอกให้ชัดว่า HibiraSync เหมาะกับเกมปาร์ตี้ เกมร่วมมือ และบอร์ดเกม ซึ่งเป็นเกมที่ "เล่นกันในหมู่เพื่อน" ผู้เล่นแต่ละคนควบคุมตัวละครของตัวเองได้เต็มที่ มันไม่ใช่เน็ตโค้ดแบบที่เซิร์ฟเวอร์เป็นผู้ตัดสิน เกมแข่งขันที่ต้องกันการโกงยังต้องให้เซิร์ฟเวอร์เป็นผู้ตัดสิน

เริ่มใช้งานในห้านาที

  1. ดาวน์โหลด addons/hibira จาก GitHub ใส่ไว้ในโฟลเดอร์ addons/ ของโปรเจกต์ แล้วเปิด Hibira Realtime ใน Project → Project Settings → Plugins
  2. เปิด addons/hibira/demo/playground.tscn แล้วกด F6 โดยไม่ต้องตั้งค่าอะไร มันจะเชื่อมต่อกับแอปเดโมสาธารณะของเรา และสร้างห้องที่มีรหัสสี่ตัวอักษร
  3. ไปที่ Debug → Customize Run Instances ตั้งจำนวนอินสแตนซ์เป็น 2 แล้วรันอีกครั้ง จะเห็นจุดสองจุดขยับอยู่ในห้องเดียวกัน

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

เมื่อจะใช้แอปของคุณเอง ให้ตั้งค่าในหน้าจัดการของ Hibira ก่อน คัดลอก key จาก Overview → Credentials ของแอป (secret จะแสดงเพียงครั้งเดียวตอนสร้างแอป และเก็บไว้ที่แบ็กเอนด์เท่านั้น) เปิด Settings → Allow client events และถ้าส่งออกเป็นเว็บ ให้เพิ่ม origin ของหน้าเว็บ เช่น https://yourname.itch.io ไว้ใน Settings → Allowed origins แพ็กเกจฟรีไม่รองรับ * และถ้าไม่เพิ่ม origin เบราว์เซอร์จะเชื่อมต่อไม่ได้ endpoint ยืนยันตัวตนของคุณเซ็น presence- แชนเนลได้เหมือนแบ็กเอนด์ที่รองรับ Pusher ทั่วไป ถ้าใช้ Node ก็ใช้ authorizeRoom() จาก @hibira-io/lobby ได้เลย

จากนั้นกรอก app key และ endpoint ยืนยันตัวตนในส่วน Hibira ของ Project Settings แอดออนจะเพิ่ม autoload ชื่อ Hibira ที่เชื่อมต่อเองตอนเกมเริ่ม และทุกสคริปต์เรียกใช้ได้ทันที

func _ready() -> void:
	var lobby := HibiraRoom.join(Hibira, "presence-room-ABCD", {"capacity": 4})
	lobby.message_received.connect(func(m): print(m.info.name, ": ", m.text))
	lobby.started.connect(func(data, _by): start_game(data))

ตัวอย่างที่สมบูรณ์: เกมวัดความไว

เพื่อยืนยันว่าชิ้นส่วนเหล่านี้ประกอบเป็นเกมได้จริง เราจึงทำเกมวัดความไวสำหรับสี่คน มีรายการห้อง สี่ที่นั่ง หัวห้อง ปุ่มพร้อม เตะออก แชทในห้อง และห้ารอบของ "เห็น GO! แล้วกดก่อน"

รายการห้อง: สร้างห้อง หรือใช้รหัสเข้าห้องของเพื่อน
รายการห้อง: สร้างห้อง หรือใช้รหัสเข้าห้องของเพื่อน
ในเกม: เมื่อหัวห้องกดเริ่ม การแตะแต่ละครั้งคือ client อีเวนต์หนึ่งครั้งบนแชนเนลของห้อง
ในเกม: เมื่อหัวห้องกดเริ่ม การแตะแต่ละครั้งคือ client อีเวนต์หนึ่งครั้งบนแชนเนลของห้อง

เกมนี้ใช้อีเวนต์ชุดเดียวกับตัวอย่างล็อบบี้บนเว็บของเรา ผู้เล่นบน Godot และบนเบราว์เซอร์จึงเล่นด้วยกันได้ ซอร์สโค้ดทั้งหมดอยู่ที่ examples/godot-lobby

ค่าใช้จ่ายและข้อจำกัด

  • client อีเวนต์หนึ่งครั้งนับเป็นหนึ่งข้อความ ไม่ว่าจะมีผู้รับกี่คน สี่คนเล่นห้ารอบใช้เพียงไม่กี่สิบข้อความ แพ็กเกจฟรีมีวันละ 200,000 ข้อความ เหลือเฟือสำหรับต้นแบบและการทดสอบเล็กๆ
  • โดยค่าเริ่มต้น HibiraSync ส่งได้สูงสุดวินาทีละ 8 ข้อความ (ปรับได้ใน Project Settings สูงสุด 10) และส่งเฉพาะตอนมีการเปลี่ยนแปลง ถ้าสี่คนขยับตลอดเวลา จะใช้สูงสุดราว 110,000 ข้อความต่อชั่วโมง ส่วนช่วงที่ยืนนิ่งไม่นับ
  • ในแพ็กเกจฟรี ข้อมูลของอีเวนต์หนึ่งครั้งมีได้สูงสุด 4 KB (แพ็กเกจที่เสียเงินได้มากกว่า) HibiraSync จะแบ่งชุดข้อมูลให้เล็กกว่านั้น ส่วนค่าเดี่ยวๆ เช่นสตริงยาวๆ ควรให้มีขนาดเล็ก
  • presence แชนเนลรองรับสมาชิกได้สูงสุด 100 คน เพียงพอสำหรับห้อง ถ้าเป็นพื้นที่ใหญ่กว่านั้น เช่นล็อบบี้หลายพันคน ให้ใช้แชนเนลธรรมดาคู่กับการบรอดแคสต์จากเซิร์ฟเวอร์

ต่อจากนี้

แอดออนดาวน์โหลดได้ที่ GitHub และเราส่งเข้า Godot Asset Library แล้ว ต่อไปเราอยากเพิ่มแชนเนลที่เข้ารหัสแบบต้นทางถึงปลายทาง และการลงชื่อเข้าใช้ของผู้ใช้ (pusher:signin)

ถ้าคุณกำลังทำเกมมัลติเพลเยอร์ด้วย Godot ลองใช้ดู เราอยากรู้ว่าเกมของคุณต้องการอะไรบ้าง