private BotController CreateBotControllerFor(EumelGameRoomDefinition def)
{
var players = def.Players
.Select(playerInfo => _playerFactory.GetNewPlayerOfType(playerInfo.Type));
return(new BotController(players, def));
}
static void PlayAgainstBots()
{
var players = new[]
{
Player.CreateBot("Fatz!"),
Player.CreateBot("Hans"),
Player.CreateCustom("YOU", new ConsolePlayer()),
};
var playerFactory = new PlayerFactory()
.RegisterOrOverrideCreator(nameof(ConsolePlayer), () => new ConsolePlayer());
var gameDef = new EumelGameRoomDefinition(
"the game",
players.Select(p => p.Info).ToImmutableList().WithValueSemantics(),
EumelGamePlan.For(players.Length),
new GameRoomSettings(0)
);
var botController = new BotController(players.Select(p => p.Invocable), gameDef);
var lobby = new ActiveLobby(botController, gameDef, GameProgress.NotStarted);
var logger = new ConsoleGameObserver();
lobby.SubscribeWithPreviousEvents(logger);
lobby.GameContext.SubscribeWithPreviousEvents(logger);
while (lobby.HasMoreRounds)
{
lobby.StartNextRound();
}
}
public static void Run()
{
var players = new[]
{
Player.CreateCustom("TrickBoy1", new MaxTrickBoy()),
Player.CreateCustom("O1", new Opportunist()),
Player.CreateCustom("TrickBoy2", new MaxTrickBoy()),
Player.CreateCustom("O1", new Opportunist()),
Player.CreateCustom("O1", new Opportunist()),
Player.CreateCustom("O1", new Opportunist()),
};
for (int repeat = 0; repeat <= 10; repeat++)
{
var scoreTracker = new ScoreTracker();
// scoreTracker.PrintHeader(players);
for (int games = 0; games < 1000; games++)
{
var gameDef = new EumelGameRoomDefinition(
"the game",
players.Select(p => p.Info).ToImmutableList().WithValueSemantics(),
EumelGamePlan.For(players.Length),
new GameRoomSettings(0)
);
var botController = new BotController(players.Select(p => p.Invocable), gameDef);
var room = new ActiveLobby(botController, gameDef, GameProgress.NotStarted);
room.SubscribeWithPreviousEvents(scoreTracker);
while (room.HasMoreRounds)
{
room.StartNextRound();
}
}
Console.WriteLine("Total scores: " + string.Join(", ", Enumerable.Zip(players.Select(p => p.Info.Name), scoreTracker.Scores)));
}
}
public BotController(IEnumerable <IInvokablePlayer> bots, EumelGameRoomDefinition def)
{
_botDelayMs = def.Settings.BotDelayMs;
_bots = bots.ToArray();
if (def.Players.Count != _bots.Length)
{
throw new ArgumentException($"'{nameof(bots)}' must have same length as players in game definition.");
}
}
private GameRoomData ConvertRoomDefinitionToDto(EumelGameRoomDefinition roomDef) =>
new GameRoomData
{
Name = roomDef.Name,
Players = roomDef.Players
.Select(p => new GamePlayerData {
Name = p.Name, IsHuman = p.Type == PlayerType.Human
})
.ToArray()
};
private static EumelGameRoomDefinition GenGameRoomDefinitionFor3Players()
{
var players = Enumerable.Range(1, 3)
.Select(_ => new PlayerInfo("unnamed", PlayerType.Bot))
.ToImmutableList()
.WithValueSemantics();
var plan = EumelGamePlan.For(3);
var gameRoomDef = new EumelGameRoomDefinition("test", players);
return(gameRoomDef);
}
public GameEventHub(EumelGameRoomDefinition definition, GameProgress progress)
{
_gameEventContext = new(definition.Name, -1);
_numPlayers = definition.Players.Count;
_plan = definition.Plan;
// TODO: join event types. Make GameSeriesStarted contents static data of the room
_events = new EventCollection <GameEvent>();
if (progress.LastRoundEvents.Any())
{
ForwardTo(progress);
}
}
public ActiveLobby GetLobbyFor(EumelGameRoomDefinition room)
{
var roomName = room.Name;
lock (_lobbies)
{
if (!_lobbies.ContainsKey(roomName))
{
_lobbies[roomName] = ActivateLobby(room);
}
return(_lobbies[roomName]);
}
}
private ActiveLobby ActivateLobby(EumelGameRoomDefinition room)
{
var roomName = room.Name;
_logger.LogInformation("activating lobby for {roomName}", roomName);
var progress = _eventRepo.GetGameProgress(roomName);
var botController = CreateBotControllerFor(room);
var newLobby = new ActiveLobby(botController, room, progress);
newLobby.Subscribe(_eventPersister);
newLobby.GameContext.Subscribe(_eventPersister);
newLobby.EnsureStarted();
return(newLobby);
}
public ActiveLobby(BotController botController, EumelGameRoomDefinition room, GameProgress progress)
{
Room = room ?? throw new ArgumentException(nameof(room));
_botController = botController ?? throw new ArgumentException(nameof(botController));
_events = new EventCollection <GameSeriesEvent>();
GameContext = new GameEventHub(room, progress);
// TODO when / how is an active lobby disposed
GameContext.OnGameEvent += async(s, e) => await GameEventHandler(s, e);
GameContext.OnGameEvent += async(s, e) => await _botController.OnGameEvent(s, e);
SetProgress(progress);
}
public static PersistedEumelGame CreateFrom(EumelGameRoomDefinition room)
{
if (room.Plan != EumelGamePlan.For(room.Players.Count))
{
throw new NotImplementedException($"can only persist simple variants of {nameof(EumelGamePlan)}");
}
return(new PersistedEumelGame
{
Name = room.Name,
Players = room.Players
.Select(pi => new PersistedPlayer {
Name = pi.Name, Type = pi.Type
})
.ToList(),
// Rounds = room.Events.OfType<RoundStarted>().Select((rse, index) => new PersistedGameRound{
// Index = index,
// StartingPlayerIndex = rse.Settings.StartingPlayerIndex,
// NumTricks = rse.Settings.TricksToPlay,
// }).ToList()
});
}
public ActionResult <GameRoomData> Create(GameRoomData roomData)
{
var name = roomData.Name;
if (string.IsNullOrWhiteSpace(name))
{
throw new System.ArgumentException("invalid room name given");
}
if (_repo.ExistsWithName(name))
{
return(BadRequest($"Room name '{name}' taken"));
}
var players = roomData.Players
.Select(p => new PlayerInfo(p.Name, p.IsHuman ? PlayerType.Human : PlayerType.Bot))
.ToList();
var room = new EumelGameRoomDefinition(name, players);
_repo.Insert(room);
return(NoContent());
// return CreatedAtRoute(nameof(GetRoom), new { name = room.Name }, room);
}
public void Insert(EumelGameRoomDefinition room)
{
_rooms.Add(room.Name.ToLowerInvariant(), room);
}
public void Insert(EumelGameRoomDefinition room)
{
_context.Games.Add(PersistedEumelGame.CreateFrom(room));
_context.SaveChanges();
}
