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

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

Source: https://hibira.io/th/blog/godot-multiplayer-without-a-server
Updated: 2026-11-17

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

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

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

![ห้องเดียวกัน ทางซ้ายเป็นผู้เล่นบน Godot ทางขวาเป็นผู้เล่นบนเบราว์เซอร์](https://hibira.io/portal/articles/godot-lobby-crossplay-th.webp)

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

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

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

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

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

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

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

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

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

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

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

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

- **`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` แล้วสร้างผู้เล่นแต่ละคนแบบนี้

```gdscript
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 ครั้งไปใช้ตรงๆ ตัวละครจะกระโดดเป็นช่วงๆ จึงใช้ค่าที่ได้รับเป็นเป้าหมาย แล้วให้ตัวละครขยับเข้าใกล้ทีละนิดทุกเฟรม มีการประมาณค่าที่เหมาะกับมุมและควอเทอร์เนียนด้วย

```text
sequence: สิ่งที่เกิดขึ้นในหนึ่ง tick
เกมของผู้เล่น A | *Hibira | เกมของผู้เล่น B
1 > 2: client-hibira-sync | {"s": {"A/Player": {"position": [...]}}}
2 > 3: อีเวนต์เดิม | พร้อม user_id: "A"
note: ผู้เล่น B ตรวจว่า user_id เป็นเจ้าของโหนด แล้วจึงขยับตัวละครไปตำแหน่งใหม่อย่างนุ่มนวล
```

![Playground: หน้าต่างเบราว์เซอร์สองหน้าต่างในห้องเดียวกัน ต่างฝ่ายต่างควบคุมจุดของตัวเอง และจุดของอีกฝั่งจะตามมาอย่างนุ่มนวล](https://hibira.io/portal/articles/godot-playground-th.mp4)

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

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

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

อยากลองในเบราว์เซอร์ทันที เปิด [playground ออนไลน์](https://demos.hibira.io/godot/) ได้เลย เป็นฉากเดียวกันที่ส่งออกสำหรับเว็บ ส่งลิงก์ที่มีรหัสห้องให้เพื่อน เพื่อนก็จะเข้ามาอยู่ห้องเดียวกัน แต่ละหน้าต่างของ 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` ที่เชื่อมต่อเองตอนเกมเริ่ม และทุกสคริปต์เรียกใช้ได้ทันที

```gdscript
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! แล้วกดก่อน"

![รายการห้อง: สร้างห้อง หรือใช้รหัสเข้าห้องของเพื่อน](https://hibira.io/portal/articles/godot-lobby-rooms-th.webp)

![ในเกม: เมื่อหัวห้องกดเริ่ม การแตะแต่ละครั้งคือ client อีเวนต์หนึ่งครั้งบนแชนเนลของห้อง](https://hibira.io/portal/articles/godot-lobby-game-th.webp)

เกมนี้ใช้อีเวนต์ชุดเดียวกับตัวอย่างล็อบบี้บนเว็บของเรา ผู้เล่นบน Godot และบนเบราว์เซอร์จึงเล่นด้วยกันได้ ซอร์สโค้ดทั้งหมดอยู่ที่ [examples/godot-lobby](https://github.com/hibira-io/examples/tree/main/godot-lobby)

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

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

## ต่อจากนี้

แอดออนดาวน์โหลดได้ที่ [GitHub](https://github.com/hibira-io/godot/releases) และเราส่งเข้า Godot Asset Library แล้ว ต่อไปเราอยากเพิ่มแชนเนลที่เข้ารหัสแบบต้นทางถึงปลายทาง และการลงชื่อเข้าใช้ของผู้ใช้ (`pusher:signin`)

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