netplay

type Entry struct {
	Side game.Player
	Move string
}

type Event struct {
	Kind EventKind
	// Move is the move in the engine's notation, for EventMove.
	Move string
	// Err is the failure, for EventError.
	Err error
	// Text is a line fit to show the player.
	Text string
}

type EventKind int

type GuestOptions struct {
	// Name is the local player's name, shown to the host.
	Name string
	// Rules, when set, is the ruleset this end insists on: if the host offers
	// anything else the game is refused, naming the difference. Left zero, the
	// host's ruleset is adopted.
	Rules game.Ruleset
	// Side, when set, is the side this end expects to be given. Left zero,
	// whichever side the host did not take is accepted.
	Side game.Player
	// Resume continues the game in the snapshot instead of starting a new one.
	Resume *Snapshot
	Tuning
}

type HostOptions struct {
	// Name is the local player's name, shown to the guest.
	Name string
	// Rules is the ruleset both ends will play by. Required.
	Rules game.Ruleset
	// Side is the side the host takes; the guest is given the other one.
	// Required, because the choice of side is the player's to make.
	Side game.Player
	// Resume continues the game in the snapshot instead of starting a new one.
	// The snapshot's ruleset and side win over the fields above.
	Resume *Snapshot
	Tuning
}

type Invite struct {
	// ID identifies the game. Every move code carries its digest.
	ID string
	// Rules is the ruleset both players will use.
	Rules game.Ruleset
	// HostSide is the side the host took; the guest plays the other one.
	HostSide game.Player
	// HostName is the host's name, for the guest to see who invited them.
	HostName string
}

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

type MoveCode struct {
	// Game is the digest of the game identifier. Compare it with GameDigest of
	// a saved game's identifier to find the game the code belongs to.
	Game string
	// Entries is how many entries the record held before this one, which is
	// what the code follows on from.
	Entries int
	// Side is the player who made the move.
	Side game.Player
	// Move is the move in the engine's notation.
	Move string
	// Before is the position hash the move must be applied to, shortened.
	Before string
	// After is the position hash the move produces, shortened.
	After string
}

type Relay struct {
	// Wait is how long the first client of a room waits for the second. Zero
	// means DefaultPairingWait.
	Wait time.Duration
	// MaxConnections bounds waiting and paired client sockets together. Set it
	// before Serve starts; zero means DefaultMaxRelayConnections.
	MaxConnections int
	// IdleTimeout closes a paired connection after this long without bytes.
	// Set it before Serve starts; zero means DefaultRelayIdleTimeout.
	IdleTimeout time.Duration
	// Logf, when set, is where the relay reports what its operator needs to
	// see. Left nil, it logs through the standard logger. It is never given a
	// pairing code, a player name or an address: an operator needs enough to
	// tell abuse from popularity, and nothing about the games being carried.
	Logf func(format string, args ...any)
	// contains filtered or unexported fields
}

type RelayStats struct {
	// Rooms is how many rooms the relay is holding now.
	Rooms int
	// Connections is how many client sockets are live now.
	Connections int
	// Paired is how many pairs the relay has put together since it started.
	Paired uint64
	// Abandoned is how many waiting clients stopped being usable before an
	// opponent arrived. This climbing while Paired does not is what somebody
	// exhausting the relay's rooms looks like.
	Abandoned uint64
	// RefusedBusy is how many connections were turned away because
	// MaxConnections was reached.
	RefusedBusy uint64
	// RefusedPrelude is how many connections never asked for a room in a form
	// the relay understands.
	RefusedPrelude uint64
}

type Resumable interface {
	Session
	// Snapshot returns everything needed to resume the game.
	Snapshot() Snapshot
	// Position returns a copy of the session's own view of the game, which the
	// protocol keeps in step with the opponent's.
	Position() *game.Game
}

type Role int

type Session interface {
	// Side reports which side this end plays.
	Side() game.Player
	// Rules reports the ruleset both ends agreed on.
	Rules() game.Ruleset
	// OpponentName reports the name the other end gave.
	OpponentName() string
	// SendMove plays a move in the engine's notation and sends it.
	SendMove(notation string) error
	SendResign() error
	SendDrawOffer() error
	SendDrawAccept() error
	// Events returns the stream of things the opponent did. It is closed when
	// the session finishes.
	Events() <-chan Event
	// Close ends the session and the underlying connection.
	Close() error
}

type Snapshot struct {
	Role     Role
	Rules    game.Ruleset
	Side     game.Player
	Name     string
	Opponent string
	Moves    []Entry
}

type Tuning struct {
	// Keepalive is how often a ping goes out on an otherwise idle connection.
	Keepalive time.Duration
	// DeadAfter is how long a connection may carry no traffic at all before
	// the opponent is declared gone. It also bounds a single write, so a peer
	// that has stopped reading cannot block a move for ever.
	DeadAfter time.Duration
	// HandshakeTimeout bounds the handshake.
	HandshakeTimeout time.Duration
}