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 {
Codename KillWord
Codename Codename
Assigned time.Time
Assignee string
@ -195,6 +195,11 @@ type (
Assignment Assignment
}
Codename struct {
KillWord KillWord
Consumed bool
}
Assignment struct {
Public []KillWord
Private []KillWord
@ -478,7 +483,7 @@ func (games Games) CreateEventGameReset(ctx context.Context, gid string) error {
}
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 {
@ -607,8 +612,8 @@ func (m AllKillWords) fillKillWords(
result := maps.Clone(m)
m = result
for k, v := range m {
if v.Codename.Word == "" {
v.Codename = KillWord{Word: m.unusedCodename(poolCodename), Points: 200}
if v.Codename.KillWord.Word == "" {
v.Codename = Codename{KillWord: KillWord{Word: m.unusedCodename(poolCodename), Points: 200}}
m[k] = v
}
if len(v.Assignment.Public) == 0 {
@ -633,7 +638,7 @@ func (m AllKillWords) unusedCodename(pool []string) string {
inUse := func() []string {
result := []string{}
for _, killWords := range m {
result = append(result, killWords.Codename.Word)
result = append(result, killWords.Codename.KillWord.Word)
}
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 {
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")
} else if v.Players[p].KillWords.Assigned.IsZero() {
t.Error(p, "no killwords.assigned")
@ -199,10 +199,10 @@ func TestParseEvent(t *testing.T) {
},
AllKillWords: map[string]KillWords{
"x": KillWords{
Codename: KillWord{
Codename: Codename{KillWord: KillWord{
Word: "a",
Points: 200,
},
}},
Assignee: "z",
Assigned: now,
Assignment: Assignment{
@ -260,48 +260,48 @@ func TestAllKillWordsFill(t *testing.T) {
}{
"full": {
given: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", "pri"),
},
expect: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", "pri"),
},
},
"no ass": {
given: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: Assignment{},
},
expect: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("filled-public", "filled-private"),
},
},
"no pub": {
given: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("", "pri"),
},
expect: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("filled-public", "pri"),
},
},
"no pri": {
given: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", ""),
},
expect: KillWords{
Codename: kw(200, "global"),
Codename: Codename{KillWord: kw(200, "global")},
Assignment: ass("pub", "filled-private"),
},
},
"empty": {
given: KillWords{},
expect: KillWords{
Codename: kw(200, "filled-global"),
Codename: Codename{KillWord: kw(200, "filled-global")},
Assignment: ass("filled-public", "filled-private"),
},
},
@ -310,7 +310,7 @@ func TestAllKillWordsFill(t *testing.T) {
Assignment: ass("pub", "pri"),
},
expect: KillWords{
Codename: kw(200, "filled-global"),
Codename: Codename{KillWord: kw(200, "filled-global")},
Assignment: ass("pub", "pri"),
},
},
@ -363,7 +363,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Run("private", func(t *testing.T) {
akw := make(AllKillWords)
akw["k"] = KillWords{
Codename: KillWord{Word: "x"},
Codename: Codename{KillWord: KillWord{Word: "x"}},
Assignment: Assignment{
Private: []KillWord{{}, {Word: "y"}},
Public: []KillWord{{}, {Word: "x"}},
@ -377,7 +377,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Run("global", func(t *testing.T) {
akw := make(AllKillWords)
akw["k"] = KillWords{
Codename: KillWord{Word: "y"},
Codename: Codename{KillWord: KillWord{Word: "y"}},
Assignment: Assignment{
Private: []KillWord{{}, {Word: "x"}},
Public: []KillWord{{}, {Word: "x"}},
@ -391,7 +391,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Run("public", func(t *testing.T) {
akw := make(AllKillWords)
akw["k"] = KillWords{
Codename: KillWord{Word: "x"},
Codename: Codename{KillWord: KillWord{Word: "x"}},
Assignment: Assignment{
Private: []KillWord{{}, {Word: "x"}},
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
if gameState, err := ugs.games.GameState(ctx, ugs.ID); err != nil {
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
} 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
@ -151,7 +151,7 @@ func (ugs *UserGameServer) State(ctx context.Context) (UserGameState, error) {
if isSelf := k == ugs.Session.ID; isSelf {
v.KillWords.Assignment = Assignment{}
} else {
v.KillWords.Codename = KillWord{}
v.KillWords.Codename = Codename{}
v.KillWords.Assignee = ""
for i := range v.Kills {
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 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")
}
if p.KillWords.Assignee == "" {
@ -96,7 +96,7 @@ func TestUserGameServer(t *testing.T) {
t.Error("self knows its own private")
}
} else {
if !p.KillWords.Codename.Empty() {
if !p.KillWords.Codename.KillWord.Empty() {
t.Error("can see not self Codename")
}
if p.KillWords.Assignee != "" {
@ -167,7 +167,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.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")
}
if p.KillWords.Assignee == "" {
@ -190,7 +190,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.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")
}
if p.KillWords.Assignee != "" {
@ -248,7 +248,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.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")
}
if p.KillWords.Assignee == "" {
@ -271,7 +271,7 @@ func TestUserGameServer(t *testing.T) {
} else if kill.KillWord.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")
}
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{}
if hasBeenKilledWithCodename := slices.ContainsFunc(self.Kills, func(a Kill) bool {
return a.Victim == uid && a.KillWord.Word == self.KillWords.Codename.Word
}); !hasBeenKilledWithCodename {
tags = append(tags, newInProgressMsgItemTag(self.KillWords.Codename))
if canKillWithCodename := !self.KillWords.Codename.Consumed; canKillWithCodename {
tags = append(tags, newInProgressMsgItemTag(self.KillWords.Codename.KillWord))
}
for _, killWord := range append(