entity

type Actions struct {
	Current map[string]*ms.ModAction
	History []*ms.ModAction
}

type CompetitionType string

type DivisionManager interface {
	SubmitResult(int, string, string, int, int, pb.TournamentGameResult,
		pb.TournamentGameResult, pb.GameEndReason, bool, int, string) (*pb.DivisionPairingsResponse, error)
	PairRound(int, bool) (*pb.DivisionPairingsResponse, error)
	DeletePairings(int) error
	GetStandings(int) (*pb.RoundStandings, int, error)
	GetCurrentRound() int
	GetPlayers() *pb.TournamentPersons
	SetPairing(string, string, int, pb.TournamentGameResult) (*pb.DivisionPairingsResponse, error)
	SetSingleRoundControls(int, *pb.RoundControl) (*pb.RoundControl, error)
	SetRoundControls([]*pb.RoundControl) (*pb.DivisionPairingsResponse, []*pb.RoundControl, error)
	SetDivisionControls(*pb.DivisionControls) (*pb.DivisionControls, map[int32]*pb.RoundStandings, error)
	GetDivisionControls() *pb.DivisionControls
	AddPlayers(*pb.TournamentPersons) (*pb.DivisionPairingsResponse, error)
	RemovePlayers(*pb.TournamentPersons) (*pb.DivisionPairingsResponse, error)
	IsRoundReady(int) (bool, error)
	IsRoundComplete(int) (bool, error)
	IsStarted() bool
	IsFinished() (bool, error)
	StartRound(bool) error
	IsRoundStartable() error
	GetXHRResponse() (*pb.TournamentDivisionDataResponse, error)
	SetReadyForGame(userID, connID string, round, gameIndex int, unready bool) ([]string, bool, error)
	ClearReadyStates(userID string, round, gameIndex int) ([]*pb.Pairing, error)
	ResetToBeginning() error
}

type EventAudienceType string

type EventWrapper struct {
	Type pb.MessageType
	// The actual event should therefore be a proto object
	Event proto.Message
	// contains filtered or unexported fields
}

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

type Game struct {
	sync.RWMutex
	game.Game

	PlayerDBIDs [2]uint // needed to associate the games to the player IDs in the db.

	GameReq *pb.GameRequest
	// started is set when the game actually starts (when the game timers start).
	// Note that the internal game.Game may have started a few seconds before,
	// but there should be no information about it given until _this_ started
	// is true.
	Started bool
	Timers  Timers

	GameEndReason pb.GameEndReason
	// if 0 or 1, that player won
	// if -1, it was a tie!
	WinnerIdx int
	LoserIdx  int

	Stats *Stats

	ChangeHook chan<- *EventWrapper

	Quickdata      *Quickdata
	TournamentData *TournamentData
	MetaEvents     *MetaEventData
	CreatedAt      time.Time
	// contains filtered or unexported fields
}

type GameTimer struct{}

type IncrementType int

type ListDatum struct {
	// Used for words
	Word        string `json:"w,omitempty"`
	Probability int    `json:"p,omitempty"`
	// Used for words or games:
	Score int `json:"s,omitempty"`

	// Used for comments:
	Comment string `json:"c,omitempty"`

	// Used for mistakes:
	MistakeType int `json:"t,omitempty"`
	MistakeSize int `json:"z,omitempty"`

	// Used for ratings:
	Rating  int    `json:"r,omitempty"`
	Variant string `json:"v,omitempty"`
}

type ListItem struct {
	GameId   string
	PlayerId string
	Time     int64
	Item     ListDatum
}

type MetaEventData struct {
	Events []*pb.GameMetaEvent `json:"events"`
}

type MistakeMagnitude string

type MistakeType string

type Nower interface {
	// Now returns a timestamp in milliseconds
	Now() int64
}

type PoolMember struct {
	Id          string
	Rating      int
	RatingRange [2]int
	Blocking    []string
	Misses      int
	Wins        int
	Draws       int
	Spread      int
}

type Profile struct {
	FirstName string
	LastName  string
	// BirthDate uses ISO format YYYY-MM-DD
	BirthDate   string
	CountryCode string
	Title       string
	About       string
	Ratings     Ratings
	Stats       ProfileStats
	AvatarUrl   string
}

type ProfileStats struct {
	Data map[VariantKey]*Stats
}

type Quickdata struct {
	OriginalRequestId string           `json:"o"`
	FinalScores       []int32          `json:"s"`
	PlayerInfo        []*pb.PlayerInfo `json:"pi"`
	OriginalRatings   []float64
	NewRatings        []float64
}

type Ratings struct {
	Data map[VariantKey]SingleRating
}

type Session struct {
	ID       string
	Username string
	UserUUID string
	Expiry   time.Time
}

type SingleRating struct {
	Rating          float64 `json:"r"`
	RatingDeviation float64 `json:"rd"`
	Volatility      float64 `json:"v"`
	// This is the last game timestamp for this user for THIS variant:
	LastGameTimestamp int64 `json:"ts"`
}

type SoughtGame struct {
	SeekRequest *pb.SeekRequest
}

type SoughtGameType int

type StatItem struct {
	Name          string         `json:"-"`
	Minimum       int            `json:"-"`
	Maximum       int            `json:"-"`
	Total         int            `json:"t"`
	IncrementType IncrementType  `json:"-"`
	List          []*ListItem    `json:"-"`
	Subitems      map[string]int `json:"s"`
}

type StatItemType int

type Stats struct {
	PlayerOneId   string               `json:"i1"`
	PlayerTwoId   string               `json:"i2"`
	PlayerOneData map[string]*StatItem `json:"d1"`
	PlayerTwoData map[string]*StatItem `json:"d2"`
	NotableData   map[string]*StatItem `json:"n"`
}

type TimeControl string

type Timers struct {
	// TimeOfLastUpdate is the timestamp of the last update, in milliseconds.
	// If no update has been made, this defaults to timeStarted.
	TimeOfLastUpdate int64 `json:"lu"`
	// TimeStarted is a unix timestamp, in milliseconds.
	TimeStarted int64 `json:"ts"`
	// TimeRemaining is an array of remaining time per player, in milliseconds.
	TimeRemaining []int `json:"tr"`
	// MaxOvertime is in minutes. All others are in milliseconds.
	MaxOvertime int `json:"mo"`
}

type Tournament struct {
	sync.RWMutex
	UUID        string `json:"uuid"`
	Name        string `json:"name"`
	Description string `json:"desc"`
	// XXX: We will likely remove the following two fields
	AliasOf string `json:"aliasOf"`
	URL     string `json:"url"`
	// XXX: Investigate above.
	ExecutiveDirector string                         `json:"execDirector"`
	Directors         *pb.TournamentPersons          `json:"directors"`
	IsStarted         bool                           `json:"started"`
	IsFinished        bool                           `json:"finished"`
	Divisions         map[string]*TournamentDivision `json:"divs"`
	Type              CompetitionType                `json:"type"`
	ParentID          string                         `json:"parent"`
	Slug              string                         `json:"slug"`
	ExtraMeta         *TournamentMeta                `json:"extraMeta"`
}

type TournamentData struct {
	Id        string
	Division  string `json:"d"`
	Round     int    `json:"r"`
	GameIndex int    `json:"i"`
}

type TournamentDivision struct {
	ManagerType        TournamentType  `json:"mgrType"`
	DivisionRawMessage json.RawMessage `json:"json"`
	DivisionManager    DivisionManager `json:"-"`
}

type TournamentMeta struct {
	Disclaimer                string          `json:"disclaimer"`
	TileStyle                 string          `json:"tileStyle"`
	BoardStyle                string          `json:"boardStyle"`
	DefaultClubSettings       *pb.GameRequest `json:"defaultClubSettings"`
	FreeformClubSettingFields []string        `json:"freeformClubSettingFields"`
	Password                  string          `json:"password"`
	Logo                      string          `json:"logo"`
	Color                     string          `json:"color"`
	PrivateAnalysis           bool            `json:"privateAnalysis"`
}

type TournamentType int

type UnpairedPoolMembers struct {
	PoolMembers   []*PoolMember
	RoundControls *ipc.RoundControl
	Repeats       map[string]int
}

type User struct {
	sync.RWMutex

	Anonymous bool
	// ID is the database ID. Since this increases monotonically, we should
	// not expose it to the user
	ID uint
	// UUID is the "user-exposed" ID, in any APIs.
	UUID     string
	Username string
	Password string
	Email    string
	Profile  *Profile
	// CurrentChannel tracks presence; where is the user currently?
	CurrentChannel string
	IsBot          bool
	IsDirector     bool
	IsMod          bool
	IsAdmin        bool

	Actions   *Actions
	Notoriety int
}

type UserPermission int

type Variant string

type VariantKey string

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