bel
/
out
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use codename.Consumed instead of kills to know whether codename is available for murdering

main
Bel LaPointe 2024-12-15 18:36:19 -07:00
parent 15078a626d
commit 4abac89472
5 changed files with 36 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
cmd/server/games.go
View File

@ -187,7 +187,7 @@ type (
} }
KillWords struct { KillWords struct {
Codename KillWord Codename Codename
Assigned time.Time Assigned time.Time
Assignee string Assignee string
@ -195,6 +195,11 @@ type (
Assignment Assignment Assignment Assignment
} }
Codename struct {
KillWord KillWord
Consumed bool
}
Assignment struct { Assignment struct {
Public []KillWord Public []KillWord
Private []KillWord Private []KillWord
@ -478,7 +483,7 @@ func (games Games) CreateEventGameReset(ctx context.Context, gid string) error {
} }
func (words KillWords) Empty() bool { func (words KillWords) Empty() bool {
return words.Codename == (KillWord{}) && words.Assigned.IsZero() && words.Assignee == "" && words.Assignment.Empty() return words.Codename == (Codename{}) && words.Assigned.IsZero() && words.Assignee == "" && words.Assignment.Empty()
} }
func (words KillWords) Privates() []KillWord { func (words KillWords) Privates() []KillWord {
@ -607,8 +612,8 @@ func (m AllKillWords) fillKillWords(
result := maps.Clone(m) result := maps.Clone(m)
m = result m = result
for k, v := range m { for k, v := range m {
if v.Codename.Word == "" { if v.Codename.KillWord.Word == "" {
v.Codename = KillWord{Word: m.unusedCodename(poolCodename), Points: 200} v.Codename = Codename{KillWord: KillWord{Word: m.unusedCodename(poolCodename), Points: 200}}
m[k] = v m[k] = v
} }
if len(v.Assignment.Public) == 0 { if len(v.Assignment.Public) == 0 {
@ -633,7 +638,7 @@ func (m AllKillWords) unusedCodename(pool []string) string {
inUse := func() []string { inUse := func() []string {
result := []string{} result := []string{}
for _, killWords := range m { for _, killWords := range m {
result = append(result, killWords.Codename.Word) result = append(result, killWords.Codename.KillWord.Word)
} }
return result return result
} }

32
cmd/server/games_test.go
View File

@ -128,7 +128,7 @@ func TestGames(t *testing.T) {
if v.Players[p].Points() != 0 { if v.Players[p].Points() != 0 {
t.Error("nonzero points after zero kills:", v.Players[p].Points()) t.Error("nonzero points after zero kills:", v.Players[p].Points())
} }
if v.Players[p].KillWords.Codename.Word == "" { if v.Players[p].KillWords.Codename.KillWord.Word == "" {
t.Error(p, "no killwords.Codename") t.Error(p, "no killwords.Codename")
} else if v.Players[p].KillWords.Assigned.IsZero() { } else if v.Players[p].KillWords.Assigned.IsZero() {
t.Error(p, "no killwords.assigned") t.Error(p, "no killwords.assigned")
@ -199,10 +199,10 @@ func TestParseEvent(t *testing.T) {
}, },
AllKillWords: map[string]KillWords{ AllKillWords: map[string]KillWords{
"x": KillWords{ "x": KillWords{
Codename: KillWord{ Codename: Codename{KillWord: KillWord{
Word: "a", Word: "a",
Points: 200, Points: 200,
}, }},
Assignee: "z", Assignee: "z",
Assigned: now, Assigned: now,
Assignment: Assignment{ Assignment: Assignment{
@ -260,48 +260,48 @@ func TestAllKillWordsFill(t *testing.T) {
}{ }{
"full": { "full": {
given: KillWords{ given: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
expect: KillWords{ expect: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
}, },
"no ass": { "no ass": {
given: KillWords{ given: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: Assignment{}, Assignment: Assignment{},
}, },
expect: KillWords{ expect: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("filled-public", "filled-private"), Assignment: ass("filled-public", "filled-private"),
}, },
}, },
"no pub": { "no pub": {
given: KillWords{ given: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("", "pri"), Assignment: ass("", "pri"),
}, },
expect: KillWords{ expect: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("filled-public", "pri"), Assignment: ass("filled-public", "pri"),
}, },
}, },
"no pri": { "no pri": {
given: KillWords{ given: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", ""), Assignment: ass("pub", ""),
}, },
expect: KillWords{ expect: KillWords{
Codename: kw(200, "global"), Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", "filled-private"), Assignment: ass("pub", "filled-private"),
}, },
}, },
"empty": { "empty": {
given: KillWords{}, given: KillWords{},
expect: KillWords{ expect: KillWords{
Codename: kw(200, "filled-global"), Codename: Codename{KillWord: kw(200, "filled-global")},
Assignment: ass("filled-public", "filled-private"), Assignment: ass("filled-public", "filled-private"),
}, },
}, },
@ -310,7 +310,7 @@ func TestAllKillWordsFill(t *testing.T) {
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
expect: KillWords{ expect: KillWords{
Codename: kw(200, "filled-global"), Codename: Codename{KillWord: kw(200, "filled-global")},
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
}, },
@ -363,7 +363,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Run("private", func(t *testing.T) { t.Run("private", func(t *testing.T) {
akw := make(AllKillWords) akw := make(AllKillWords)
akw["k"] = KillWords{ akw["k"] = KillWords{
Codename: KillWord{Word: "x"}, Codename: Codename{KillWord: KillWord{Word: "x"}},
Assignment: Assignment{ Assignment: Assignment{
Private: []KillWord{{}, {Word: "y"}}, Private: []KillWord{{}, {Word: "y"}},
Public: []KillWord{{}, {Word: "x"}}, Public: []KillWord{{}, {Word: "x"}},
@ -377,7 +377,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Run("global", func(t *testing.T) { t.Run("global", func(t *testing.T) {
akw := make(AllKillWords) akw := make(AllKillWords)
akw["k"] = KillWords{ akw["k"] = KillWords{
Codename: KillWord{Word: "y"}, Codename: Codename{KillWord: KillWord{Word: "y"}},
Assignment: Assignment{ Assignment: Assignment{
Private: []KillWord{{}, {Word: "x"}}, Private: []KillWord{{}, {Word: "x"}},
Public: []KillWord{{}, {Word: "x"}}, Public: []KillWord{{}, {Word: "x"}},
@ -391,7 +391,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Run("public", func(t *testing.T) { t.Run("public", func(t *testing.T) {
akw := make(AllKillWords) akw := make(AllKillWords)
akw["k"] = KillWords{ akw["k"] = KillWords{
Codename: KillWord{Word: "x"}, Codename: Codename{KillWord: KillWord{Word: "x"}},
Assignment: Assignment{ Assignment: Assignment{
Private: []KillWord{{}, {Word: "x"}}, Private: []KillWord{{}, {Word: "x"}},
Public: []KillWord{{}, {Word: "y"}}, Public: []KillWord{{}, {Word: "y"}},

4
cmd/server/usergameserver.go
View File

@ -95,7 +95,7 @@ func (ugs *UserGameServer) listen(ctx context.Context, reader func(context.Conte
var points int var points int
if gameState, err := ugs.games.GameState(ctx, ugs.ID); err != nil { if gameState, err := ugs.games.GameState(ctx, ugs.ID); err != nil {
return err return err
} else if codename := gameState.Players[killer].KillWords.Codename; codename.Word == word { } else if codename := gameState.Players[killer].KillWords.Codename.KillWord; codename.Word == word {
points = codename.Points points = codename.Points
} else if matches := slices.DeleteFunc(gameState.Players[victim].KillWords.Publics(), func(kw KillWord) bool { return kw.Word != word }); len(matches) > 0 { } else if matches := slices.DeleteFunc(gameState.Players[victim].KillWords.Publics(), func(kw KillWord) bool { return kw.Word != word }); len(matches) > 0 {
points = matches[0].Points points = matches[0].Points
@ -151,7 +151,7 @@ func (ugs *UserGameServer) State(ctx context.Context) (UserGameState, error) {
if isSelf := k == ugs.Session.ID; isSelf { if isSelf := k == ugs.Session.ID; isSelf {
v.KillWords.Assignment = Assignment{} v.KillWords.Assignment = Assignment{}
} else { } else {
v.KillWords.Codename = KillWord{} v.KillWords.Codename = Codename{}
v.KillWords.Assignee = "" v.KillWords.Assignee = ""
for i := range v.Kills { for i := range v.Kills {
v.Kills[i].Victim = "" v.Kills[i].Victim = ""

12
cmd/server/usergameserver_test.go
View File

@ -83,7 +83,7 @@ func TestUserGameServer(t *testing.T) {
} }
if isSelf := pid == ugs.Session.ID; isSelf { if isSelf := pid == ugs.Session.ID; isSelf {
if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 { if p.KillWords.Codename.KillWord.Word == "" || p.KillWords.Codename.KillWord.Points == 0 {
t.Error("self codename missing field") t.Error("self codename missing field")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
@ -96,7 +96,7 @@ func TestUserGameServer(t *testing.T) {
t.Error("self knows its own private") t.Error("self knows its own private")
} }
} else { } else {
if !p.KillWords.Codename.Empty() { if !p.KillWords.Codename.KillWord.Empty() {
t.Error("can see not self Codename") t.Error("can see not self Codename")
} }
if p.KillWords.Assignee != "" { if p.KillWords.Assignee != "" {
@ -167,7 +167,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.Word == "" { } else if kill.KillWord.Word == "" {
t.Errorf("dont know own kill word") t.Errorf("dont know own kill word")
} }
if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 { if p.KillWords.Codename.KillWord.Word == "" || p.KillWords.Codename.KillWord.Points == 0 {
t.Error("self Codename missing field") t.Error("self Codename missing field")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
@ -190,7 +190,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.Word != "" { } else if kill.KillWord.Word != "" {
t.Errorf("know other's kill word") t.Errorf("know other's kill word")
} }
if !p.KillWords.Codename.Empty() { if !p.KillWords.Codename.KillWord.Empty() {
t.Error("can see not self Codename") t.Error("can see not self Codename")
} }
if p.KillWords.Assignee != "" { if p.KillWords.Assignee != "" {
@ -248,7 +248,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.Word == "" { } else if kill.KillWord.Word == "" {
t.Errorf("dont know own kill word") t.Errorf("dont know own kill word")
} }
if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 { if p.KillWords.Codename.KillWord.Word == "" || p.KillWords.Codename.KillWord.Points == 0 {
t.Error("self Codename missing field") t.Error("self Codename missing field")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
@ -271,7 +271,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.Word == "" { } else if kill.KillWord.Word == "" {
t.Errorf("dont know other's kill word") t.Errorf("dont know other's kill word")
} }
if p.KillWords.Codename.Empty() { if p.KillWords.Codename.KillWord.Empty() {
t.Error("cannot see not self Codename") t.Error("cannot see not self Codename")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {

6
cmd/server/ws.go
View File

@ -191,10 +191,8 @@ func (ws WS) inProgressMsgItem(ctx context.Context, ugs *UserGameServer, gameSta
tags := []inProgressMsgItemTag{} tags := []inProgressMsgItemTag{}
if hasBeenKilledWithCodename := slices.ContainsFunc(self.Kills, func(a Kill) bool { if canKillWithCodename := !self.KillWords.Codename.Consumed; canKillWithCodename {
return a.Victim == uid && a.KillWord.Word == self.KillWords.Codename.Word tags = append(tags, newInProgressMsgItemTag(self.KillWords.Codename.KillWord))
}); !hasBeenKilledWithCodename {
tags = append(tags, newInProgressMsgItemTag(self.KillWords.Codename))
} }
for _, killWord := range append( for _, killWord := range append(