-
Notifications
You must be signed in to change notification settings - Fork 0
/
service.go
146 lines (132 loc) · 3.39 KB
/
service.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package domain
import (
"github.com/the4thamigo-uk/gameserver/pkg/store"
)
// HangmanResult is the result of the last action in a game of hangman.
type HangmanResult struct {
ID store.ID `json:"id,omitempty"`
Current string `json:"current,omitempty"`
Word *string `json:"word,omitempty"`
Turns int `json:"turns,omitempty"`
State State `json:"state,omitempty"`
Success *bool `json:"success,omitempty"`
}
// HangmanResults is a slice of HangmanResult
type HangmanResults []*HangmanResult
func newHangmanResult(g *Hangman, id store.ID, success *bool) *HangmanResult {
res := &HangmanResult{
ID: id,
Current: g.Current(),
Turns: g.Turns(),
State: g.State(),
Success: success,
}
if g.State() != Play {
word := g.Word()
res.Word = &word
}
return res
}
// LoadHangman loads a specific game from the store
func LoadHangman(s store.Store, id store.ID) (*Hangman, store.ID, error) {
var g Hangman
id, err := s.Load(id, &g.hangman)
if err != nil {
return nil, id, err
}
return &g, id, err
}
func newHangman() interface{} {
return &hangman{}
}
// LoadAllHangman loads all hangman games from the store
func LoadAllHangman(s store.Store) (map[store.ID]*Hangman, error) {
objs, err := s.LoadAll(newHangman)
if err != nil {
return nil, err
}
gs := map[store.ID]*Hangman{}
for id, obj := range objs {
gs[id] = &Hangman{
hangman: *obj.(*hangman),
}
}
return gs, nil
}
// SaveHangman loads a specific game from the store
func SaveHangman(s store.Store, id store.ID, g *Hangman) (store.ID, error) {
id, err := s.Save(id, &g.hangman)
if err != nil {
return id, err
}
return id, nil
}
// CreateHangman creates a new game instance and stores it.
func CreateHangman(stg store.Store, word string, turns int) (*HangmanResult, error) {
g, err := NewHangman(word, turns)
if err != nil {
return nil, err
}
id := store.NewID(NewID(), 0)
id, err = SaveHangman(stg, id, g)
if err != nil {
return nil, err
}
return newHangmanResult(g, id, nil), nil
}
// ListHangman returns details of all current games of hangman in the store
func ListHangman(stg store.Store) (HangmanResults, error) {
gs, err := LoadAllHangman(stg)
if err != nil {
return nil, err
}
rs := HangmanResults{}
for id, g := range gs {
r := newHangmanResult(g, id, nil)
rs = append(rs, r)
}
return rs, nil
}
// JoinHangman loads an existing game instance.
func JoinHangman(stg store.Store, id store.ID) (*HangmanResult, error) {
g, id, err := LoadHangman(stg, id)
if err != nil {
return nil, err
}
return newHangmanResult(g, id, nil), nil
}
// PlayLetter submits a letter guess to a specified game
func PlayLetter(stg store.Store, id store.ID, letter rune) (*HangmanResult, error) {
g, id, err := LoadHangman(stg, id)
if err != nil {
return nil, err
}
ok, err := g.PlayLetter(letter)
if err != nil {
return nil, err
}
id, err = SaveHangman(stg, id, g)
if err != nil {
return nil, err
}
return newHangmanResult(g, id, ptrBool(ok)), nil
}
// PlayWord submits a word guess to a specified game.
func PlayWord(stg store.Store, id store.ID, word string) (*HangmanResult, error) {
g, ver, err := LoadHangman(stg, id)
if err != nil {
return nil, err
}
ok, err := g.PlayWord(word)
if err != nil {
return nil, err
}
ver, err = SaveHangman(stg, ver, g)
if err != nil {
return nil, err
}
return newHangmanResult(g, ver, ptrBool(ok)), nil
}
func ptrBool(b bool) *bool {
return &b
}