jkomoros
commented
7 years ago boardgame/enum.go
type Enum struct {
names map[EnumConstant]string
low, high int
}
func (e *Enum) Valid(v EnumConstant) bool {
if v < low || v > high {
return false
}
return true
}
func (e *Enum) String(v EnumConstant) string {
return e.names[v]
}
//EnumProperty should be used like a Stack: as a property on Game or Player state. You create them in EmptyGameState initialized with the enum name
type EnumProperty struct {
enumName string
value EnumConstant
}
func (e *EnumProperty) Valid() bool {
return e.state.game.getEnum(e.enumName).Valid(e.value)
}
func (e *EnumProperty) String() string {
//... similar to Valid()
}
func (e *EnumProperty) Value() EnumConstant {
//... similar to Valid()
}
func (e *EnumProperty) SetValue(v EnumConstant) bool {
enum := e.state.game.getEnum(e.enumName)
if e.enumName != v.enum {
return false
}
if !enum.Valid(v) {
return false
}
e.value = v
return true
}
type EnumConstant struct {
enum string
value int
}
//enumConstant can't have a String() because we don't have a canonical reference to the enum, we just know its name
type (e *EnumConstant) Int() int {
return e.int
}
func (g *GameManager) AddEnum(name string, values ...EnumConstant) {
//Create a new Enum with the given name. The values will automatically get stringified by taking the name of them, getting rid of the prefix of name, and using those as the string value.
}
mygame/components.go
const (
CardBlue = iota
CardGreen
CardRed
)mygame/main.go
//in NewManager...
manager.AddEnum("Card",CardBlue, CardGreen, CardRed)
//...
For example anything in components.go there should be a relatively easy way to:
1) Verify that a given value is in the enum. Get its string value, tell if it's invalid, and tell which one is greater. 2) Have access to those enums clientside in an auto-generated file
Would be useful for for example Valentine, but also a lot of other aspects.
Perhaps it's a new PropertyType of Enum, where a game is configured with a named enum, which is effectively like a deck. Then the enum will have properties to say its string value and verify that it's legal.
In early designs these were called "Colors" I believe.
Goals: 1) Easy to compare to actual constants in Go for type safety, e.g. theColor == ColorRed 2) Can always verify that the property that is an enum is never set to an illegal value 3) Way to convert to a string 4) Can be shipped to client in an auto-generated way and auto-expanded 5) They aren't high overhead memory/CPU wise 6) They don't require a lot of annoyance to use (e.g. val, err := prop.GetConstantEnum("bam"); if val != nil; ...)
Nice to have: 1) You can have them based on an underlying type like
type Color int