hexz

type Board struct {
	Turn         int
	Move         int
	LastRevealed int       // Move at which fields were last revealed
	FlatFields   []Field   // The 1-d array backing the "2d" Fields.
	Fields       [][]Field // The board's fields. Subslices of FlatFields.
	Score        []int     // Depending on the number of players, 1 or 2 elements.
	Resources    []ResourceInfo
	State        GameState
}

type BoardView struct {
	Turn      int            `json:"turn"`
	Move      int            `json:"move"`
	Fields    [][]Field      `json:"fields"` // The board's fields.
	Score     []int          `json:"score"`  // Depending on the number of players, 1 or 2 elements.
	Resources []ResourceInfo `json:"resources"`
	State     GameState      `json:"state"`
}

type CPUPlayer interface {
	SuggestMove(ctx context.Context, ge *GameEngineFlagz) (*GameEngineMove, *pb.SuggestMoveStats, error)
	MaxThinkTime() time.Duration
}

type CPUPlayerServer struct {
	// contains filtered or unexported fields
}

type CPUPlayerServerConfig struct {
	Addr         string // Same format as http.Server.Addr, e.g. "localhost:8085".
	CpuThinkTime time.Duration
	CpuMaxFlags  int
	TlsCertChain string
	TlsPrivKey   string
}

type CellType int

type ControlEvent interface {
	// contains filtered or unexported methods
}

type ControlEventMove struct {
	PlayerId    PlayerId
	MoveRequest *MoveRequest
	MCTSStats   *MCTSStats // Optional, only populated by CPU players.
}

type ControlEventRedo struct {
	RedoRequest
	// contains filtered or unexported fields
}

type ControlEventRegister struct {
	// contains filtered or unexported fields
}

type ControlEventReset struct {
	// contains filtered or unexported fields
}

type ControlEventUndo struct {
	UndoRequest
	// contains filtered or unexported fields
}

type ControlEventUnregister struct {
	// contains filtered or unexported fields
}

type ControlEventValidMoves struct {
	// contains filtered or unexported fields
}

type Counter struct {
	// contains filtered or unexported fields
}

type DatabaseStore interface {
	// Stores a game state in the database.
	StoreGame(ctx context.Context, hostId string, state *pb.GameState) error
	// Adds an entry to the game history. state can be nil for "undo" and "redo" entries.
	InsertHistory(ctx context.Context, entryType string, gameId string, state *pb.GameState) error
	// Returns the previous game state from the database. Does not write any new history entries.
	// Clients should register the undo once it became effective by calling InsertHistory(ctx, "undo", ...).
	PreviousGameState(ctx context.Context, gameId string) (*pb.GameState, error)
	// Returns the next game state from the database. Does not write any new history entries.
	// This will only yield a non-error result if the previous event was an undo.
	// Clients should register the undo once it became effective by calling InsertHistory(ctx, "undo", ...).
	NextGameState(ctx context.Context, gameId string) (*pb.GameState, error)
	// Adds stats for a CPU move.
	InsertStats(ctx context.Context, stats *WASMStatsRequest) error
	// Loads a game state from the database.
	LoadGame(ctx context.Context, gameId string) (*pb.GameState, error)
}

type Distribution struct {
	// contains filtered or unexported fields
}

type Field struct {
	Type    CellType `json:"type"`
	Owner   int      `json:"owner,omitempty"` // Player number owning this field. 0 for unowned fields.
	Hidden  bool     `json:"hidden,omitempty"`
	Value   int      `json:"v"`                 // Some games assign different values to cells.
	Blocked uint8    `json:"blocked,omitempty"` // Indicates which players this field is blocked for.
	// Internal fields, not exported in JSON
	Lifetime int    `json:"-"` // Moves left until this cell gets cleared. -1 means infinity.
	NextVal  [2]int `json:"-"` // If this cell would be occupied, what value would it have? (For Flagz)
}

type GameEngine interface {
	Reset()
	NumPlayers() int
	ValidCellTypes() []CellType
	MakeMove(move GameEngineMove) bool
	Board() *Board
	IsDone() bool
	Winner() (playerNum int) // Results are only meaningful if IsDone() is true. 0 for draw.
	GameType() GameType
	// Encodes the current state of the game engine.
	Encode() (*pb.GameEngineState, error)
	// Sets this game engine into the state defined by the given encoded state.
	Decode(s *pb.GameEngineState) error
}

type GameEngineClassic struct {
	// contains filtered or unexported fields
}

type GameEngineFlagz struct {
	B *Board
	// Used to efficiently process moves and determine game state for flagz.
	FreeCells   int    // Number of unoccupied cells
	NormalMoves [2]int // Number of normal cell moves the players can make

}

type GameEngineFreeform struct {
	// contains filtered or unexported fields
}

type GameEngineMove struct {
	PlayerNum int
	Move      int
	Row       int
	Col       int
	CellType  CellType
}

type GameHandle struct {
	// contains filtered or unexported fields
}

type GameHistory struct {
	Header  *GameHistoryHeader
	Entries []*GameHistoryEntry
}

type GameHistoryEntry struct {
	Timestamp  time.Time // Will be added automatically by the .Write method if not specified.
	EntryType  string    // One of {"move", "undo", "redo", "reset"}.
	Move       *MoveRequest
	Board      *BoardView
	MoveScores *MoveScores
}

type GameHistoryHeader struct {
	GameId      string
	GameType    GameType
	PlayerNames []string
}

type GameHistoryResponse struct {
	GameId      string                      `json:"gameId"`
	PlayerNames []string                    `json:"playerNames"`
	GameType    GameType                    `json:"gameType,omitempty"`
	Entries     []*GameHistoryResponseEntry `json:"entries"`
}

type GameHistoryResponseEntry struct {
	Timestamp time.Time    `json:"timestamp"` // RFC3339 formatted.
	EntryType string       `json:"entryType"` // One of {"move", "undo", "redo", "reset"}.
	Move      *MoveRequest `json:"move"`      // Only populated if the EntryType is "move"
	Board     *BoardView   `json:"board"`
	// For single-player flagz: scores that the CPU assigns to each move.
	MoveScores *MoveScores `json:"moveScores,omitempty"`
}

type GameInfo struct {
	Id       string    `json:"id"`
	Host     string    `json:"host"`
	Started  time.Time `json:"started"`
	GameType GameType  `json:"gameType"`
}

type GameMaster struct {
	// contains filtered or unexported fields
}

type GameState string

type GameStateResponse struct {
	GameId           string `json:"gameId"`
	EncodedGameState []byte `json:"encodedGameState"`
}

type GameStore interface {
	StoreNewGame(ctx context.Context, s *pb.GameState) (bool, error)
	LookupGame(ctx context.Context, gameId string) (*pb.GameState, error)
	UpdateGame(ctx context.Context, s *pb.GameState) error
	ListRecentGames(ctx context.Context, limit int) ([]*pb.GameInfo, error)

	Publish(ctx context.Context, gameId string, event string) error
	Subscribe(ctx context.Context, gameId string, ch chan<- string)
}

type GameType string

type HexzTestClient struct {
	// contains filtered or unexported fields
}

type HistoryWriter struct {
	// contains filtered or unexported fields
}

type InMemoryPlayerStore struct {
	// contains filtered or unexported fields
}

type LocalCPUPlayer struct {
	// contains filtered or unexported fields
}

type MCTS struct {
	UctFactor float64
	// If true, SuggestMove returns the most frequently vistited child node,
	// not the one with the highest win rate.
	ReturnMostFrequentlyVisited bool
	// Sample boards that led to a win/loss.
	WinningBoard *Board
	LosingBoard  *Board
	// For explicit memory handling.
	Mem  []mcNode
	Next int
}

type MCTSMoveStats struct {
	Row        int
	Col        int
	CellType   CellType
	U          float64
	Q          float64
	Iterations int
}

type MCTSStats struct {
	Iterations  int
	MaxDepth    int
	TreeSize    int
	LeafNodes   []int         // Per depth level, 0=root
	BranchNodes []int         // Per depth level, 0=root
	VisitCounts []map[int]int // Per depth level, maps visit count to number of nodes with that count.
	Elapsed     time.Duration
	Moves       []MCTSMoveStats
	BestMoveQ   float64
}

type MoveRequest struct {
	Move int      `json:"move"` // Used to discard move requests that do not match the game's current state.
	Row  int      `json:"row"`
	Col  int      `json:"col"`
	Type CellType `json:"type"`
}

type MoveScores struct {
	NormalCell [][]float64 `json:"normalCell"` // Scores for placing a normal cell on a field.
	Flag       [][]float64 `json:"flag"`       // Scores for placing a flag on a field.
}

type Player struct {
	Id         PlayerId  `json:"id"`
	Name       string    `json:"name"`
	LastActive time.Time `json:"lastActive"`
}

type PlayerId string

type PlayerStore interface {
	// Lookup looks up the given player by ID.
	Lookup(ctx context.Context, playerId PlayerId) (Player, error)
	// Login logs in the given player. If the player is already logged in,
	// the existing data will be overwritten with the new data.
	Login(ctx context.Context, playerId PlayerId, name string) error
}

type RedoRequest struct {
	Move int `json:"move"`
}

type RemoteCPUPlayer struct {
	// contains filtered or unexported fields
}

type ResetRequest struct {
	Message string `json:"message"`
}

type ResourceInfo struct {
	NumPieces [cellTypeLen]int `json:"numPieces"`
}

type Server struct {
	// contains filtered or unexported fields
}

type ServerConfig struct {
	ServerHost         string
	ServerPort         int
	DocumentRoot       string        // Path to static resource files.
	GameHistoryRoot    string        // Path to game history files.
	LoginDatabasePath  string        // Path to the file where the player DB is stored. If empty, no persistent storage is used.
	RemoteCPUPlayerURL string        // Base URL of the remote CPU player server. If emtpy, a local CPU player is used.
	RedisAddr          string        // Address of the Redis server. If empty, local storage is used.
	PostgresURL        string        // URL of the PostgreSQL server. If empty, no persistent storage is used.
	InactivityTimeout  time.Duration // Time after which a game is ended due to inactivity.
	PlayerRemoveDelay  time.Duration // Time to wait before removing an unregistered player from the game.
	LoginTTL           time.Duration
	CpuThinkTime       time.Duration
	CpuMaxFlags        int
	AuthTokenSha256    string // Used in http Basic authentication for /statusz. Must be a SHA256 checksum.
	DisableUndo        bool   // If true, Undo/Redo is enabled for all games
	TlsCertChain       string
	TlsPrivKey         string
	DebugMode          bool
	// If true, run stateless server (e.g. for Cloud Run). RedisAddr must also be set in this case.
	Stateless bool
}

type ServerEvent struct {
	Timestamp time.Time  `json:"timestamp"` // RFC3339 formatted.
	Board     *BoardView `json:"board"`
	// Role of the client receiving the event. 0: spectator, 1, 2: players.
	Role          int      `json:"role"`
	PlayerNames   []string `json:"playerNames"`
	Announcements []string `json:"announcements"`
	DebugMessage  string   `json:"debugMessage"`
	// Number of the player that wins. 0 if no winner yet or draw.
	Winner int `json:"winner,omitempty"`
	// Only sent in the first event to clients.
	GameInfo *ServerEventGameInfo `json:"gameInfo,omitempty"`
	// If true, the client should not display undo/redo buttons.
	DisableUndo bool `json:"disableUndo,omitempty"`
	// Signals to clients that this is the last event they will receive.
	LastEvent bool `json:"lastEvent"`
}

type ServerEventGameInfo struct {
	// Indicates which cell types exist in this type of game.
	ValidCellTypes []CellType `json:"validCellTypes"`
	// The type of game we're playing.
	GameType GameType `json:"gameType"`
	// True if this is a game of one player against a CPU player, which
	// should be run on the client side.
	ClientSideCPUPlayer bool `json:"clientSideCPUPlayer"`
}

type StatelessServer struct {
	// contains filtered or unexported fields
}

type StatuszCounter struct {
	Name  string `json:"name"`
	Value int64  `json:"value"`
}

type StatuszDistrib struct {
	Name    string                 `json:"name"`
	Buckets []StatuszDistribBucket `json:"buckets"`
}

type StatuszDistribBucket struct {
	Lower float64 `json:"lower"`
	Upper float64 `json:"upper"` // exclusive
	Count int64   `json:"count"`
}

type StatuszResponse struct {
	Started            time.Time         `json:"started"`
	UptimeSeconds      int               `json:"uptimeSeconds"`
	Uptime             string            `json:"uptime"` // 1h30m3.5s
	NumOngoingGames    int               `json:"numOngoingGames"`
	NumLoggedInPlayers *int              `json:"numLoggedInPlayers,omitempty"` // pointer to make this one optional (remote store does not support count).
	Counters           []StatuszCounter  `json:"counters"`
	Distributions      []*StatuszDistrib `json:"distributions"`
}

type UndoRequest struct {
	Move int `json:"move"`
}

type UserInfo struct {
	// The User-Agent header.
	UserAgent string `json:"userAgent"`
	// Taken from navigator.language.
	Language string `json:"language"`
	// Resolution is the screen resolution in pixels [window.screen.width, window.screen.height].
	Resolution [2]int `json:"resolution"`
	// Viewport is the size of the viewport in pixels [window.innerWidth, window.innerHeight].
	Viewport [2]int `json:"viewport"`
	// BrowserWindow is the size of the browser window in pixels [window.outerWidth, window.outerHeight].
	BrowserWindow [2]int `json:"browserWindow"`
	// HardwareConcurrency is the number of logical processors available to run threads
	// on the user's computer (navigator.hardwareConcurrency).
	HardwareConcurrency int `json:"hardwareConcurrency"`
}

type WASMStats struct {
	// MCTS stats.
	TreeSize   int           `json:"treeSize"`
	MaxDepth   int           `json:"maxDepth"`
	Iterations int           `json:"iterations"`
	Elapsed    time.Duration `json:"elapsed"`
	// Memory allocations, in MiB (1024*1024 bytes).
	TotalAllocMiB float64 `json:"totalAllocMiB"`
	HeapAllocMiB  float64 `json:"heapAllocMiB"`
}

type WASMStatsRequest struct {
	GameId   string    `json:"gameId"`
	GameType GameType  `json:"gameType"`
	Move     int       `json:"move"`
	UserInfo UserInfo  `json:"userInfo"`
	Stats    WASMStats `json:"stats"`
}