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)
}

type CellType int

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
	MakeMoveError(move GameEngineMove) error
	Board() *Board
	IsDone() bool
	Winner() (playerNum int) // Results are only meaningful if IsDone() is true. 0 for draw.
	GameType() api.GameType
	// Encodes the current state of the game engine.
	Proto() *pb.GameEngineState
	// Sets this game engine into the state defined by the given encoded state.
	FromProto(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 GameHistoryResponse struct {
	GameId      string                      `json:"gameId"`
	PlayerNames []string                    `json:"playerNames"`
	GameType    api.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 api.GameType `json:"gameType"`
}

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

type GameRequest[R any] struct {
	// contains filtered or unexported fields
}

type GameSettingsRequest struct {
	GameId             string `json:"gameId"`
	CPUThinkTimeMillis int64  `json:"cpuThinkTimeMillis"`
}

type GameState string

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

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

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

type LoginNamesResponse struct {
	Names []string `json:"names"`
}

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 MoveSuggesterServer struct {
	// Needs to be embedded to have MoveSuggesterServer implement pb.CPUPlayerServiceServer.
	pb.UnimplementedCPUPlayerServiceServer
	// contains filtered or unexported fields
}

type MoveSuggesterServerConfig struct {
	Addr         string // e.g. "localhost:50051".
	CpuThinkTime time.Duration
	CpuMaxFlags  int
}

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

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

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

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

type ServerConfig struct {
	ServerHost string
	ServerPort int
	// Path prefix that all URLs for this server have.
	// Usually "/hexz/", but when running behind a reverse proxy it might differ.
	URLPathPrefix      string
	DocumentRoot       string                // Path to static resource files.
	GameHistoryRoot    string                // Path to game history files.
	RemoteCPUPlayerURL string                // Base URL of the remote CPU player server. If emtpy, a local CPU player is used.
	CPUPlayerMode      pb.CPUPlayerMode_Enum // Type of CPU player to use.
	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.
	FromAddress        string                // Address to use for transactional emails
	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.
	TlsCertChain       string
	TlsPrivKey         string
	DebugMode          bool
	// The VCS (typically: git) revision that the binary was built at.
	// Can be used in .js / .wasm URLs as a query parameter to avoid
	// the usual browser caching problems.
	VCSRevision string
}

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"`
	// Number of the player that wins. 0 if no winner yet or draw.
	Winner int `json:"winner,omitempty"`
	// Only populated in the first event.
	GameInfo *ServerEventGameInfo `json:"gameInfo,omitempty"`
	// Only populated if the game was reset and a new one starts under a
	// new game ID. Clients are expected to maintain their SSE connection
	// and start playing the new game.
	// The new game's board and other data are part of the same message.
	NewGameID string `json:"newGameId"`
}

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 api.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 StatelessServerBuilder 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 UndoRedoRequest struct {
	GameId      string `json:"gameId"`
	Action      string `json:"action"`      // One of {"undo", "redo"}
	CurrentMove int    `json:"currentMove"` // The current move number (not the one to be undone)
}