go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/matchmaker/pkg/sim/simulation.go

/*

Copyright (c) 2024 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package sim

import (
	"fmt"
	"math"
	"math/rand"
	"slices"
	"time"

	c9s "go.charczuk.com/sdk/collections"
	"go.charczuk.com/sdk/mathutil"
	"go.charczuk.com/sdk/uuid"
)

type Simulation struct {
	// Config holds configuration options that will
	// be satisfied by defaults if they're not set.
	Config SimulationConfig

	// Clock is the source of time for the simulation.
	//
	// If it's not set, it will be assigned a default.
	Clock      Clock
	Matchmaker Matchmaker
	RandSource rand.Source

	// rand is to save some gc churn.
	r *rand.Rand

	// players is the authoritative full list of players.
	players PlayerLookup
	// playersAvailable are players that have not connected.
	playersAvailable PlayerLookup
	// playersIdle are players that have connected and are
	// waiting to join the matchmaker queue.
	playersIdle PlayerLookup
	// playersInQueue are players that have connected and are
	// in the matchmaker queue.
	playersInQueue PlayerLookup
	// playersInGame are players that are in game(s).
	playersInGame PlayerLookup

	// servers is the authoritative full list of servers.
	servers ServerLookup
	// serversIdle are the servers that can be used
	// to host games by the matchmaker.
	serversIdle ServerLookup
	// serversHostingGames are the servers that are currently hosting
	// games and should be checked if they're done.
	serversHostingGames ServerLookup
}

// Player is an alias to lookup for player.
type PlayerLookup = Lookup[uuid.UUID, *Player]

// ServerLookup is an alias to lookup for server.
type ServerLookup = Lookup[uuid.UUID, *Server]

// Init sets up internal data stores and resolves dependencies.
//
// You must call `Init` before you call `Simulate`.
func (s *Simulation) Init() {
	if s.RandSource == nil {
		s.RandSource = rand.NewSource(time.Now().UnixMilli())
	}
	if s.Clock == nil {
		s.Clock = NewSimulatedClock(time.Now())
	}
	if s.Matchmaker == nil {
		s.Matchmaker = new(SimpleMatchmaker)
	}

	s.r = rand.New(s.RandSource)
	s.Matchmaker.Init(s.r)

	s.players = s.generatePlayers()
	s.playersAvailable = s.players.Copy()
	s.playersIdle = make(PlayerLookup)
	s.playersInQueue = make(PlayerLookup)
	s.playersInGame = make(PlayerLookup)

	s.servers = s.generateServers()
	s.serversIdle = s.servers.Copy()
	s.serversHostingGames = make(ServerLookup)
}

// Simulate runs the simulation and returns results.
func (s *Simulation) Simulate() SimulationResults {
	startTime := s.Clock.Now()
	var lastTimestamp, displayLastTimestamp, currentTimestamp time.Time = startTime, startTime, startTime
	var state SimulationResultState
	for {
		currentTimestamp = s.Clock.Now()
		if currentTimestamp.Sub(startTime) > s.Config.SimulationLengthOrDefault() {
			break
		}
		s.simulateTick(currentTimestamp, currentTimestamp.Sub(lastTimestamp), &state)
		s.Clock.Wait(s.Config.TickIntervalOrDefault())
		lastTimestamp = currentTimestamp
		if displayLastTimestamp.IsZero() {
			displayLastTimestamp = currentTimestamp
		} else if currentTimestamp.Sub(displayLastTimestamp) >= time.Hour {
			// log(
			// 	"tick (1hr)",
			// 	tag{"ts", currentTimestamp.Format("15:04")},
			// 	tag{"elapsed", currentTimestamp.Sub(startTime)},
			// 	tag{"ql", s.Matchmaker.QueueLen()},
			// 	tag{"p", len(s.players)},
			// 	tag{"pi", len(s.playersIdle)},
			// 	tag{"piq", len(s.playersInQueue)},
			// 	tag{"pig", len(s.playersInGame)},
			// 	tag{"s", len(s.servers)},
			// 	tag{"si", len(s.serversIdle)},
			// 	tag{"shg", len(s.serversHostingGames)},
			// )
			// log("\tplayers in queue", s.queuedPlayersByRank()...)
			displayLastTimestamp = currentTimestamp
		}
	}

	return s.simulateProcessResults(&state)
}

func (s *Simulation) simulateProcessResults(state *SimulationResultState) (res SimulationResults) {
	ts := s.Clock.Now()
	for _, p := range s.playersInQueue {
		state.queuedElapsed = append(state.queuedElapsed, ts.Sub(p.QueuedAt))
	}
	res.GamesPlayed = len(state.games)
	res.GamesLobsided = state.gamesLobsided
	res.GamesTied = state.gamesTied
	res.QueueTimeMean = mathutil.MeanDuration(state.queuedElapsed)
	res.QueueTimeP95 = mathutil.Percentile(state.queuedElapsed, 95.0)

	var playersByWinrate []*Player
	var winrates, naturalSkills, ratings []float64
	for _, p := range s.players {
		if p.Games <= 5 {
			continue
		}

		playersByWinrate = append(playersByWinrate, p)
		winrates = append(winrates, p.Winrate())
		naturalSkills = append(naturalSkills, float64(p.NaturalSkill))
		ratings = append(ratings, float64(p.Rating))
	}

	slices.SortFunc(playersByWinrate, func(a, b *Player) int {
		awr := a.Winrate()
		bwr := b.Winrate()
		if awr > bwr {
			return -1
		}
		if awr == bwr {
			return 0
		}
		return 1
	})

	res.PlayerNaturalSkillToRatingCorrelation = mathutil.Correlation(naturalSkills, ratings)

	res.PlayerTop10 = playersByWinrate[0:10]
	pl := len(playersByWinrate)
	res.PlayerBottom10 = playersByWinrate[pl-10 : pl]
	res.Players = playersByWinrate

	slices.Sort(winrates)
	res.WinrateP20 = mathutil.PercentileSorted(winrates, 20.0)
	res.WinrateMean = mathutil.PercentileSorted(winrates, 50.0)
	res.WinrateP80 = mathutil.PercentileSorted(winrates, 80.0)
	res.PlayerCountsByRank = s.countPlayersByRank(s.players)
	return res
}

func (s *Simulation) countPlayersByRank(players PlayerLookup) []Tag {
	lookup := make(map[string]int)
	for _, tier := range rankTiers {
		lookup[tier.Name] = 0
	}
	for _, p := range players {
		var didFindPlayerTier bool
		for _, tier := range rankTiers {
			if tier.MaxRating >= p.Rating && tier.MinRating < p.Rating {
				lookup[tier.Name]++
				didFindPlayerTier = true
				break
			}
		}
		if !didFindPlayerTier {
			println("bad player rating", p.Rating)
		}
	}
	var output []Tag
	for _, tier := range rankTiers {
		output = append(output, Tag{tier.Name, fmt.Sprint(lookup[tier.Name])})
	}
	return output
}

func (s *Simulation) simulateTick(currentTimestamp time.Time, elapsedSinceLastTick time.Duration, state *SimulationResultState) {
	s.tickPlayerArrivals(currentTimestamp, elapsedSinceLastTick)
	s.tickQueueIdlePlayersIntoMatchmaker(currentTimestamp)
	s.tickMatchmakerFormGames(currentTimestamp, state)
	s.tickFinalizeGames(currentTimestamp, state)
	s.tickMoveTimedOutPlayersToAvailable(currentTimestamp)
}

func (s *Simulation) tickPlayerArrivals(currentTimestamp time.Time, elapsedSinceLastTick time.Duration) {
	newPlayerCount := s.randomNewPlayerCount(currentTimestamp, elapsedSinceLastTick)
	for x := 0; x < newPlayerCount; x++ {
		p, ok := s.playersAvailable.PopRandom(s.r)
		if !ok {
			p = s.createPlayer()
			s.players.Add(p)
		}
		p.IdleAt = currentTimestamp
		p.TimedOutAt = currentTimestamp.Add(s.generatePlayerTimedOutAfter())
		s.playersIdle.Add(p)
	}
	return
}

func (s *Simulation) generatePlayerTimedOutAfter() time.Duration {
	playerActiveDuration := float64(s.Config.PlayerActiveDurationOrDefault())
	return time.Duration(s.randomNormal(playerActiveDuration, playerActiveDuration))
}

func (s *Simulation) randomNewPlayerCount(currentTimestamp time.Time, elapsedSinceLastTick time.Duration) int {
	playersPerHour := float64(targetPlayerCountsByHour[currentTimestamp.Hour()])
	elapsedHours := float64(elapsedSinceLastTick) / float64(time.Hour)
	playerMean := math.Floor(playersPerHour * elapsedHours)
	return int(s.randomNormal(playerMean, playerMean))
}

func (s *Simulation) tickMoveTimedOutPlayersToAvailable(currentTimestamp time.Time) {
	var newlyTimedOutPlayers []*Player
	for _, player := range s.playersIdle {
		if player.IsTimedOut(currentTimestamp) {
			newlyTimedOutPlayers = append(newlyTimedOutPlayers, player)
		}
	}
	for _, player := range newlyTimedOutPlayers {
		s.playersIdle.Del(player)
		s.playersAvailable.Add(player)
	}
}

func (s *Simulation) tickQueueIdlePlayersIntoMatchmaker(currentTimestamp time.Time) {
	var newlyQueuedPlayers []*Player
	for _, player := range s.playersIdle {
		newlyQueuedPlayers = append(newlyQueuedPlayers, player)
		player.QueuedAt = currentTimestamp
		s.playersInQueue.Add(player)
		s.Matchmaker.Queue(player)
	}
	for _, player := range newlyQueuedPlayers {
		s.playersIdle.Del(player)
	}
}

func (s *Simulation) tickMatchmakerFormGames(currentTimestamp time.Time, state *SimulationResultState) {
	if len(s.serversIdle) == 0 {
		return
	}
	games := s.Matchmaker.FormGames(MatchmakerConfig{
		TeamSize: s.Config.GameTeamSizeOrDefault(),
		MaxGames: len(s.serversIdle),
	})
	for _, mg := range games {
		svr, ok := s.serversIdle.PopRandom(s.r)
		if !ok {
			panic(fmt.Errorf("critical error; cannot assign game to server; no servers available"))
		}
		svr.Game = s.createGame(currentTimestamp, mg.TeamA, mg.TeamB)
		s.measurePlayerQueuedElapsed(currentTimestamp, svr.Game, state)
		s.moveGamePlayersToInGame(svr.Game)
		s.serversHostingGames.Add(svr)
	}
}

func (s *Simulation) tickFinalizeGames(currentTimestamp time.Time, state *SimulationResultState) {
	var serversNewlyIdle []*Server
	for _, svr := range s.serversHostingGames {
		if svr.Game.Done(currentTimestamp) {
			state.games = append(state.games, s.tickFinalizeGame(svr.Game, state))
			serversNewlyIdle = append(serversNewlyIdle, svr)
		}
	}
	for _, svr := range serversNewlyIdle {
		s.serversHostingGames.Del(svr)
		s.serversIdle.Add(svr)
	}
}

func (s *Simulation) measurePlayerQueuedElapsed(currentTimestamp time.Time, g *Game, state *SimulationResultState) {
	for _, player := range g.TeamA {
		queuedFor := currentTimestamp.Sub(player.QueuedAt)
		state.queuedElapsed = append(state.queuedElapsed, queuedFor)
		player.QueuedElapsed = append(player.QueuedElapsed, queuedFor)
	}
	for _, player := range g.TeamB {
		queuedFor := currentTimestamp.Sub(player.QueuedAt)
		state.queuedElapsed = append(state.queuedElapsed, queuedFor)
		player.QueuedElapsed = append(player.QueuedElapsed, queuedFor)
	}
}

func (s *Simulation) tickFinalizeGame(g *Game, state *SimulationResultState) *Game {
	scorea, scoreb := s.computeGameOutcome(g)

	if scorea > scoreb {
		g.Outcome = TeamA
	} else if scoreb > scorea {
		g.Outcome = TeamB
	} else {
		state.gamesTied++
		if s.r.Float64() > 0.5 {
			g.Outcome = TeamA
		} else {
			g.Outcome = TeamB
		}
	}

	if math.Abs(mathutil.PercentChange(float64(scorea), float64(scoreb))) > 0.20 {
		state.gamesLobsided++
	}
	s.updateGamePlayerStatsAndHistory(g)
	s.moveGamePlayersToIdle(g)
	return g
}

func (s *Simulation) computeGameOutcome(g *Game) (scorea, scoreb int) {
	var besta, bestb int
	for _, player := range g.TeamA {
		scorea += player.NaturalSkill
		if besta < player.NaturalSkill {
			besta = player.NaturalSkill
		}
	}
	for _, player := range g.TeamB {
		scoreb += player.NaturalSkill
		if bestb < player.NaturalSkill {
			bestb = player.NaturalSkill
		}
	}

	scorea += (2 * besta)
	scoreb += (2 * bestb)
	scorea += s.r.Intn(500)
	scoreb += s.r.Intn(500)
	return
}

func (s *Simulation) updateGamePlayerStatsAndHistory(g *Game) {
	for playerID := range g.TeamA {
		s.updatePlayerStatsAndHistory(playerID, g)
	}
	for playerID := range g.TeamB {
		s.updatePlayerStatsAndHistory(playerID, g)
	}
}

func (s *Simulation) updatePlayerStatsAndHistory(playerID uuid.UUID, g *Game) {
	p := s.players[playerID]
	if g.PlayerTeam(p.ID) == g.Outcome {
		p.Wins++
	}
	p.Games++

	p.Recent.Push(g)
	for p.Recent.Len() > s.Config.PlayerRatingHistoryLenOrDefault() {
		_, _ = p.Recent.Pop()
	}
	p.Rating = s.calculatePlayerRating(p)
}

func (s *Simulation) moveGamePlayersToIdle(g *Game) {
	for playerID := range g.TeamA {
		s.movePlayerToIdle(playerID)
	}
	for playerID := range g.TeamB {
		s.movePlayerToIdle(playerID)
	}
}

func (s *Simulation) movePlayerToIdle(playerID uuid.UUID) {
	player := s.players[playerID]
	s.playersInGame.Del(player)
	s.playersIdle.Add(player)
}

func (s *Simulation) moveGamePlayersToInGame(g *Game) {
	for playerID := range g.TeamA {
		s.movePlayerToInGame(playerID)
	}
	for playerID := range g.TeamB {
		s.movePlayerToInGame(playerID)
	}
}

func (s *Simulation) movePlayerToInGame(playerID uuid.UUID) {
	player := s.players[playerID]
	s.playersInQueue.Del(player)
	s.playersInGame.Add(player)
}

func (s *Simulation) generatePlayers() (output Lookup[uuid.UUID, *Player]) {
	output = make(Lookup[uuid.UUID, *Player])
	for x := 0; x < s.Config.PlayerCount; x++ {
		output.Add(s.createPlayer())
	}
	return
}

func (s *Simulation) generateServers() (output Lookup[uuid.UUID, *Server]) {
	output = make(Lookup[uuid.UUID, *Server])
	for x := 0; x < s.Config.ServerCountOrDefault(); x++ {
		output.Add(s.createServer())
	}
	return output
}

func (s *Simulation) createServer() *Server {
	return &Server{
		ID: uuid.V4(),
	}
}

func (s *Simulation) createPlayer() *Player {
	return &Player{
		ID: uuid.V4(),
		NaturalSkill: int(s.randomNormal(
			s.Config.PlayerNaturalRatingMedianOrDefault(),
			s.Config.PlayerNaturalRatingStdDevOrDefault(),
		)),
		Rating: ratingBase,
		Recent: new(c9s.Queue[*Game]),
	}
}

func (s *Simulation) createGame(currentTimestamp time.Time, teamA, teamB []*Player) *Game {
	return &Game{
		ID:          uuid.V4(),
		StartedAt:   currentTimestamp,
		FinishedAt:  currentTimestamp.Add(s.Config.GameDurationOrDefault()),
		TeamA:       NewLookup(teamA),
		RatingTeamA: s.calculateTeamRating(teamA),
		TeamB:       NewLookup(teamB),
		RatingTeamB: s.calculateTeamRating(teamB),
	}
}