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

Global-1 to Codename+200

main
Bel LaPointe 2024-12-15 18:25:47 -07:00
parent 02dc21c124
commit 15078a626d
5 changed files with 46 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
cmd/server/games.go
View File

@ -187,7 +187,7 @@ type (
} }
KillWords struct { KillWords struct {
Global KillWord Codename KillWord
Assigned time.Time Assigned time.Time
Assignee string Assignee string
@ -478,7 +478,7 @@ func (games Games) CreateEventGameReset(ctx context.Context, gid string) error {
} }
func (words KillWords) Empty() bool { func (words KillWords) Empty() bool {
return words.Global == (KillWord{}) && words.Assigned.IsZero() && words.Assignee == "" && words.Assignment.Empty() return words.Codename == (KillWord{}) && words.Assigned.IsZero() && words.Assignee == "" && words.Assignment.Empty()
} }
func (words KillWords) Privates() []KillWord { func (words KillWords) Privates() []KillWord {
@ -549,7 +549,7 @@ func (m AllKillWords) withoutAssignees() AllKillWords {
result := make(AllKillWords) result := make(AllKillWords)
for k := range m { for k := range m {
result[k] = KillWords{ result[k] = KillWords{
Global: m[k].Global, Codename: m[k].Codename,
Assigned: now, Assigned: now,
Assignee: "", Assignee: "",
Assignment: m[k].Assignment, Assignment: m[k].Assignment,
@ -598,7 +598,7 @@ func (m AllKillWords) FillKillWords() AllKillWords {
} }
func (m AllKillWords) fillKillWords( func (m AllKillWords) fillKillWords(
poolGlobal []string, poolCodename []string,
nPublic int, nPublic int,
poolPublic []string, poolPublic []string,
nPrivate int, nPrivate int,
@ -607,8 +607,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.Global.Word == "" { if v.Codename.Word == "" {
v.Global = KillWord{Word: m.unusedGlobal(poolGlobal), Points: -1} v.Codename = 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 {
@ -629,11 +629,11 @@ func (m AllKillWords) fillKillWords(
return m return m
} }
func (m AllKillWords) unusedGlobal(pool []string) string { 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.Global.Word) result = append(result, killWords.Codename.Word)
} }
return result return result
} }

38
cmd/server/games_test.go
View File

@ -128,8 +128,8 @@ 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.Global.Word == "" { if v.Players[p].KillWords.Codename.Word == "" {
t.Error(p, "no killwords.global") 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")
} else if v.Players[p].KillWords.Assignee == "" { } else if v.Players[p].KillWords.Assignee == "" {
@ -199,9 +199,9 @@ func TestParseEvent(t *testing.T) {
}, },
AllKillWords: map[string]KillWords{ AllKillWords: map[string]KillWords{
"x": KillWords{ "x": KillWords{
Global: KillWord{ Codename: KillWord{
Word: "a", Word: "a",
Points: -1, Points: 200,
}, },
Assignee: "z", Assignee: "z",
Assigned: now, Assigned: now,
@ -260,48 +260,48 @@ func TestAllKillWordsFill(t *testing.T) {
}{ }{
"full": { "full": {
given: KillWords{ given: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
expect: KillWords{ expect: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
}, },
"no ass": { "no ass": {
given: KillWords{ given: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: Assignment{}, Assignment: Assignment{},
}, },
expect: KillWords{ expect: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("filled-public", "filled-private"), Assignment: ass("filled-public", "filled-private"),
}, },
}, },
"no pub": { "no pub": {
given: KillWords{ given: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("", "pri"), Assignment: ass("", "pri"),
}, },
expect: KillWords{ expect: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("filled-public", "pri"), Assignment: ass("filled-public", "pri"),
}, },
}, },
"no pri": { "no pri": {
given: KillWords{ given: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("pub", ""), Assignment: ass("pub", ""),
}, },
expect: KillWords{ expect: KillWords{
Global: kw(-1, "global"), Codename: kw(200, "global"),
Assignment: ass("pub", "filled-private"), Assignment: ass("pub", "filled-private"),
}, },
}, },
"empty": { "empty": {
given: KillWords{}, given: KillWords{},
expect: KillWords{ expect: KillWords{
Global: kw(-1, "filled-global"), Codename: 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{
Global: kw(-1, "filled-global"), Codename: kw(200, "filled-global"),
Assignment: ass("pub", "pri"), Assignment: ass("pub", "pri"),
}, },
}, },
@ -354,7 +354,7 @@ func TestAllKillWordsUnused(t *testing.T) {
t.Error("empty playerbase didnt think only option was unused") t.Error("empty playerbase didnt think only option was unused")
} }
if got := akw.unusedGlobal([]string{"x"}); got != "x" { if got := akw.unusedCodename([]string{"x"}); got != "x" {
t.Error("empty playerbase didnt think only option was unused") t.Error("empty playerbase didnt think only option was unused")
} }
}) })
@ -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{
Global: KillWord{Word: "x"}, Codename: KillWord{Word: "x"},
Assignment: Assignment{ Assignment: Assignment{
Private: []KillWord{{}, {Word: "y"}}, Private: []KillWord{{}, {Word: "y"}},
Public: []KillWord{{}, {Word: "x"}}, Public: []KillWord{{}, {Word: "x"}},
@ -377,13 +377,13 @@ 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{
Global: KillWord{Word: "y"}, Codename: KillWord{Word: "y"},
Assignment: Assignment{ Assignment: Assignment{
Private: []KillWord{{}, {Word: "x"}}, Private: []KillWord{{}, {Word: "x"}},
Public: []KillWord{{}, {Word: "x"}}, Public: []KillWord{{}, {Word: "x"}},
}, },
} }
got := akw.unusedGlobal([]string{"x", "y"}) got := akw.unusedCodename([]string{"x", "y"})
if got != "x" { if got != "x" {
t.Error("didnt return only unused option") t.Error("didnt return only unused option")
} }
@ -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{
Global: KillWord{Word: "x"}, Codename: KillWord{Word: "x"},
Assignment: Assignment{ Assignment: Assignment{
Private: []KillWord{{}, {Word: "x"}}, Private: []KillWord{{}, {Word: "x"}},
Public: []KillWord{{}, {Word: "y"}}, Public: []KillWord{{}, {Word: "y"}},

6
cmd/server/usergameserver.go
View File

@ -95,8 +95,8 @@ 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 global := gameState.Players[killer].KillWords.Global; global.Word == word { } else if codename := gameState.Players[killer].KillWords.Codename; codename.Word == word {
points = global.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
} else if matches := slices.DeleteFunc(gameState.Players[victim].KillWords.Privates(), func(kw KillWord) bool { return kw.Word != word }); len(matches) > 0 { } else if matches := slices.DeleteFunc(gameState.Players[victim].KillWords.Privates(), func(kw KillWord) bool { return kw.Word != word }); len(matches) > 0 {
@ -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.Global = KillWord{} v.KillWords.Codename = KillWord{}
v.KillWords.Assignee = "" v.KillWords.Assignee = ""
for i := range v.Kills { for i := range v.Kills {
v.Kills[i].Victim = "" v.Kills[i].Victim = ""

24
cmd/server/usergameserver_test.go
View File

@ -83,8 +83,8 @@ func TestUserGameServer(t *testing.T) {
} }
if isSelf := pid == ugs.Session.ID; isSelf { if isSelf := pid == ugs.Session.ID; isSelf {
if p.KillWords.Global.Word == "" || p.KillWords.Global.Points == 0 { if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 {
t.Error("self global missing field") t.Error("self codename missing field")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
t.Error("assignee is empty") t.Error("assignee is empty")
@ -96,8 +96,8 @@ func TestUserGameServer(t *testing.T) {
t.Error("self knows its own private") t.Error("self knows its own private")
} }
} else { } else {
if !p.KillWords.Global.Empty() { if !p.KillWords.Codename.Empty() {
t.Error("can see not self global") t.Error("can see not self Codename")
} }
if p.KillWords.Assignee != "" { if p.KillWords.Assignee != "" {
t.Error("can see other player's assignee") t.Error("can see other player's assignee")
@ -167,8 +167,8 @@ 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.Global.Word == "" || p.KillWords.Global.Points == 0 { if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 {
t.Error("self global missing field") t.Error("self Codename missing field")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
t.Error("assignee is empty") t.Error("assignee is empty")
@ -190,8 +190,8 @@ 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.Global.Empty() { if !p.KillWords.Codename.Empty() {
t.Error("can see not self global") t.Error("can see not self Codename")
} }
if p.KillWords.Assignee != "" { if p.KillWords.Assignee != "" {
t.Error("can see other player's assignee") t.Error("can see other player's assignee")
@ -248,8 +248,8 @@ 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.Global.Word == "" || p.KillWords.Global.Points == 0 { if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 {
t.Error("self global missing field") t.Error("self Codename missing field")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
t.Error("assignee is empty") t.Error("assignee is empty")
@ -271,8 +271,8 @@ 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.Global.Empty() { if p.KillWords.Codename.Empty() {
t.Error("cannot see not self global") t.Error("cannot see not self Codename")
} }
if p.KillWords.Assignee == "" { if p.KillWords.Assignee == "" {
t.Error("cannot see other player's assignee") t.Error("cannot see other player's assignee")

8
cmd/server/ws.go
View File

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