first

.gitignore

@@ -0,0 +1,25 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# from ide
+.vscode
+.idea
+
+# Virtual environments
+.venv
+venv
+
+# config
+settings.json
+
+# logs
+log/*
+
+cmake-build-debug
+
+

game/card.go

@@ -0,0 +1,104 @@
+package game
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+type CardDef struct {
+	TypeID   string
+	Name     string
+	MP       int
+	Priority int
+	Count    int
+	Unusable bool
+}
+
+type Card struct {
+	UID    string
+	TypeID string
+	Name   string
+	MP     int
+}
+
+var AllCardDefs = []CardDef{
+	{"student_council_president", "学生会长", 3, 4, 1, false},
+	{"class_monitor", "班长", 2, 4, 2, false},
+	{"honor_student", "优等生", 2, 4, 3, false},
+	{"discipline_committee_member", "风纪委员", 1, 4, 2, false},
+	{"library_committee_member", "图书委员", 1, 4, 3, false},
+	{"health_committee_member", "保健委员", 1, 4, 2, false},
+	{"young_lady", "大小姐", 1, 4, 3, false},
+	{"newspaper_club", "新闻部", 1, 4, 3, false},
+	{"go_home_club", "归宅部", 0, 5, 3, false},
+	{"infected_person", "感染者", 0, 2, 1, false},
+	{"accomplice", "共犯", 0, 3, 1, false},
+	{"culprit", "犯人", 0, 3, 1, true},
+	{"alien", "外星人", -1, 1, 1, false},
+}
+
+type RemoveRule struct {
+	TypeID string
+	Count  int
+}
+
+type GameSetting struct {
+	PlayerCount   int
+	HarmonyTarget int
+	RemoveCards   []RemoveRule
+	TotalCards    int
+	HandSize      int
+}
+
+var GameSettings = map[int]GameSetting{
+	3: {3, 9, []RemoveRule{
+		{"library_committee_member", 1}, {"accomplice", 1}, {"honor_student", 1},
+		{"discipline_committee_member", 1}, {"young_lady", 1}, {"newspaper_club", 1}, {"go_home_club", 1},
+	}, 18, 6},
+	4: {4, 8, []RemoveRule{{"library_committee_member", 1}}, 24, 6},
+	5: {5, 7, nil, 25, 5},
+	6: {6, 6, []RemoveRule{{"library_committee_member", 1}}, 24, 4},
+}
+
+func BuildDeck(playerCount int) ([]*Card, GameSetting) {
+	setting := GameSettings[playerCount]
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	removeCount := make(map[string]int)
+	for _, r := range setting.RemoveCards {
+		removeCount[r.TypeID] += r.Count
+	}
+
+	var deck []*Card
+	uid := 0
+	for _, def := range AllCardDefs {
+		toRemove := removeCount[def.TypeID]
+		toAdd := def.Count - toRemove
+		for i := 0; i < toAdd; i++ {
+			uid++
+			deck = append(deck, &Card{
+				UID:    fmt.Sprintf("c_%03d", uid),
+				TypeID: def.TypeID,
+				Name:   def.Name,
+				MP:     def.MP,
+			})
+		}
+	}
+
+	rng.Shuffle(len(deck), func(i, j int) { deck[i], deck[j] = deck[j], deck[i] })
+	return deck, setting
+}
+
+func IsUnusable(typeID string) bool {
+	return typeID == "culprit"
+}
+
+func GetCardDef(typeID string) *CardDef {
+	for i := range AllCardDefs {
+		if AllCardDefs[i].TypeID == typeID {
+			return &AllCardDefs[i]
+		}
+	}
+	return nil
+}

game/effects.go

@@ -0,0 +1,719 @@
+package game
+
+import "fmt"
+
+type EffectState struct {
+	Active           bool
+	CardTypeID       string
+	CasterID         string
+	Step             int
+	WaitingFor       string
+	ChoiceType       string
+	ChoiceData       map[string]interface{}
+	TempData         map[string]interface{}
+	PendingResponses map[string]interface{}
+	AllCollected     bool
+}
+
+func (e *Engine) triggerEffect(caster *PlayerState, card *Card) bool {
+	switch card.TypeID {
+	case "student_council_president", "culprit", "alien":
+		return false
+	case "library_committee_member":
+		return e.effectLibrary(caster)
+	case "discipline_committee_member":
+		return e.effectDiscipline(caster)
+	case "health_committee_member":
+		return e.effectHealth(caster)
+	case "go_home_club":
+		return e.effectGoHome(caster)
+	case "accomplice":
+		return e.effectAccomplice(caster)
+	case "class_monitor":
+		return e.effectClassMonitor(caster)
+	case "young_lady":
+		return e.effectYoungLady(caster)
+	case "newspaper_club":
+		return e.effectNewspaper(caster)
+	case "honor_student":
+		return e.effectHonorStudent(caster)
+	case "infected_person":
+		return e.effectInfected(caster)
+	}
+	return false
+}
+
+func (e *Engine) effectLibrary(caster *PlayerState) bool {
+	if len(e.HarmonyZone) == 0 {
+		return false
+	}
+	var cards []map[string]interface{}
+	for _, c := range e.HarmonyZone {
+		cards = append(cards, map[string]interface{}{
+			"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "mp": c.MP,
+		})
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "library_committee_member", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "view_cards", Step: 0,
+		ChoiceData: map[string]interface{}{"cards": cards, "message": "调和区的卡牌"},
+	}
+	return true
+}
+
+func (e *Engine) effectDiscipline(caster *PlayerState) bool {
+	var targets []map[string]interface{}
+	for _, p := range e.Players {
+		if p.ID != caster.ID && !p.IsExited && len(p.Hand) > 0 {
+			targets = append(targets, map[string]interface{}{"player_id": p.ID, "nickname": p.Nickname})
+		}
+	}
+	if len(targets) == 0 {
+		return false
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "discipline_committee_member", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "select_player", Step: 0,
+		ChoiceData: map[string]interface{}{"targets": targets, "message": "选择要查看手牌的玩家"},
+		TempData:   make(map[string]interface{}),
+	}
+	return true
+}
+
+func (e *Engine) effectHealth(caster *PlayerState) bool {
+	var cards []map[string]interface{}
+	for _, p := range e.Players {
+		for _, c := range p.SkillZone {
+			if c.TypeID != "health_committee_member" {
+				cards = append(cards, map[string]interface{}{
+					"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "owner_id": p.ID,
+				})
+			}
+		}
+	}
+	if len(cards) == 0 {
+		return false
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "health_committee_member", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "select_skill_card", Step: 0,
+		ChoiceData: map[string]interface{}{"cards": cards, "message": "选择一张已使用的牌加入手牌"},
+	}
+	return true
+}
+
+func (e *Engine) effectGoHome(caster *PlayerState) bool {
+	if len(e.HarmonyZone) == 0 || len(caster.Hand) == 0 {
+		return false
+	}
+	var handCards []map[string]interface{}
+	for _, c := range caster.Hand {
+		handCards = append(handCards, map[string]interface{}{"uid": c.UID, "type_id": c.TypeID, "name": c.Name})
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "go_home_club", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "select_card_from_hand", Step: 0,
+		ChoiceData: map[string]interface{}{"cards": handCards, "message": "选择一张手牌与调和区交换"},
+		TempData:   make(map[string]interface{}),
+	}
+	return true
+}
+
+func (e *Engine) effectAccomplice(caster *PlayerState) bool {
+	var cards []map[string]interface{}
+	for _, p := range e.Players {
+		for _, c := range p.ChallengeZone {
+			cards = append(cards, map[string]interface{}{
+				"uid": c.UID, "owner_id": p.ID,
+			})
+		}
+	}
+	if len(cards) == 0 {
+		return false
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "accomplice", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "select_challenge_card", Step: 0,
+		ChoiceData: map[string]interface{}{"cards": cards, "message": "选择一张质疑区的牌"},
+		TempData:   make(map[string]interface{}),
+	}
+	return true
+}
+
+func (e *Engine) effectClassMonitor(caster *PlayerState) bool {
+	var targets []map[string]interface{}
+	for _, p := range e.Players {
+		if !p.IsExited && len(p.Hand) > 0 {
+			targets = append(targets, map[string]interface{}{"player_id": p.ID, "nickname": p.Nickname})
+		}
+	}
+	if len(targets) < 2 {
+		return false
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "class_monitor", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "select_player", Step: 0,
+		ChoiceData: map[string]interface{}{"targets": targets, "message": "选择换牌的第一名玩家（可以是自己）"},
+		TempData:   make(map[string]interface{}),
+	}
+	return true
+}
+
+func (e *Engine) effectYoungLady(caster *PlayerState) bool {
+	var targets []map[string]interface{}
+	for _, p := range e.Players {
+		if p.ID != caster.ID && !p.IsExited && len(p.Hand) > 0 {
+			targets = append(targets, map[string]interface{}{"player_id": p.ID, "nickname": p.Nickname})
+		}
+	}
+	if len(targets) == 0 {
+		return false
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "young_lady", CasterID: caster.ID,
+		WaitingFor: caster.ID, ChoiceType: "select_player", Step: 0,
+		ChoiceData: map[string]interface{}{"targets": targets, "message": "选择一名玩家抽取手牌"},
+		TempData:   make(map[string]interface{}),
+	}
+	return true
+}
+
+func (e *Engine) effectNewspaper(caster *PlayerState) bool {
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "newspaper_club", CasterID: caster.ID,
+		ChoiceType: "all_select_card", Step: 0,
+		ChoiceData:       map[string]interface{}{"message": "选择一张手牌传给左手边的玩家"},
+		PendingResponses: make(map[string]interface{}),
+	}
+	for _, p := range e.Players {
+		if !p.IsExited && len(p.Hand) > 0 {
+			e.Effect.WaitingFor = p.ID
+		}
+	}
+	return true
+}
+
+func (e *Engine) effectHonorStudent(caster *PlayerState) bool {
+	var culpritHolder, alienHolder string
+	for _, p := range e.Players {
+		if p.ID == caster.ID {
+			continue
+		}
+		for _, c := range p.Hand {
+			if c.TypeID == "culprit" {
+				culpritHolder = p.ID
+			}
+			if c.TypeID == "alien" {
+				alienHolder = p.ID
+			}
+		}
+	}
+
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "honor_student", CasterID: caster.ID,
+		TempData: map[string]interface{}{
+			"culprit_holder": culpritHolder,
+			"alien_holder":   alienHolder,
+		},
+	}
+
+	if culpritHolder != "" {
+		cp := e.GetPlayer(culpritHolder)
+		if cp != nil && !cp.IsExited {
+			e.Effect.Step = 0
+			e.Effect.WaitingFor = culpritHolder
+			e.Effect.ChoiceType = "select_option"
+			e.Effect.ChoiceData = map[string]interface{}{
+				"message": "有人使用了优等生！你是犯人，必须吐出舌头。",
+				"options": []map[string]interface{}{
+					{"value": "long", "label": "吐长舌头"},
+					{"value": "short", "label": "吐短舌头"},
+				},
+			}
+			return true
+		}
+	}
+
+	if alienHolder != "" {
+		ap := e.GetPlayer(alienHolder)
+		if ap != nil && !ap.IsExited {
+			e.Effect.Step = 1
+			e.Effect.WaitingFor = alienHolder
+			e.Effect.ChoiceType = "select_option"
+			e.Effect.ChoiceData = map[string]interface{}{
+				"message": "有人使用了优等生！你是外星人，是否要装作犯人吐舌头？",
+				"options": []map[string]interface{}{
+					{"value": "long", "label": "吐长舌头"},
+					{"value": "short", "label": "吐短舌头"},
+					{"value": "none", "label": "不吐舌头"},
+				},
+			}
+			return true
+		}
+	}
+
+	e.Effect.Step = 99
+	e.Effect.WaitingFor = caster.ID
+	e.Effect.ChoiceType = "view_cards"
+	e.Effect.ChoiceData = map[string]interface{}{"message": "优等生效果：没有人吐舌头"}
+	return true
+}
+
+func (e *Engine) effectInfected(caster *PlayerState) bool {
+	if len(caster.Hand) <= 1 {
+		return false
+	}
+	caster.InfectedActive = true
+	return false
+}
+
+// HandleEffectResponse processes a player's response during effect resolution
+func (e *Engine) HandleEffectResponse(playerID string, response map[string]interface{}) error {
+	ef := e.Effect
+	if ef == nil || !ef.Active {
+		return fmt.Errorf("no active effect")
+	}
+
+	switch ef.CardTypeID {
+	case "library_committee_member", "student_council_president":
+		return e.finishEffect()
+	case "discipline_committee_member":
+		return e.respondDiscipline(playerID, response)
+	case "health_committee_member":
+		return e.respondHealth(playerID, response)
+	case "go_home_club":
+		return e.respondGoHome(playerID, response)
+	case "accomplice":
+		return e.respondAccomplice(playerID, response)
+	case "class_monitor":
+		return e.respondClassMonitor(playerID, response)
+	case "young_lady":
+		return e.respondYoungLady(playerID, response)
+	case "newspaper_club":
+		return e.respondNewspaper(playerID, response)
+	case "honor_student":
+		return e.respondHonorStudent(playerID, response)
+	case "infected_person":
+		return e.respondInfected(playerID, response)
+	}
+	return e.finishEffect()
+}
+
+func (e *Engine) respondDiscipline(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+	if ef.Step == 0 {
+		tid, _ := resp["player_id"].(string)
+		target := e.GetPlayer(tid)
+		if target == nil {
+			return fmt.Errorf("invalid target")
+		}
+		var cards []map[string]interface{}
+		for _, c := range target.Hand {
+			cards = append(cards, map[string]interface{}{"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "mp": c.MP})
+		}
+		ef.Step = 1
+		ef.ChoiceType = "view_cards"
+		ef.ChoiceData = map[string]interface{}{"cards": cards, "message": target.Nickname + " 的手牌"}
+		return nil
+	}
+	return e.finishEffect()
+}
+
+func (e *Engine) respondHealth(pid string, resp map[string]interface{}) error {
+	uid, _ := resp["card_uid"].(string)
+	for _, p := range e.Players {
+		for i, c := range p.SkillZone {
+			if c.UID == uid && c.TypeID != "health_committee_member" {
+				p.SkillZone = append(p.SkillZone[:i], p.SkillZone[i+1:]...)
+				caster := e.GetPlayer(e.Effect.CasterID)
+				caster.Hand = append(caster.Hand, c)
+				return e.finishEffect()
+			}
+		}
+	}
+	return fmt.Errorf("card not found")
+}
+
+func (e *Engine) respondGoHome(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+	if ef.Step == 0 {
+		uid, _ := resp["card_uid"].(string)
+		ef.TempData["hand_card_uid"] = uid
+		ef.Step = 1
+		var hCards []map[string]interface{}
+		for i, c := range e.HarmonyZone {
+			hCards = append(hCards, map[string]interface{}{"uid": c.UID, "index": i})
+		}
+		ef.ChoiceType = "select_harmony_card"
+		ef.ChoiceData = map[string]interface{}{"cards": hCards, "message": "选择调和区的一张牌"}
+		return nil
+	}
+	hUID, _ := resp["card_uid"].(string)
+	handUID, _ := ef.TempData["hand_card_uid"].(string)
+	caster := e.GetPlayer(ef.CasterID)
+
+	var handCard *Card
+	for i, c := range caster.Hand {
+		if c.UID == handUID {
+			handCard = c
+			caster.Hand = append(caster.Hand[:i], caster.Hand[i+1:]...)
+			break
+		}
+	}
+	var harmonyCard *Card
+	for i, c := range e.HarmonyZone {
+		if c.UID == hUID {
+			harmonyCard = c
+			e.HarmonyZone = append(e.HarmonyZone[:i], e.HarmonyZone[i+1:]...)
+			break
+		}
+	}
+	if handCard != nil {
+		e.HarmonyZone = append(e.HarmonyZone, handCard)
+	}
+	if harmonyCard != nil {
+		caster.Hand = append(caster.Hand, harmonyCard)
+	}
+	return e.finishEffect()
+}
+
+func (e *Engine) respondAccomplice(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+	if ef.Step == 0 {
+		uid, _ := resp["card_uid"].(string)
+		ef.TempData["challenge_uid"] = uid
+		owner, _ := resp["owner_id"].(string)
+		ef.TempData["challenge_owner"] = owner
+		ef.Step = 1
+		var targets []map[string]interface{}
+		for _, p := range e.Players {
+			if p.ID != owner {
+				targets = append(targets, map[string]interface{}{"player_id": p.ID, "nickname": p.Nickname})
+			}
+		}
+		ef.ChoiceType = "select_player"
+		ef.ChoiceData = map[string]interface{}{"targets": targets, "message": "选择转移到哪个玩家面前"}
+		return nil
+	}
+	targetID, _ := resp["player_id"].(string)
+	cUID, _ := ef.TempData["challenge_uid"].(string)
+	ownerID, _ := ef.TempData["challenge_owner"].(string)
+
+	owner := e.GetPlayer(ownerID)
+	target := e.GetPlayer(targetID)
+	if owner == nil || target == nil {
+		return e.finishEffect()
+	}
+	for i, c := range owner.ChallengeZone {
+		if c.UID == cUID {
+			owner.ChallengeZone = append(owner.ChallengeZone[:i], owner.ChallengeZone[i+1:]...)
+			target.ChallengeZone = append(target.ChallengeZone, c)
+			break
+		}
+	}
+	return e.finishEffect()
+}
+
+func (e *Engine) respondClassMonitor(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+	if ef.Step == 0 {
+		aid, _ := resp["player_id"].(string)
+		ef.TempData["player_a_id"] = aid
+		ef.Step = 1
+		var targets []map[string]interface{}
+		for _, p := range e.Players {
+			if p.ID != aid && !p.IsExited && len(p.Hand) > 0 {
+				targets = append(targets, map[string]interface{}{"player_id": p.ID, "nickname": p.Nickname})
+			}
+		}
+		ef.WaitingFor = ef.CasterID
+		ef.ChoiceType = "select_player"
+		ef.ChoiceData = map[string]interface{}{"targets": targets, "message": "选择换牌的第二名玩家"}
+		return nil
+	}
+	if ef.Step == 1 {
+		bid, _ := resp["player_id"].(string)
+		ef.TempData["player_b_id"] = bid
+		ef.Step = 2
+		aid, _ := ef.TempData["player_a_id"].(string)
+		playerA := e.GetPlayer(aid)
+		ef.WaitingFor = aid
+		var cards []map[string]interface{}
+		for _, c := range playerA.Hand {
+			cards = append(cards, map[string]interface{}{"uid": c.UID, "type_id": c.TypeID, "name": c.Name})
+		}
+		ef.ChoiceType = "select_card_from_hand"
+		ef.ChoiceData = map[string]interface{}{"cards": cards, "message": playerA.Nickname + "：选择一张手牌交给对方"}
+		return nil
+	}
+	if ef.Step == 2 {
+		uid, _ := resp["card_uid"].(string)
+		ef.TempData["card_a_uid"] = uid
+		ef.Step = 3
+		bid, _ := ef.TempData["player_b_id"].(string)
+		playerB := e.GetPlayer(bid)
+		ef.WaitingFor = bid
+		var cards []map[string]interface{}
+		for _, c := range playerB.Hand {
+			cards = append(cards, map[string]interface{}{"uid": c.UID, "type_id": c.TypeID, "name": c.Name})
+		}
+		ef.ChoiceType = "select_card_from_hand"
+		ef.ChoiceData = map[string]interface{}{"cards": cards, "message": playerB.Nickname + "：选择一张手牌交给对方"}
+		return nil
+	}
+	bUID, _ := resp["card_uid"].(string)
+	aUID, _ := ef.TempData["card_a_uid"].(string)
+	aid, _ := ef.TempData["player_a_id"].(string)
+	bid, _ := ef.TempData["player_b_id"].(string)
+	pA := e.GetPlayer(aid)
+	pB := e.GetPlayer(bid)
+	var cA, cB *Card
+	for i, c := range pA.Hand {
+		if c.UID == aUID {
+			cA = c
+			pA.Hand = append(pA.Hand[:i], pA.Hand[i+1:]...)
+			break
+		}
+	}
+	for i, c := range pB.Hand {
+		if c.UID == bUID {
+			cB = c
+			pB.Hand = append(pB.Hand[:i], pB.Hand[i+1:]...)
+			break
+		}
+	}
+	if cA != nil {
+		pB.Hand = append(pB.Hand, cA)
+	}
+	if cB != nil {
+		pA.Hand = append(pA.Hand, cB)
+	}
+	return e.finishEffect()
+}
+
+func (e *Engine) respondYoungLady(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+	caster := e.GetPlayer(ef.CasterID)
+	if ef.Step == 0 {
+		tid, _ := resp["player_id"].(string)
+		target := e.GetPlayer(tid)
+		if target == nil || len(target.Hand) == 0 {
+			return e.finishEffect()
+		}
+		drawn := target.Hand[e.rng.Intn(len(target.Hand))]
+		e.removeFromHand(target, drawn.UID)
+		caster.Hand = append(caster.Hand, drawn)
+
+		ef.TempData["target_id"] = tid
+		ef.Step = 1
+		ef.WaitingFor = ef.CasterID
+		var cards []map[string]interface{}
+		for _, c := range caster.Hand {
+			cards = append(cards, map[string]interface{}{"uid": c.UID, "type_id": c.TypeID, "name": c.Name})
+		}
+		ef.ChoiceType = "select_card_from_hand"
+		ef.ChoiceData = map[string]interface{}{
+			"cards":   cards,
+			"message": "从 " + target.Nickname + " 抽到了「" + drawn.Name + "」，选择一张手牌反面返还",
+		}
+		return nil
+	}
+	uid, _ := resp["card_uid"].(string)
+	tid, _ := ef.TempData["target_id"].(string)
+	target := e.GetPlayer(tid)
+	for i, c := range caster.Hand {
+		if c.UID == uid {
+			caster.Hand = append(caster.Hand[:i], caster.Hand[i+1:]...)
+			if target != nil {
+				target.Hand = append(target.Hand, c)
+			}
+			break
+		}
+	}
+	return e.finishEffect()
+}
+
+func (e *Engine) respondNewspaper(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+	uid, _ := resp["card_uid"].(string)
+	ef.PendingResponses[pid] = uid
+
+	allDone := true
+	for _, p := range e.Players {
+		if !p.IsExited && len(p.Hand) > 0 {
+			if _, ok := ef.PendingResponses[p.ID]; !ok {
+				allDone = false
+				break
+			}
+		}
+	}
+	if !allDone {
+		return nil
+	}
+
+	type passInfo struct {
+		from *PlayerState
+		card *Card
+	}
+	var passes []passInfo
+	activePlayers := e.getActivePlayers()
+	for _, p := range activePlayers {
+		uidStr, ok := ef.PendingResponses[p.ID].(string)
+		if !ok {
+			continue
+		}
+		for _, c := range p.Hand {
+			if c.UID == uidStr {
+				passes = append(passes, passInfo{from: p, card: c})
+				break
+			}
+		}
+	}
+
+	for _, pi := range passes {
+		e.removeFromHand(pi.from, pi.card.UID)
+	}
+	for i, pi := range passes {
+		nextIdx := (i + 1) % len(activePlayers)
+		activePlayers[nextIdx].Hand = append(activePlayers[nextIdx].Hand, pi.card)
+	}
+
+	return e.finishEffect()
+}
+
+func (e *Engine) respondHonorStudent(pid string, resp map[string]interface{}) error {
+	ef := e.Effect
+
+	if ef.Step == 0 {
+		tongue, _ := resp["value"].(string)
+		culpritID, _ := ef.TempData["culprit_holder"].(string)
+		cp := e.GetPlayer(culpritID)
+		name := culpritID
+		if cp != nil {
+			name = cp.Nickname
+		}
+		tongues := []interface{}{map[string]interface{}{"nickname": name, "tongue": tongue}}
+		ef.TempData["tongues"] = tongues
+
+		alienHolder, _ := ef.TempData["alien_holder"].(string)
+		if alienHolder != "" {
+			ap := e.GetPlayer(alienHolder)
+			if ap != nil && !ap.IsExited {
+				ef.Step = 1
+				ef.WaitingFor = alienHolder
+				ef.ChoiceType = "select_option"
+				ef.ChoiceData = map[string]interface{}{
+					"message": "有人使用了优等生！你是外星人，是否要装作犯人吐舌头？",
+					"options": []interface{}{
+						map[string]interface{}{"value": "long", "label": "吐长舌头"},
+						map[string]interface{}{"value": "short", "label": "吐短舌头"},
+						map[string]interface{}{"value": "none", "label": "不吐舌头"},
+					},
+				}
+				return nil
+			}
+		}
+		return e.showHonorResult()
+	}
+
+	if ef.Step == 1 {
+		tongue, _ := resp["value"].(string)
+		if tongue != "none" {
+			alienHolder, _ := ef.TempData["alien_holder"].(string)
+			ap := e.GetPlayer(alienHolder)
+			name := alienHolder
+			if ap != nil {
+				name = ap.Nickname
+			}
+			tongues, _ := ef.TempData["tongues"].([]interface{})
+			tongues = append(tongues, map[string]interface{}{"nickname": name, "tongue": tongue})
+			ef.TempData["tongues"] = tongues
+		}
+		return e.showHonorResult()
+	}
+
+	return e.finishEffect()
+}
+
+func (e *Engine) showHonorResult() error {
+	ef := e.Effect
+	tongues, _ := ef.TempData["tongues"].([]interface{})
+	msg := fmt.Sprintf("优等生效果：%d人吐了舌头\n", len(tongues))
+	for _, t := range tongues {
+		tm, _ := t.(map[string]interface{})
+		nick, _ := tm["nickname"].(string)
+		tongue, _ := tm["tongue"].(string)
+		label := "长舌头"
+		if tongue == "short" {
+			label = "短舌头"
+		}
+		msg += fmt.Sprintf("  • %s — %s\n", nick, label)
+	}
+	ef.Step = 99
+	ef.WaitingFor = ef.CasterID
+	ef.ChoiceType = "view_cards"
+	ef.ChoiceData = map[string]interface{}{"message": msg, "tongues": tongues}
+	return nil
+}
+
+func (e *Engine) finishEffect() error {
+	e.Effect = nil
+	caster := e.GetPlayer(e.Players[e.CurrentTurn].ID)
+	e.finishTurn(caster)
+	return nil
+}
+
+func (e *Engine) getActivePlayers() []*PlayerState {
+	var active []*PlayerState
+	for _, p := range e.Players {
+		if !p.IsExited && len(p.Hand) > 0 {
+			active = append(active, p)
+		}
+	}
+	return active
+}
+
+func (e *Engine) CheckInfectedEffect() bool {
+	p := e.CurrentPlayer()
+	if p == nil || !p.InfectedActive {
+		return false
+	}
+
+	still := false
+	for _, c := range p.SkillZone {
+		if c.TypeID == "infected_person" {
+			still = true
+			break
+		}
+	}
+	if !still || len(e.HarmonyZone) == 0 {
+		p.InfectedActive = false
+		return false
+	}
+
+	p.InfectedActive = false
+	var hCards []map[string]interface{}
+	for _, c := range e.HarmonyZone {
+		hCards = append(hCards, map[string]interface{}{"uid": c.UID})
+	}
+	e.Effect = &EffectState{
+		Active: true, CardTypeID: "infected_person", CasterID: p.ID,
+		WaitingFor: p.ID, ChoiceType: "select_harmony_card", Step: 0,
+		ChoiceData: map[string]interface{}{"cards": hCards, "message": "感染者效果：选择调和区的一张牌加入手牌"},
+	}
+	return true
+}
+
+func (e *Engine) respondInfected(pid string, resp map[string]interface{}) error {
+	uid, _ := resp["card_uid"].(string)
+	caster := e.GetPlayer(e.Effect.CasterID)
+	for i, c := range e.HarmonyZone {
+		if c.UID == uid {
+			e.HarmonyZone = append(e.HarmonyZone[:i], e.HarmonyZone[i+1:]...)
+			caster.Hand = append(caster.Hand, c)
+			break
+		}
+	}
+	e.Effect = nil
+	return nil
+}

game/engine.go

@@ -0,0 +1,349 @@
+package game
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"time"
+)
+
+type PlayerState struct {
+	ID             string
+	Nickname       string
+	IsBot          bool
+	Hand           []*Card
+	SkillZone      []*Card
+	ChallengeZone  []*Card
+	IsExited       bool
+	InfectedActive bool
+}
+
+type Engine struct {
+	Players       []*PlayerState
+	HarmonyZone   []*Card
+	CurrentTurn   int
+	Phase         string
+	TurnPhase     string
+	HarmonyTarget int
+	Setting       GameSetting
+	SelectedCard  *Card
+	SelectedBy    string
+	Effect        *EffectState
+	rng           *rand.Rand
+}
+
+func NewEngine(playerIDs []string, nicknames []string, botFlags []bool, playerCount int) *Engine {
+	e := &Engine{
+		Phase: "dealing",
+		rng:   rand.New(rand.NewSource(time.Now().UnixNano())),
+	}
+	for i, pid := range playerIDs {
+		e.Players = append(e.Players, &PlayerState{
+			ID: pid, Nickname: nicknames[i], IsBot: botFlags[i],
+		})
+	}
+	return e
+}
+
+func (e *Engine) Deal() {
+	deck, setting := BuildDeck(len(e.Players))
+	e.Setting = setting
+	e.HarmonyTarget = setting.HarmonyTarget
+	idx := 0
+	for idx < len(deck) {
+		for _, p := range e.Players {
+			if idx >= len(deck) {
+				break
+			}
+			p.Hand = append(p.Hand, deck[idx])
+			idx++
+		}
+	}
+	e.CurrentTurn = e.findStartingPlayer()
+	e.Phase = "playing"
+	e.TurnPhase = "select_card"
+	e.startTurn()
+}
+
+func (e *Engine) findStartingPlayer() int {
+	for i, p := range e.Players {
+		for _, c := range p.Hand {
+			if c.TypeID == "student_council_president" {
+				return i
+			}
+		}
+	}
+	return e.rng.Intn(len(e.Players))
+}
+
+func (e *Engine) startTurn() {
+	if e.CheckInfectedEffect() {
+		e.TurnPhase = "effect_resolving"
+	} else {
+		e.TurnPhase = "select_card"
+	}
+}
+
+func (e *Engine) CurrentPlayer() *PlayerState {
+	if e.CurrentTurn < 0 || e.CurrentTurn >= len(e.Players) {
+		return nil
+	}
+	return e.Players[e.CurrentTurn]
+}
+
+func (e *Engine) GetPlayer(id string) *PlayerState {
+	for _, p := range e.Players {
+		if p.ID == id {
+			return p
+		}
+	}
+	return nil
+}
+
+func (e *Engine) SelectCard(playerID, cardUID string) error {
+	if e.Phase != "playing" || e.TurnPhase != "select_card" {
+		return errors.New("cannot select card now")
+	}
+	cp := e.CurrentPlayer()
+	if cp == nil || cp.ID != playerID {
+		return errors.New("not your turn")
+	}
+	for _, c := range cp.Hand {
+		if c.UID == cardUID {
+			if IsUnusable(c.TypeID) {
+				return fmt.Errorf("「%s」无法被使用", c.Name)
+			}
+			e.SelectedCard = c
+			e.SelectedBy = playerID
+			e.TurnPhase = "select_action"
+			return nil
+		}
+	}
+	return errors.New("card not in hand")
+}
+
+func (e *Engine) ConfirmAction(playerID, action string, targetPlayerID string) error {
+	if e.Phase != "playing" {
+		return errors.New("not playing")
+	}
+	cp := e.CurrentPlayer()
+	if cp == nil || cp.ID != playerID {
+		return errors.New("not your turn")
+	}
+	if e.SelectedCard == nil {
+		return errors.New("no card selected")
+	}
+	switch action {
+	case "skill":
+		return e.doSkill(cp)
+	case "harmony":
+		return e.doHarmony(cp)
+	case "challenge":
+		if e.TurnPhase == "select_action" && targetPlayerID == "" {
+			e.TurnPhase = "select_target"
+			return nil
+		}
+		return e.doChallenge(cp, targetPlayerID)
+	}
+	return errors.New("unknown action")
+}
+
+func (e *Engine) doSkill(p *PlayerState) error {
+	card := e.SelectedCard
+	e.removeFromHand(p, card.UID)
+	p.SkillZone = append(p.SkillZone, card)
+	e.SelectedCard = nil
+	e.SelectedBy = ""
+
+	if e.triggerEffect(p, card) {
+		e.TurnPhase = "effect_resolving"
+		return nil
+	}
+	e.finishTurn(p)
+	return nil
+}
+
+func (e *Engine) doHarmony(p *PlayerState) error {
+	card := e.SelectedCard
+	e.removeFromHand(p, card.UID)
+	e.HarmonyZone = append(e.HarmonyZone, card)
+	e.SelectedCard = nil
+	e.SelectedBy = ""
+	e.finishTurn(p)
+	return nil
+}
+
+func (e *Engine) doChallenge(p *PlayerState, targetID string) error {
+	if targetID == "" || targetID == p.ID {
+		return errors.New("invalid challenge target")
+	}
+	target := e.GetPlayer(targetID)
+	if target == nil {
+		return errors.New("target not found")
+	}
+	card := e.SelectedCard
+	e.removeFromHand(p, card.UID)
+	target.ChallengeZone = append(target.ChallengeZone, card)
+	e.SelectedCard = nil
+	e.SelectedBy = ""
+	e.finishTurn(p)
+	return nil
+}
+
+func (e *Engine) finishTurn(p *PlayerState) {
+	if len(p.Hand) <= 1 {
+		p.IsExited = true
+	}
+	if e.allExited() {
+		e.Phase = "all_exited"
+		e.TurnPhase = ""
+		return
+	}
+	e.advanceTurn()
+	e.startTurn()
+}
+
+func (e *Engine) advanceTurn() {
+	n := len(e.Players)
+	next := (e.CurrentTurn + 1) % n
+	for i := 0; i < n; i++ {
+		if !e.Players[next].IsExited {
+			e.CurrentTurn = next
+			return
+		}
+		next = (next + 1) % n
+	}
+}
+
+func (e *Engine) allExited() bool {
+	for _, p := range e.Players {
+		if !p.IsExited {
+			return false
+		}
+	}
+	return true
+}
+
+func (e *Engine) removeFromHand(p *PlayerState, uid string) {
+	for i, c := range p.Hand {
+		if c.UID == uid {
+			p.Hand = append(p.Hand[:i], p.Hand[i+1:]...)
+			return
+		}
+	}
+}
+
+func (e *Engine) IsEffectResolving() bool {
+	return e.Effect != nil && e.Effect.Active
+}
+
+func (e *Engine) EffectNeedsResponseFrom(playerID string) bool {
+	if !e.IsEffectResolving() {
+		return false
+	}
+	ef := e.Effect
+	if ef.ChoiceType == "all_select_card" {
+		_, done := ef.PendingResponses[playerID]
+		p := e.GetPlayer(playerID)
+		return !done && p != nil && !p.IsExited && len(p.Hand) > 0
+	}
+	return ef.WaitingFor == playerID
+}
+
+func (e *Engine) BotAutoPlay(playerID string) (string, string) {
+	p := e.GetPlayer(playerID)
+	if p == nil || !p.IsBot || p.IsExited {
+		return "", ""
+	}
+	var playable []*Card
+	for _, c := range p.Hand {
+		if !IsUnusable(c.TypeID) {
+			playable = append(playable, c)
+		}
+	}
+	if len(playable) == 0 {
+		return "", ""
+	}
+	card := playable[e.rng.Intn(len(playable))]
+	e.SelectedCard = card
+	e.SelectedBy = playerID
+
+	roll := e.rng.Intn(10)
+	if roll < 4 {
+		return "harmony", ""
+	} else if roll < 7 {
+		return "skill", ""
+	} else {
+		var targets []string
+		for _, o := range e.Players {
+			if o.ID != playerID && !o.IsExited {
+				targets = append(targets, o.ID)
+			}
+		}
+		if len(targets) == 0 {
+			return "harmony", ""
+		}
+		return "challenge", targets[e.rng.Intn(len(targets))]
+	}
+}
+
+func (e *Engine) BotAutoEffectResponse(playerID string) map[string]interface{} {
+	ef := e.Effect
+	if ef == nil || !ef.Active {
+		return nil
+	}
+	p := e.GetPlayer(playerID)
+	if p == nil {
+		return nil
+	}
+
+	resp := make(map[string]interface{})
+
+	switch ef.ChoiceType {
+	case "view_cards":
+		resp["ok"] = true
+	case "select_player":
+		if targets, ok := ef.ChoiceData["targets"].([]map[string]interface{}); ok && len(targets) > 0 {
+			resp["player_id"] = targets[e.rng.Intn(len(targets))]["player_id"]
+		}
+	case "select_card_from_hand", "all_select_card":
+		if len(p.Hand) > 0 {
+			playable := p.Hand
+			var filtered []*Card
+			for _, c := range playable {
+				if !IsUnusable(c.TypeID) {
+					filtered = append(filtered, c)
+				}
+			}
+			if len(filtered) > 0 {
+				playable = filtered
+			}
+			resp["card_uid"] = playable[e.rng.Intn(len(playable))].UID
+		}
+	case "select_skill_card":
+		if cards, ok := ef.ChoiceData["cards"].([]map[string]interface{}); ok && len(cards) > 0 {
+			resp["card_uid"] = cards[e.rng.Intn(len(cards))]["uid"]
+		}
+	case "select_challenge_card":
+		if cards, ok := ef.ChoiceData["cards"].([]map[string]interface{}); ok && len(cards) > 0 {
+			c := cards[e.rng.Intn(len(cards))]
+			resp["card_uid"] = c["uid"]
+			resp["owner_id"] = c["owner_id"]
+		}
+	case "select_harmony_card":
+		if cards, ok := ef.ChoiceData["cards"].([]map[string]interface{}); ok && len(cards) > 0 {
+			resp["card_uid"] = cards[e.rng.Intn(len(cards))]["uid"]
+		}
+	case "yes_no":
+		resp["yes"] = e.rng.Intn(2) == 0
+	case "select_option":
+		if opts, ok := ef.ChoiceData["options"].([]map[string]interface{}); ok && len(opts) > 0 {
+			resp["value"] = opts[e.rng.Intn(len(opts))]["value"]
+		} else if opts2, ok := ef.ChoiceData["options"].([]interface{}); ok && len(opts2) > 0 {
+			if m, ok := opts2[e.rng.Intn(len(opts2))].(map[string]interface{}); ok {
+				resp["value"] = m["value"]
+			}
+		}
+	}
+	return resp
+}

game/settlement.go

@@ -0,0 +1,189 @@
+package game
+
+type victoryCheck struct {
+	ID       string
+	Nickname string
+	CardType string
+	CardName string
+	Priority int
+	Met      bool
+}
+
+func (e *Engine) RunSettlement() map[string]interface{} {
+	harmony := e.settleHarmony()
+	challenge := e.settleChallenge()
+	harmonyOK := harmony["success"].(bool)
+	imprisoned := challenge["imprisoned"].([]string)
+	victory := e.settleVictory(harmonyOK, imprisoned)
+	return map[string]interface{}{
+		"harmony": harmony, "challenge": challenge, "victory": victory,
+	}
+}
+
+func (e *Engine) settleHarmony() map[string]interface{} {
+	var cards []map[string]interface{}
+	total := 0
+	for _, c := range e.HarmonyZone {
+		cards = append(cards, map[string]interface{}{
+			"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "mp": c.MP,
+		})
+		total += c.MP
+	}
+	return map[string]interface{}{
+		"cards": cards, "total_mp": total, "target": e.HarmonyTarget,
+		"success": total >= e.HarmonyTarget,
+	}
+}
+
+func (e *Engine) settleChallenge() map[string]interface{} {
+	var perPlayer []map[string]interface{}
+	maxMP := 0
+	for _, p := range e.Players {
+		var cards []map[string]interface{}
+		total := 0
+		for _, c := range p.ChallengeZone {
+			eff := c.MP
+			if eff < 0 {
+				eff = 0
+			}
+			total += eff
+			cards = append(cards, map[string]interface{}{
+				"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "mp": c.MP, "effective_mp": eff,
+			})
+		}
+		perPlayer = append(perPlayer, map[string]interface{}{
+			"player_id": p.ID, "nickname": p.Nickname, "cards": cards, "total_mp": total,
+		})
+		if total > maxMP {
+			maxMP = total
+		}
+	}
+
+	allSame := true
+	for _, pp := range perPlayer {
+		if pp["total_mp"].(int) != perPlayer[0]["total_mp"].(int) {
+			allSame = false
+			break
+		}
+	}
+	var imprisoned []string
+	if !allSame && maxMP > 0 {
+		for _, pp := range perPlayer {
+			if pp["total_mp"].(int) == maxMP {
+				imprisoned = append(imprisoned, pp["player_id"].(string))
+			}
+		}
+	}
+	return map[string]interface{}{
+		"per_player": perPlayer, "max_mp": maxMP, "imprisoned": imprisoned,
+	}
+}
+
+func (e *Engine) settleVictory(harmonyOK bool, imprisoned []string) map[string]interface{} {
+	isJailed := func(pid string) bool {
+		for _, id := range imprisoned {
+			if id == pid {
+				return true
+			}
+		}
+		return false
+	}
+
+	var all []victoryCheck
+	for _, p := range e.Players {
+		if len(p.Hand) == 0 {
+			continue
+		}
+		last := p.Hand[0]
+		def := GetCardDef(last.TypeID)
+		if def == nil {
+			continue
+		}
+		all = append(all, victoryCheck{
+			ID: p.ID, Nickname: p.Nickname,
+			CardType: last.TypeID, CardName: last.Name, Priority: def.Priority,
+		})
+	}
+
+	culpritWins := false
+
+	for pri := 1; pri <= 5; pri++ {
+		var group []int
+		for i, vc := range all {
+			if vc.Priority == pri {
+				group = append(group, i)
+			}
+		}
+		if len(group) == 0 {
+			continue
+		}
+
+		for _, i := range group {
+			switch all[i].CardType {
+			case "culprit":
+				all[i].Met = !isJailed(all[i].ID)
+				if all[i].Met {
+					culpritWins = true
+				}
+			}
+		}
+		for _, i := range group {
+			switch all[i].CardType {
+			case "alien":
+				all[i].Met = isJailed(all[i].ID)
+			case "infected_person":
+				all[i].Met = !harmonyOK
+			case "accomplice":
+				all[i].Met = culpritWins
+			case "go_home_club":
+				all[i].Met = true
+			case "culprit":
+				// already set above
+			default:
+				all[i].Met = harmonyOK
+			}
+		}
+
+		anyWin := false
+		for _, i := range group {
+			if all[i].Met {
+				anyWin = true
+				break
+			}
+		}
+		if !anyWin {
+			continue
+		}
+
+		var winners []map[string]interface{}
+		for _, i := range group {
+			if all[i].Met {
+				winners = append(winners, vcToMap(all[i]))
+			}
+		}
+		return map[string]interface{}{
+			"checks": allToMaps(all), "winners": winners,
+			"winning_priority": pri, "end_type": "normal",
+		}
+	}
+
+	return map[string]interface{}{
+		"checks": allToMaps(all), "winners": []map[string]interface{}{}, "end_type": "all_dead",
+	}
+}
+
+func vcToMap(vc victoryCheck) map[string]interface{} {
+	return map[string]interface{}{
+		"player_id": vc.ID, "nickname": vc.Nickname,
+		"card_type": vc.CardType, "card_name": vc.CardName,
+		"priority": vc.Priority, "met": vc.Met,
+	}
+}
+
+func allToMaps(all []victoryCheck) []map[string]interface{} {
+	var r []map[string]interface{}
+	for _, vc := range all {
+		r = append(r, vcToMap(vc))
+	}
+	return r
+}

game/snapshot.go

@@ -0,0 +1,77 @@
+package game
+
+func (e *Engine) Snapshot(forPlayerID string) map[string]interface{} {
+	cp := e.CurrentPlayer()
+	currentTurnID := ""
+	if cp != nil {
+		currentTurnID = cp.ID
+	}
+
+	snap := map[string]interface{}{
+		"phase":          e.Phase,
+		"turn_phase":     e.TurnPhase,
+		"current_turn":   currentTurnID,
+		"your_player_id": forPlayerID,
+		"harmony_target": e.HarmonyTarget,
+	}
+
+	var players []map[string]interface{}
+	for _, p := range e.Players {
+		pi := map[string]interface{}{
+			"player_id":            p.ID,
+			"nickname":             p.Nickname,
+			"is_bot":               p.IsBot,
+			"is_exited":            p.IsExited,
+			"hand_card_count":      len(p.Hand),
+			"challenge_zone_count": len(p.ChallengeZone),
+		}
+		var skill []map[string]interface{}
+		for _, c := range p.SkillZone {
+			skill = append(skill, map[string]interface{}{
+				"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "mp": c.MP,
+			})
+		}
+		pi["skill_zone"] = skill
+		players = append(players, pi)
+	}
+	snap["players"] = players
+
+	me := e.GetPlayer(forPlayerID)
+	var hand []map[string]interface{}
+	if me != nil {
+		for _, c := range me.Hand {
+			hand = append(hand, map[string]interface{}{
+				"uid": c.UID, "type_id": c.TypeID, "name": c.Name, "mp": c.MP,
+			})
+		}
+	}
+	snap["hand_cards"] = hand
+
+	var harmony []map[string]interface{}
+	for _, c := range e.HarmonyZone {
+		harmony = append(harmony, map[string]interface{}{
+			"uid": c.UID, "face_up": false,
+		})
+	}
+	snap["harmony_zone"] = harmony
+
+	if e.Effect != nil && e.Effect.Active {
+		ef := e.Effect
+		effectInfo := map[string]interface{}{
+			"active":    true,
+			"card_type": ef.CardTypeID,
+			"caster_id": ef.CasterID,
+		}
+		if e.EffectNeedsResponseFrom(forPlayerID) {
+			effectInfo["needs_response"] = true
+			effectInfo["choice_type"] = ef.ChoiceType
+			effectInfo["choice_data"] = ef.ChoiceData
+		} else {
+			effectInfo["needs_response"] = false
+			effectInfo["waiting_message"] = "等待效果结算中..."
+		}
+		snap["effect"] = effectInfo
+	}
+
+	return snap
+}

go.mod

@@ -0,0 +1,5 @@
+module Embalming_Girl_Server
+
+go 1.22
+
+require github.com/gorilla/websocket v1.5.3

go.sum

@@ -0,0 +1,2 @@
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

handler/ws.go

@@ -0,0 +1,626 @@
+package handler
+
+import (
+	"Embalming_Girl_Server/game"
+	"Embalming_Girl_Server/room"
+	"encoding/json"
+	"log"
+	"math/rand"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool { return true },
+}
+
+type Client struct {
+	ID     string
+	RoomID string
+	Conn   *websocket.Conn
+	Send   chan []byte
+	mu     sync.Mutex
+}
+
+type Hub struct {
+	RoomMgr *room.Manager
+	clients map[string]*Client
+	engines map[string]*game.Engine
+	mu      sync.RWMutex
+}
+
+func NewHub() *Hub {
+	return &Hub{
+		RoomMgr: room.NewManager(),
+		clients: make(map[string]*Client),
+		engines: make(map[string]*game.Engine),
+	}
+}
+
+func (h *Hub) InitTestRooms() {
+	for _, n := range []int{3, 4, 5, 6} {
+		rid := "TEST" + string(rune('0'+n))
+		h.RoomMgr.CreateTestRoom(rid, n)
+		log.Printf("Test room: %s (%d players, %d bots)", rid, n, n-1)
+	}
+}
+
+func (h *Hub) ServeWS(w http.ResponseWriter, r *http.Request) {
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Println("Upgrade:", err)
+		return
+	}
+	clientID := generateClientID()
+	client := &Client{ID: clientID, Conn: conn, Send: make(chan []byte, 256)}
+	h.mu.Lock()
+	h.clients[clientID] = client
+	h.mu.Unlock()
+	log.Printf("Connected: %s", clientID)
+	go h.writePump(client)
+	go h.readPump(client)
+}
+
+func (h *Hub) readPump(c *Client) {
+	defer func() { h.removeClient(c); c.Conn.Close() }()
+	for {
+		msgType, msg, err := c.Conn.ReadMessage()
+		if err != nil {
+			break
+		}
+		if msgType == websocket.BinaryMessage {
+			h.relayAudio(c, msg)
+			continue
+		}
+		var m map[string]interface{}
+		if json.Unmarshal(msg, &m) == nil {
+			h.handleMessage(c, m)
+		}
+	}
+}
+
+func (h *Hub) writePump(c *Client) {
+	defer c.Conn.Close()
+	for data := range c.Send {
+		c.mu.Lock()
+		err := c.Conn.WriteMessage(websocket.TextMessage, data)
+		c.mu.Unlock()
+		if err != nil {
+			break
+		}
+	}
+}
+
+func (h *Hub) removeClient(c *Client) {
+	h.mu.Lock()
+	delete(h.clients, c.ID)
+	h.mu.Unlock()
+	if c.RoomID != "" {
+		h.RoomMgr.LeaveRoom(c.RoomID, c.ID)
+		rm := h.RoomMgr.GetRoom(c.RoomID)
+		if rm != nil {
+			h.broadcastRoomState(rm)
+		}
+	}
+	close(c.Send)
+	log.Printf("Disconnected: %s", c.ID)
+}
+
+func (h *Hub) handleMessage(c *Client, msg map[string]interface{}) {
+	t, _ := msg["type"].(string)
+	p, _ := msg["payload"].(map[string]interface{})
+	switch t {
+	case "create_room":
+		h.handleCreateRoom(c, p)
+	case "join_room":
+		h.handleJoinRoom(c, p)
+	case "leave_room":
+		h.handleLeaveRoom(c)
+	case "set_ready":
+		h.handleSetReady(c, p)
+	case "start_game":
+		h.handleStartGame(c)
+	case "list_rooms":
+		h.handleListRooms(c)
+	case "select_card":
+		h.handleSelectCard(c, p)
+	case "confirm_action":
+		h.handleConfirmAction(c, p)
+	case "effect_response":
+		h.handleEffectResponse(c, p)
+	case "send_chat":
+		h.handleChat(c, p)
+	case "heartbeat":
+		h.sendTo(c, "heartbeat_ack", nil)
+	}
+}
+
+// ---- Room handlers ----
+
+func (h *Hub) handleListRooms(c *Client) {
+	h.sendTo(c, "room_list", map[string]interface{}{"rooms": h.RoomMgr.ListRooms()})
+}
+
+func (h *Hub) handleCreateRoom(c *Client, p map[string]interface{}) {
+	nick, _ := p["nickname"].(string)
+	mp := 4
+	if v, ok := p["max_players"].(float64); ok {
+		mp = int(v)
+	}
+	if nick == "" {
+		nick = "Player"
+	}
+	rm := h.RoomMgr.CreateRoom(c.ID, nick, mp)
+	c.RoomID = rm.ID
+	rm.Players[c.ID].Send = c.Send
+	h.sendTo(c, "room_created", map[string]interface{}{"room_id": rm.ID})
+	h.broadcastRoomState(rm)
+}
+
+func (h *Hub) handleJoinRoom(c *Client, p map[string]interface{}) {
+	rid, _ := p["room_id"].(string)
+	nick, _ := p["nickname"].(string)
+	if nick == "" {
+		nick = "Player"
+	}
+	rm, ok := h.RoomMgr.JoinRoom(rid, c.ID, nick)
+	if !ok {
+		h.sendTo(c, "error", map[string]interface{}{"message": "Cannot join room"})
+		return
+	}
+	c.RoomID = rm.ID
+	rm.Players[c.ID].Send = c.Send
+	h.sendTo(c, "room_joined", map[string]interface{}{"room_id": rm.ID})
+	h.broadcastRoomState(rm)
+}
+
+func (h *Hub) handleLeaveRoom(c *Client) {
+	if c.RoomID == "" {
+		return
+	}
+	rid := c.RoomID
+	h.RoomMgr.LeaveRoom(rid, c.ID)
+	c.RoomID = ""
+	h.sendTo(c, "room_left", nil)
+	if rm := h.RoomMgr.GetRoom(rid); rm != nil {
+		h.broadcastRoomState(rm)
+	}
+}
+
+func (h *Hub) handleChat(c *Client, p map[string]interface{}) {
+	if c.RoomID == "" {
+		return
+	}
+	rm := h.RoomMgr.GetRoom(c.RoomID)
+	if rm == nil {
+		return
+	}
+	text, _ := p["text"].(string)
+	if text == "" {
+		return
+	}
+	nick := ""
+	if pl, ok := rm.Players[c.ID]; ok {
+		nick = pl.Nickname
+	}
+	msg := map[string]interface{}{
+		"sender_id": c.ID, "nickname": nick, "text": text,
+	}
+	for _, pid := range rm.PlayerOrder {
+		pl := rm.Players[pid]
+		if pl.IsBot || pl.Send == nil {
+			continue
+		}
+		h.sendToChannel(pl.Send, "chat", msg)
+	}
+}
+
+func (h *Hub) handleSetReady(c *Client, p map[string]interface{}) {
+	ready, _ := p["ready"].(bool)
+	if c.RoomID == "" {
+		return
+	}
+	h.RoomMgr.SetReady(c.RoomID, c.ID, ready)
+	if rm := h.RoomMgr.GetRoom(c.RoomID); rm != nil {
+		h.broadcastRoomState(rm)
+	}
+}
+
+// ---- Game start ----
+
+func (h *Hub) handleStartGame(c *Client) {
+	if c.RoomID == "" {
+		return
+	}
+	rm := h.RoomMgr.GetRoom(c.RoomID)
+	if rm == nil || !rm.Players[c.ID].IsHost {
+		h.sendTo(c, "error", map[string]interface{}{"message": "Only host can start"})
+		return
+	}
+	if len(rm.Players) < 3 {
+		h.sendTo(c, "error", map[string]interface{}{"message": "Need 3+ players"})
+		return
+	}
+
+	var ids, nicks []string
+	var bots []bool
+	for _, pid := range rm.PlayerOrder {
+		p := rm.Players[pid]
+		ids = append(ids, p.ID)
+		nicks = append(nicks, p.Nickname)
+		bots = append(bots, p.IsBot)
+	}
+
+	eng := game.NewEngine(ids, nicks, bots, len(ids))
+	eng.Deal()
+
+	h.mu.Lock()
+	h.engines[rm.ID] = eng
+	h.mu.Unlock()
+
+	rm.State = "playing"
+	rm.HarmonyTarget = eng.HarmonyTarget
+
+	for _, pid := range rm.PlayerOrder {
+		p := rm.Players[pid]
+		if p.IsBot || p.Send == nil {
+			continue
+		}
+		h.sendToChannel(p.Send, "game_start", map[string]interface{}{
+			"your_player_id": pid,
+			"harmony_target": eng.HarmonyTarget,
+			"player_count":   len(ids),
+		})
+	}
+
+	log.Printf("Game started in %s, %d players, target=%d, first=%s",
+		rm.ID, len(ids), eng.HarmonyTarget, eng.CurrentPlayer().ID)
+
+	h.broadcastSnapshots(rm.ID)
+	h.processBotTurns(rm.ID)
+}
+
+// ---- Game action handlers ----
+
+func (h *Hub) handleSelectCard(c *Client, p map[string]interface{}) {
+	h.mu.RLock()
+	eng := h.engines[c.RoomID]
+	h.mu.RUnlock()
+	if eng == nil {
+		return
+	}
+
+	uid, _ := p["card_uid"].(string)
+	if err := eng.SelectCard(c.ID, uid); err != nil {
+		h.sendTo(c, "error", map[string]interface{}{"message": err.Error()})
+		return
+	}
+	h.broadcastSnapshots(c.RoomID)
+}
+
+func (h *Hub) handleConfirmAction(c *Client, p map[string]interface{}) {
+	h.mu.RLock()
+	eng := h.engines[c.RoomID]
+	h.mu.RUnlock()
+	if eng == nil {
+		return
+	}
+
+	action, _ := p["action"].(string)
+	target, _ := p["target_player_id"].(string)
+
+	if err := eng.ConfirmAction(c.ID, action, target); err != nil {
+		h.sendTo(c, "error", map[string]interface{}{"message": err.Error()})
+		return
+	}
+
+	h.broadcastSnapshots(c.RoomID)
+
+	if eng.IsEffectResolving() {
+		h.processBotEffectResponses(c.RoomID)
+		return
+	}
+
+	if eng.Phase == "all_exited" {
+		h.handleAllExited(c.RoomID)
+		return
+	}
+
+	h.processBotTurns(c.RoomID)
+}
+
+func (h *Hub) handleEffectResponse(c *Client, p map[string]interface{}) {
+	h.mu.RLock()
+	eng := h.engines[c.RoomID]
+	h.mu.RUnlock()
+	if eng == nil || !eng.IsEffectResolving() {
+		return
+	}
+
+	if err := eng.HandleEffectResponse(c.ID, p); err != nil {
+		h.sendTo(c, "error", map[string]interface{}{"message": err.Error()})
+		return
+	}
+
+	h.broadcastSnapshots(c.RoomID)
+
+	if eng.IsEffectResolving() {
+		h.processBotEffectResponses(c.RoomID)
+		return
+	}
+
+	if eng.Phase == "all_exited" {
+		h.handleAllExited(c.RoomID)
+		return
+	}
+
+	h.processBotTurns(c.RoomID)
+}
+
+func (h *Hub) processBotEffectResponses(roomID string) {
+	h.mu.RLock()
+	eng := h.engines[roomID]
+	h.mu.RUnlock()
+	if eng == nil {
+		return
+	}
+
+	for eng.IsEffectResolving() {
+		ef := eng.Effect
+		if ef == nil {
+			break
+		}
+
+		if ef.ChoiceType == "all_select_card" {
+			anyBotLeft := false
+			for _, p := range eng.Players {
+				if p.IsBot && eng.EffectNeedsResponseFrom(p.ID) {
+					time.Sleep(200 * time.Millisecond)
+					resp := eng.BotAutoEffectResponse(p.ID)
+					if resp != nil {
+						eng.HandleEffectResponse(p.ID, resp)
+					}
+					anyBotLeft = true
+				}
+			}
+			if !anyBotLeft {
+				break
+			}
+			h.broadcastSnapshots(roomID)
+			continue
+		}
+
+		waitFor := ef.WaitingFor
+		bot := eng.GetPlayer(waitFor)
+		if bot == nil || !bot.IsBot {
+			break
+		}
+
+		time.Sleep(200 * time.Millisecond)
+		resp := eng.BotAutoEffectResponse(waitFor)
+		if resp != nil {
+			eng.HandleEffectResponse(waitFor, resp)
+		}
+		h.broadcastSnapshots(roomID)
+	}
+}
+
+func (h *Hub) processBotTurns(roomID string) {
+	h.mu.RLock()
+	eng := h.engines[roomID]
+	h.mu.RUnlock()
+	if eng == nil {
+		return
+	}
+
+	for eng.Phase == "playing" && !eng.IsEffectResolving() {
+		cp := eng.CurrentPlayer()
+		if cp == nil || !cp.IsBot {
+			break
+		}
+
+		time.Sleep(300 * time.Millisecond)
+
+		action, target := eng.BotAutoPlay(cp.ID)
+		if action == "" {
+			break
+		}
+
+		eng.ConfirmAction(cp.ID, action, target)
+		h.broadcastSnapshots(roomID)
+
+		if eng.IsEffectResolving() {
+			h.processBotEffectResponses(roomID)
+			if eng.IsEffectResolving() {
+				break
+			}
+			h.broadcastSnapshots(roomID)
+		}
+
+		if eng.Phase == "all_exited" {
+			h.handleAllExited(roomID)
+			return
+		}
+	}
+}
+
+func (h *Hub) handleAllExited(roomID string) {
+	rm := h.RoomMgr.GetRoom(roomID)
+	if rm == nil {
+		return
+	}
+	h.mu.RLock()
+	eng := h.engines[roomID]
+	h.mu.RUnlock()
+	if eng == nil {
+		return
+	}
+
+	result := eng.RunSettlement()
+	log.Printf("Settlement in room %s: %s", roomID, result["victory"].(map[string]interface{})["end_type"])
+
+	for _, pid := range rm.PlayerOrder {
+		p := rm.Players[pid]
+		if p.IsBot || p.Send == nil {
+			continue
+		}
+		h.sendToChannel(p.Send, "settlement_result", result)
+	}
+
+	endType, _ := result["victory"].(map[string]interface{})["end_type"].(string)
+	winners, _ := result["victory"].(map[string]interface{})["winners"].([]map[string]interface{})
+	var winnerNames []string
+	for _, w := range winners {
+		winnerNames = append(winnerNames, w["nickname"].(string))
+	}
+
+	endMsg := map[string]interface{}{"end_type": endType}
+	if endType == "all_dead" {
+		endMsg["message"] = "全灭结局 — 没有任何人获胜"
+	} else {
+		msg := ""
+		for i, n := range winnerNames {
+			if i > 0 {
+				msg += ", "
+			}
+			msg += n
+		}
+		endMsg["message"] = "获胜者: " + msg
+		endMsg["winners"] = winners
+	}
+
+	for _, pid := range rm.PlayerOrder {
+		p := rm.Players[pid]
+		if p.IsBot || p.Send == nil {
+			continue
+		}
+		h.sendToChannel(p.Send, "game_end", endMsg)
+	}
+
+	rm.State = "waiting"
+	for _, p := range rm.Players {
+		p.IsReady = false
+		if p.IsBot {
+			p.IsReady = true
+		}
+	}
+	h.mu.Lock()
+	delete(h.engines, roomID)
+	h.mu.Unlock()
+	h.broadcastRoomState(rm)
+}
+
+// ---- Audio relay ----
+
+func (h *Hub) relayAudio(sender *Client, pcm []byte) {
+	if sender.RoomID == "" {
+		return
+	}
+	rm := h.RoomMgr.GetRoom(sender.RoomID)
+	if rm == nil {
+		return
+	}
+
+	idBytes := []byte(sender.ID)
+	header := make([]byte, 2+len(idBytes))
+	header[0] = byte(len(idBytes) >> 8)
+	header[1] = byte(len(idBytes))
+	copy(header[2:], idBytes)
+	frame := append(header, pcm...)
+
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+	for _, pid := range rm.PlayerOrder {
+		p := rm.Players[pid]
+		if p.IsBot || pid == sender.ID {
+			continue
+		}
+		if cl, ok := h.clients[pid]; ok {
+			cl.mu.Lock()
+			cl.Conn.WriteMessage(websocket.BinaryMessage, frame)
+			cl.mu.Unlock()
+		}
+	}
+}
+
+// ---- Broadcast helpers ----
+
+func (h *Hub) broadcastSnapshots(roomID string) {
+	rm := h.RoomMgr.GetRoom(roomID)
+	if rm == nil {
+		return
+	}
+	h.mu.RLock()
+	eng := h.engines[roomID]
+	h.mu.RUnlock()
+	if eng == nil {
+		return
+	}
+
+	for _, pid := range rm.PlayerOrder {
+		p := rm.Players[pid]
+		if p.IsBot || p.Send == nil {
+			continue
+		}
+		snap := eng.Snapshot(pid)
+		data := buildMessage("state_snapshot", snap)
+		select {
+		case p.Send <- data:
+		default:
+		}
+	}
+}
+
+func (h *Hub) broadcastRoomState(rm *room.Room) {
+	players := rm.GetPlayerInfos()
+	for _, pid := range rm.PlayerOrder {
+		p, ok := rm.Players[pid]
+		if !ok || p.IsBot || p.Send == nil {
+			continue
+		}
+		st := map[string]interface{}{
+			"room_id": rm.ID, "state": rm.State,
+			"harmony_target": rm.HarmonyTarget,
+			"players":        players, "your_player_id": pid,
+		}
+		select {
+		case p.Send <- buildMessage("room_state", st):
+		default:
+		}
+	}
+}
+
+func (h *Hub) sendTo(c *Client, t string, p map[string]interface{}) {
+	select {
+	case c.Send <- buildMessage(t, p):
+	default:
+	}
+}
+
+func (h *Hub) sendToChannel(ch chan []byte, t string, p map[string]interface{}) {
+	select {
+	case ch <- buildMessage(t, p):
+	default:
+	}
+}
+
+func buildMessage(t string, p map[string]interface{}) []byte {
+	m := map[string]interface{}{"type": t}
+	if p != nil {
+		m["payload"] = p
+	}
+	d, _ := json.Marshal(m)
+	return d
+}
+
+func generateClientID() string {
+	const cs = "abcdefghijklmnopqrstuvwxyz0123456789"
+	b := make([]byte, 12)
+	for i := range b {
+		b[i] = cs[rand.Intn(len(cs))]
+	}
+	return string(b)
+}

main.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"Embalming_Girl_Server/handler"
+	"log"
+	"net/http"
+)
+
+func main() {
+	hub := handler.NewHub()
+	hub.InitTestRooms()
+
+	http.HandleFunc("/ws", hub.ServeWS)
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		w.Write([]byte("Embalming Girl Server v0.1.0"))
+	})
+
+	addr := ":8080"
+	log.Printf("Server started on %s", addr)
+	log.Printf("Test rooms: TEST3, TEST4, TEST5, TEST6")
+	if err := http.ListenAndServe(addr, nil); err != nil {
+		log.Fatal("ListenAndServe:", err)
+	}
+}

model/message.go

@@ -0,0 +1,23 @@
+package model
+
+type Message struct {
+	Type      string                 `json:"type"`
+	Seq       int                    `json:"seq,omitempty"`
+	Timestamp int64                  `json:"timestamp,omitempty"`
+	Payload   map[string]interface{} `json:"payload,omitempty"`
+}
+
+type PlayerInfo struct {
+	PlayerID string `json:"player_id"`
+	Nickname string `json:"nickname"`
+	IsReady  bool   `json:"is_ready"`
+	IsHost   bool   `json:"is_host"`
+}
+
+type RoomState struct {
+	RoomID        string       `json:"room_id"`
+	State         string       `json:"state"`
+	HarmonyTarget int          `json:"harmony_target"`
+	Players       []PlayerInfo `json:"players"`
+	YourPlayerID  string       `json:"your_player_id"`
+}

room/manager.go

@@ -0,0 +1,310 @@
+package room
+
+import (
+	"fmt"
+	"math/rand"
+	"sync"
+	"time"
+)
+
+type Player struct {
+	ID       string
+	Nickname string
+	IsReady  bool
+	IsHost   bool
+	IsBot    bool
+	Send     chan []byte
+}
+
+type Room struct {
+	ID            string
+	State         string
+	MaxPlayers    int
+	HarmonyTarget int
+	ChaosMode     bool
+	Players       map[string]*Player
+	PlayerOrder   []string
+	mu            sync.RWMutex
+}
+
+type Manager struct {
+	rooms map[string]*Room
+	mu    sync.RWMutex
+}
+
+func NewManager() *Manager {
+	return &Manager{
+		rooms: make(map[string]*Room),
+	}
+}
+
+func (m *Manager) CreateTestRoom(roomID string, playerCount int) *Room {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	rm := &Room{
+		ID:         roomID,
+		State:      "waiting",
+		MaxPlayers: playerCount,
+		Players:    make(map[string]*Player),
+	}
+
+	botNames := []string{"Bot-A", "Bot-B", "Bot-C", "Bot-D", "Bot-E"}
+	for i := 0; i < playerCount-1; i++ {
+		botID := fmt.Sprintf("bot_%s_%d", roomID, i)
+		bot := &Player{
+			ID:       botID,
+			Nickname: botNames[i%len(botNames)],
+			IsReady:  true,
+			IsBot:    true,
+			Send:     nil,
+		}
+		rm.Players[botID] = bot
+		rm.PlayerOrder = append(rm.PlayerOrder, botID)
+	}
+
+	m.rooms[roomID] = rm
+	return rm
+}
+
+func (m *Manager) CreateRoom(hostID, nickname string, maxPlayers int) *Room {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	roomID := generateRoomID()
+	room := &Room{
+		ID:         roomID,
+		State:      "waiting",
+		MaxPlayers: maxPlayers,
+		Players:    make(map[string]*Player),
+	}
+
+	host := &Player{
+		ID:       hostID,
+		Nickname: nickname,
+		IsHost:   true,
+		Send:     make(chan []byte, 256),
+	}
+	room.Players[hostID] = host
+	room.PlayerOrder = append(room.PlayerOrder, hostID)
+
+	m.rooms[roomID] = room
+	return room
+}
+
+func (m *Manager) GetRoom(roomID string) *Room {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.rooms[roomID]
+}
+
+func (m *Manager) ListRooms() []map[string]interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	var list []map[string]interface{}
+	for _, rm := range m.rooms {
+		rm.mu.RLock()
+		realCount := 0
+		totalCount := len(rm.Players)
+		for _, p := range rm.Players {
+			if !p.IsBot {
+				realCount++
+			}
+		}
+		rm.mu.RUnlock()
+		list = append(list, map[string]interface{}{
+			"room_id":      rm.ID,
+			"state":        rm.State,
+			"player_count": totalCount,
+			"real_players": realCount,
+			"max_players":  rm.MaxPlayers,
+		})
+	}
+	return list
+}
+
+func (m *Manager) JoinRoom(roomID, playerID, nickname string) (*Room, bool) {
+	m.mu.RLock()
+	room, exists := m.rooms[roomID]
+	m.mu.RUnlock()
+
+	if !exists {
+		return nil, false
+	}
+
+	room.mu.Lock()
+	defer room.mu.Unlock()
+
+	if len(room.Players) >= room.MaxPlayers {
+		return nil, false
+	}
+	if room.State != "waiting" {
+		return nil, false
+	}
+
+	player := &Player{
+		ID:       playerID,
+		Nickname: nickname,
+		Send:     make(chan []byte, 256),
+	}
+	room.Players[playerID] = player
+	room.PlayerOrder = append(room.PlayerOrder, playerID)
+
+	hasRealHost := false
+	for _, p := range room.Players {
+		if p.IsHost && !p.IsBot {
+			hasRealHost = true
+			break
+		}
+	}
+	if !hasRealHost {
+		for _, p := range room.Players {
+			p.IsHost = false
+		}
+		player.IsHost = true
+	}
+
+	return room, true
+}
+
+func (m *Manager) LeaveRoom(roomID, playerID string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	room, exists := m.rooms[roomID]
+	if !exists {
+		return
+	}
+
+	room.mu.Lock()
+	defer room.mu.Unlock()
+
+	delete(room.Players, playerID)
+
+	newOrder := make([]string, 0)
+	for _, id := range room.PlayerOrder {
+		if id != playerID {
+			newOrder = append(newOrder, id)
+		}
+	}
+	room.PlayerOrder = newOrder
+
+	realCount := 0
+	for _, p := range room.Players {
+		if !p.IsBot {
+			realCount++
+		}
+	}
+	if realCount == 0 && !isTestRoom(roomID) {
+		delete(m.rooms, roomID)
+		return
+	}
+
+	if realCount == 0 && isTestRoom(roomID) {
+		for _, p := range room.Players {
+			p.IsHost = false
+		}
+		room.State = "waiting"
+		return
+	}
+
+	hasHost := false
+	for _, p := range room.Players {
+		if p.IsHost && !p.IsBot {
+			hasHost = true
+			break
+		}
+	}
+	if !hasHost {
+		for _, p := range room.Players {
+			p.IsHost = false
+		}
+		for _, id := range room.PlayerOrder {
+			p := room.Players[id]
+			if !p.IsBot {
+				p.IsHost = true
+				break
+			}
+		}
+	}
+}
+
+func isTestRoom(roomID string) bool {
+	return roomID == "TEST3" || roomID == "TEST4" || roomID == "TEST5" || roomID == "TEST6"
+}
+
+func (m *Manager) SetReady(roomID, playerID string, ready bool) bool {
+	room := m.GetRoom(roomID)
+	if room == nil {
+		return false
+	}
+	room.mu.Lock()
+	defer room.mu.Unlock()
+	p, exists := room.Players[playerID]
+	if !exists {
+		return false
+	}
+	p.IsReady = ready
+	return true
+}
+
+func (r *Room) GetPlayerInfos() []map[string]interface{} {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var infos []map[string]interface{}
+	for _, id := range r.PlayerOrder {
+		p, ok := r.Players[id]
+		if !ok {
+			continue
+		}
+		infos = append(infos, map[string]interface{}{
+			"player_id": p.ID,
+			"nickname":  p.Nickname,
+			"is_ready":  p.IsReady,
+			"is_host":   p.IsHost,
+			"is_bot":    p.IsBot,
+		})
+	}
+	return infos
+}
+
+func (r *Room) BroadcastToReal(data []byte) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	for _, p := range r.Players {
+		if p.IsBot || p.Send == nil {
+			continue
+		}
+		select {
+		case p.Send <- data:
+		default:
+		}
+	}
+}
+
+func (r *Room) SendToPlayer(playerID string, data []byte) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	p, ok := r.Players[playerID]
+	if !ok || p.IsBot || p.Send == nil {
+		return
+	}
+	select {
+	case p.Send <- data:
+	default:
+	}
+}
+
+func generateRoomID() string {
+	src := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(src)
+	const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	b := make([]byte, 6)
+	for i := range b {
+		b[i] = charset[r.Intn(len(charset))]
+	}
+	return string(b)
+}