chk
/
KoogleV4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

dev

This commit is contained in:
Christian Kauer 2023-12-31 10:38:21 +01:00
parent 0331e7b2c3
commit a69a8f450d
10 changed files with 133 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
GameHandler/ExpenseHandler.cs
View File

@ -23,29 +23,25 @@ namespace GameHandler
_expenseRepository = expenseRepository;
}
public async Task<ExpenseModel> HandleGameExenseEventArgs(GameExenseEventArgs gameExenseEventArgs, ExpenseModel expenseModelToAppend)
public async Task<IEnumerable<PlayerExpense>> HandleGameExenseEventArgs(GameExenseEventArgs gameExenseEventArgs)
{
if (!gameExenseEventArgs.PlayerIds.Any(_ => _ == gameExenseEventArgs.PlayerId))
{
throw new InvalidPinThrowException($"Player {gameExenseEventArgs.PlayerId} not found");
}
List<PlayerExpense> memberExpenses = PrepareResult(ref expenseModelToAppend);
List<PlayerExpense> memberExpenses = new List<PlayerExpense>(); //PrepareResult(ref expenseModelToAppend);
var triggers = gameExenseEventArgs.Triggers;
await AssignExpenses(gameExenseEventArgs.PlayerId, gameExenseEventArgs.PlayerIds, memberExpenses, triggers,
gameExenseEventArgs.GameStateId);
await AssignExpenses(gameExenseEventArgs.PlayerId, gameExenseEventArgs.PlayerIds, memberExpenses, triggers);
return expenseModelToAppend with { MemberExpenses = memberExpenses.ToArray() };
return memberExpenses;
}
private async Task AssignExpenses(int playerId, int[] playerIds,
List<PlayerExpense> memberExpenses, ExpenseTrigger[] triggers,
Guid gameStateId)
private async Task AssignExpenses(int playerId, int[] playerIds, List<PlayerExpense> memberExpenses, ExpenseTrigger[] triggers)
{
var list = await _expenseRepository.GetAll();
var destExpenses = list
.Where(_ => _.ExpenseTriggers.Any(et => triggers.Any(et2 => et2 == et)));
var destExpenses = list.Where(_ => _.ExpenseTriggers.Any(et => triggers.Any(et2 => et2 == et)));
var inversePlayers = playerIds.Where(_ => _ != playerId);
foreach (var expense in destExpenses)
@ -54,41 +50,39 @@ namespace GameHandler
{
foreach (var player in inversePlayers)
{
memberExpenses.Add(PlayerExpense.Create(player, expense, gameStateId));
memberExpenses.Add(PlayerExpense.Create(player, expense));
}
}
else
{
memberExpenses.Add(PlayerExpense.Create(playerId, expense, gameStateId));
memberExpenses.Add(PlayerExpense.Create(playerId, expense));
}
}
}
public async Task<ExpenseModel> CheckThrow(BoardState currentState, PinThrow pinThrow, int[] PlayerIds,
Guid gameStateId,
ExpenseModel expenseModelToAppend = null)
public async Task<IEnumerable<PlayerExpense>> CheckThrow(BoardState currentState, PinThrow pinThrow, int[] PlayerIds)
{
if (!PlayerIds.Any(_ => _ == pinThrow.PlayerId))
{
throw new InvalidPinThrowException($"Player {pinThrow.PlayerId} not found");
}
List<PlayerExpense> memberExpenses = PrepareResult(ref expenseModelToAppend);
List<PlayerExpense> memberExpenses = new List<PlayerExpense>(); //PrepareResult(ref expenseModelToAppend);
var triggers = pinThrow.GetExpenseTriggers(currentState);
await AssignExpenses(pinThrow.PlayerId, PlayerIds, memberExpenses, triggers, gameStateId);
await AssignExpenses(pinThrow.PlayerId, PlayerIds, memberExpenses, triggers);
return expenseModelToAppend with { MemberExpenses = memberExpenses.ToArray() };
}
private static List<PlayerExpense> PrepareResult(ref ExpenseModel expenseModelToAppend)
{
if (expenseModelToAppend == null)
{
expenseModelToAppend = new ExpenseModel(Array.Empty<PlayerExpense>());
}
var memberExpenses = new List<PlayerExpense>(expenseModelToAppend.MemberExpenses);
return memberExpenses;
}
//private static List<PlayerExpense> PrepareResult(ref ExpenseModel expenseModelToAppend)
//{
// if (expenseModelToAppend == null)
// {
// expenseModelToAppend = new ExpenseModel(Array.Empty<PlayerExpense>());
// }
// var memberExpenses = new List<PlayerExpense>(expenseModelToAppend.MemberExpenses);
// return memberExpenses;
//}
}
}

8
GameHandler/GameExenseEventArgs.cs
View File

@ -10,16 +10,14 @@ namespace GameHandler
public class GameExenseEventArgs : EventArgs
{
public int[] PlayerIds { get; set; }
public int PlayerId { get; set; }
public Guid GameStateId { get; set; }
public int PlayerId { get; set; }
public ExpenseTrigger[] Triggers { get; set; }
public GameExenseEventArgs(int playerId, ExpenseTrigger[] triggers, int[] playerIds, Guid gameStateId)
public GameExenseEventArgs(int playerId, ExpenseTrigger[] triggers, int[] playerIds)
{
PlayerId = playerId;
Triggers = triggers;
PlayerIds = playerIds;
GameStateId = gameStateId;
PlayerIds = playerIds;
}
}
}

12
GameHandler/GameHandler/DeathGameHandler.cs
View File

@ -73,17 +73,17 @@ namespace GameHandler.DeathGame
}
public IGameModel Update(PinThrow pinThrow, IGameModel gameModel, BoardState boardStateBeforeUpdate,
ThrowState throwStateAfterUpdate, Guid gameStateId)
ThrowState throwStateAfterUpdate)
{
var isTrowIntoAllPins = boardStateBeforeUpdate.PinPicture.UpCount == 9;
var boardCleared = pinThrow.IsCleared;
var firstThrowInRound = throwStateAfterUpdate.ThrowCount == 1;
return CalcNextModel(gameModel as DeathGameModel, pinThrow.PinCount,
isTrowIntoAllPins, boardCleared, firstThrowInRound, gameStateId);
isTrowIntoAllPins, boardCleared, firstThrowInRound);
}
public DeathGameModel CalcNextModel(DeathGameModel gm, int pinCount, bool isTrowIntoAllPins,
bool boardCleared, bool firstThrowInRound, Guid gameStateId)
bool boardCleared, bool firstThrowInRound)
{
var current = gm.Coffins.First();
var next = gm.Coffins.Skip(1).First();
@ -96,7 +96,7 @@ namespace GameHandler.DeathGame
incX = true;
if ((pinCount < 3) && firstThrowInRound)
{
OnFirstThrowFailed(gm, current, gameStateId);
OnFirstThrowFailed(gm, current);
incLine = true;
}
}
@ -195,9 +195,9 @@ namespace GameHandler.DeathGame
return result;
}
private void OnFirstThrowFailed(DeathGameModel gm, Coffin current, Guid gameStateId)
private void OnFirstThrowFailed(DeathGameModel gm, Coffin current)
{
OnGameExpenseOccured(new GameExenseEventArgs(current.PlayerId, new[] { ExpenseTrigger.FirstThrowFail }, gm.PlayerIds, gameStateId));
OnGameExpenseOccured(new GameExenseEventArgs(current.PlayerId, new[] { ExpenseTrigger.FirstThrowFail }, gm.PlayerIds));
}
public static string GameName()

2
GameHandler/GameHandler/FreeGameHandler.cs
View File

@ -34,7 +34,7 @@ namespace GameHandler.GameHandler
}
public IGameModel Update(PinThrow pinThrow, IGameModel gameModel, BoardState boardStateBeforeUpdate,
ThrowState throwStateAfterUpdate, Guid gameStateId)
ThrowState throwStateAfterUpdate)
{
if (gameModel == null)
{

28
GameHandler/GameService.cs
View File

@ -69,8 +69,6 @@ namespace GameHandler
InitGameServiceBehaviour(gameName);
var state = await InitGameState(playerIds, gameSettings, gameName);
await _gameStateHandler.Add(state);
await _gameStateHandler.Add(ExpenseModel.Create());
await _gameStateHandler.Save();
return state;
@ -82,8 +80,11 @@ namespace GameHandler
var throwState = ThrowState.Create(_gh.ThrowMode(), _gh.ThrowsPerRount());
_game = await _gameStateHandler.CreateNewGame(gameName);
_gameStateHandler.StartNewState();
var state = GameState.Create(_game.Id, gameName, throwState, _gh.GetCurrentPlayerId(gm), gm);
_gameStateHandler.Add(state);
return state;
}
@ -99,8 +100,8 @@ namespace GameHandler
private void _gh_GameExpenseOccured(object? sender, EventArgs e)
{
var expenseModel = _eh.HandleGameExenseEventArgs(e as GameExenseEventArgs, _gameStateHandler.ExpenseModel).Result;
_gameStateHandler.Add(expenseModel);
var items = _eh.HandleGameExenseEventArgs(e as GameExenseEventArgs).Result;
_gameStateHandler.Add(items);
//_lastState = _lastState with { ExpenseModel = expenseModel };
}
@ -111,24 +112,25 @@ namespace GameHandler
throw new InvalidGameStateExcpetion("Game not started");
}
var lastGameState = _gameStateHandler.GameState;
var nextGameStateId = Guid.NewGuid();
_gameStateHandler.StartNewState();
var lastGameState = _gameStateHandler.GameState;
var boardStateBeforeUpdate = lastGameState.ThrowState.BoardState;
pinThrow = AutoCompletePlayerId(pinThrow);
var throwStateAfterUpdate = _th.Update(lastGameState.ThrowState, pinThrow);
var gameModel = _gh.Update(pinThrow, lastGameState.GameModel, boardStateBeforeUpdate, throwStateAfterUpdate, nextGameStateId);
var expenseModel = await _eh.CheckThrow(throwStateAfterUpdate.BoardState, pinThrow, gameModel.PlayerIds, nextGameStateId,
_gameStateHandler.ExpenseModel);
var gameModel = _gh.Update(pinThrow, lastGameState.GameModel, boardStateBeforeUpdate, throwStateAfterUpdate);
var expenseModel = await _eh.CheckThrow(throwStateAfterUpdate.BoardState, pinThrow, gameModel.PlayerIds);
var newGameState = lastGameState with { Id = nextGameStateId, ThrowState = throwStateAfterUpdate, GameModel = gameModel, NextPlayerId = _gh.GetCurrentPlayerId(gameModel) };
var newGameState = lastGameState with { Id = _gameStateHandler.NextGameStateId, ThrowState = throwStateAfterUpdate, GameModel = gameModel, NextPlayerId = _gh.GetCurrentPlayerId(gameModel) };
_gameStateHandler.Add(newGameState);
_gameStateHandler.Add(expenseModel);
await _gameStateHandler.Add(newGameState);
await _gameStateHandler.Add(expenseModel);
await _gameStateHandler.Save();
// todo: bei undo wird gamestate nicht korrekt gelöscht
return newGameState;
}

117
GameHandler/GameStateHandler.cs
View File

@ -27,11 +27,11 @@ namespace GameHandler
private Guid _gameStateId;
private List<GameStateHandlerItem<GameState>> gameStates = new List<GameStateHandlerItem<GameState>>();
private List<GameStateHandlerItem<ExpenseModel>> expenseModels = new List<GameStateHandlerItem<ExpenseModel>>();
//private List<GameStateHandlerItem<ExpenseModel>> expenseModels = new List<GameStateHandlerItem<ExpenseModel>>();
private List<GameStateHandlerItem<PlayerExpense>> memberExpenses = new List<GameStateHandlerItem<PlayerExpense>>();
private List<GameStateHandlerItem<GameState>> redoableGameStates = new List<GameStateHandlerItem<GameState>>();
private List<GameStateHandlerItem<ExpenseModel>> redoableExpenseModels = new List<GameStateHandlerItem<ExpenseModel>>();
//private List<GameStateHandlerItem<ExpenseModel>> redoableExpenseModels = new List<GameStateHandlerItem<ExpenseModel>>();
private List<GameStateHandlerItem<PlayerExpense>> redoableMeberExpenses = new List<GameStateHandlerItem<PlayerExpense>>();
private IGameRepository _gameRepository;
@ -43,18 +43,18 @@ namespace GameHandler
_expenseRepository = expenseRepository;
}
public ExpenseModel ExpenseModel
{
get
{
var res = expenseModels.LastOrDefault();
if (res != null)
{
return res.Data;
}
return null;
}
}
//public ExpenseModel ExpenseModel
//{
// get
// {
// var res = expenseModels.LastOrDefault();
// if (res != null)
// {
// return res.Data;
// }
// return null;
// }
//}
public GameState GameState
{
@ -69,21 +69,50 @@ namespace GameHandler
}
}
internal async Task Add(ExpenseModel expenseModel)
public Guid NextGameStateId
{
if (ExpenseModel != null)
get
{
if (!expenseModel.Equals(ExpenseModel))
if (_gameStateId == Guid.Empty)
{
expenseModels.Add(new GameStateHandlerItem<ExpenseModel>(_gameStateId, expenseModel));
_gameStateId = Guid.NewGuid();
}
}
else
{
expenseModels.Add(new GameStateHandlerItem<ExpenseModel>(_gameStateId, expenseModel));
return _gameStateId;
}
}
public Guid StartNewState()
{
_gameStateId = Guid.NewGuid();
return _gameStateId;
}
internal void Add(IEnumerable<PlayerExpense> playerExpenses)
{
foreach (var playerExpense in playerExpenses)
{
Add(playerExpense);
}
}
internal void Add(PlayerExpense playerExpense)
{
var model = playerExpense with { GamestateId = _gameStateId };
memberExpenses.Add(new GameStateHandlerItem<PlayerExpense>(_gameStateId, model));
}
internal void Add(GameState newState)
{
if (newState.Id != Guid.Empty && newState.Id != NextGameStateId)
{
throw new InvalidDataException("GameState is not new");
}
var model = newState with { Id = _gameStateId, Counter = gameStates.Count + 1 };
var item = new GameStateHandlerItem<GameState>(_gameStateId, model);
gameStates.Add(item);
}
public async Task Save()
{
await DeleteRedoableStates(); // first delete undone items - otherwise ID is not unique in DB
@ -91,17 +120,22 @@ namespace GameHandler
var gameState = gameStates.FirstOrDefault(_ => _.GameStateId == _gameStateId);
await Save(gameState);
var expenseModelItem = expenseModels.FirstOrDefault(_ => _.GameStateId == _gameStateId);
if (expenseModelItem != null)
foreach (var memberExpense in memberExpenses.Where(_ => _.GameStateId == _gameStateId))
{
var expenseModel = expenseModelItem.Data;
foreach (var memberExpense in expenseModel.MemberExpenses.Where(_ => _.GamestateId == _gameStateId))
{
var item = new GameStateHandlerItem<PlayerExpense>(memberExpense.GamestateId, memberExpense);
memberExpenses.Add(item);
await Save(item);
}
await Save(memberExpense);
}
//var expenseModelItem = expenseModels.FirstOrDefault(_ => _.GameStateId == _gameStateId);
//if (expenseModelItem != null)
//{
// var expenseModel = expenseModelItem.Data;
// foreach (var memberExpense in expenseModel.MemberExpenses.Where(_ => _.GamestateId == _gameStateId))
// {
// var item = new GameStateHandlerItem<PlayerExpense>(memberExpense.GamestateId, memberExpense);
// memberExpenses.Add(item);
// await Save(item);
// }
//}
}
@ -120,18 +154,11 @@ namespace GameHandler
redoableMeberExpenses.Clear();
}
redoableExpenseModels.Clear();
//redoableExpenseModels.Clear();
}
internal async Task Add(GameState newState)
{
if (!newState.Equals(GameState))
{
_gameStateId = newState.Id;
var item = new GameStateHandlerItem<GameState>(_gameStateId, newState with { Counter = gameStates.Count + 1 });
gameStates.Add(item);
}
}
private async Task Save(GameStateHandlerItem<PlayerExpense> item)
{
await _expenseRepository.Save(item.Data);
@ -154,11 +181,11 @@ namespace GameHandler
var redoId = redoableGameStates.Last().GameStateId;
gameStates.AddRange(redoableGameStates.Where(_ => _.GameStateId == redoId));
expenseModels.AddRange(redoableExpenseModels.Where(_ => _.GameStateId == redoId));
//expenseModels.AddRange(redoableExpenseModels.Where(_ => _.GameStateId == redoId));
memberExpenses.AddRange(redoableMeberExpenses.Where(_ => _.GameStateId == redoId));
redoableGameStates.RemoveAll(_ => _.GameStateId == redoId);
redoableExpenseModels.RemoveAll(_ => _.GameStateId == redoId);
//redoableExpenseModels.RemoveAll(_ => _.GameStateId == redoId);
redoableMeberExpenses.RemoveAll(_ => _.GameStateId == redoId);
}
@ -174,11 +201,11 @@ namespace GameHandler
}
redoableGameStates.AddRange(gameStates.Where(_ => _.GameStateId == _gameStateId));
redoableExpenseModels.AddRange(expenseModels.Where(_ => _.GameStateId == _gameStateId));
//redoableExpenseModels.AddRange(expenseModels.Where(_ => _.GameStateId == _gameStateId));
redoableMeberExpenses.AddRange(memberExpenses.Where(_ => _.GameStateId == _gameStateId));
gameStates.RemoveAll(_ => _.GameStateId == _gameStateId);
expenseModels.RemoveAll(_ => _.GameStateId == _gameStateId);
//expenseModels.RemoveAll(_ => _.GameStateId == _gameStateId);
memberExpenses.RemoveAll(_ => _.GameStateId == _gameStateId);
_gameStateId = gameStates.Last().GameStateId;

2
GameModel/Contracts/IGameHandler.cs
View File

@ -23,7 +23,7 @@ namespace GameModel.Contract
int GetCurrentPlayerId(IGameModel gameModel);
IGameModel Update(PinThrow pinThrow, IGameModel gameModel, BoardState boardStateBeforeUpdate,
ThrowState throwStateAfterUpdate, Guid gameStateId);
ThrowState throwStateAfterUpdate);
event EventHandler GameExpenseOccured;
}

26
GameModel/ExpenseModel.cs
View File

@ -6,20 +6,20 @@ using System.Threading.Tasks;
namespace GameModel
{
public record ExpenseModel(PlayerExpense[] MemberExpenses)
{
public virtual bool Equals(ExpenseModel other)
{
if (ReferenceEquals(null, other)) return false;
//public record ExpenseModel(PlayerExpense[] MemberExpenses)
//{
// public virtual bool Equals(ExpenseModel other)
// {
// if (ReferenceEquals(null, other)) return false;
return MemberExpenses.SequenceEqual(other.MemberExpenses);
}
// return MemberExpenses.SequenceEqual(other.MemberExpenses);
// }
public override int GetHashCode() => MemberExpenses.GetHashCode();
// public override int GetHashCode() => MemberExpenses.GetHashCode();
public static ExpenseModel Create()
{
return new ExpenseModel(Array.Empty<PlayerExpense>());
}
}
// public static ExpenseModel Create()
// {
// return new ExpenseModel(Array.Empty<PlayerExpense>());
// }
//}
}

2
GameModel/GameState.cs
View File

@ -12,7 +12,7 @@ namespace GameModel
{
public static GameState Create(Guid gameId, string gameName, ThrowState throwState, int nextPlayerId, IGameModel gameModel)
{
return new GameState(Guid.NewGuid(), gameId, gameName, throwState, nextPlayerId, gameModel, 0);
return new GameState(Guid.Empty, gameId, gameName, throwState, nextPlayerId, gameModel, 0);
}
}
}

6
GameModel/PlayerExpense.cs
View File

@ -14,11 +14,5 @@ namespace GameModel
return new PlayerExpense(Guid.NewGuid(), playerId, expense.Id, expense.ExpenseType,
DateTime.Now, expense.Price, expense.Name, Guid.Empty);
}
public static PlayerExpense Create(int playerId, Expense expense, Guid gameStateId)
{
return new PlayerExpense(Guid.NewGuid(), playerId, expense.Id, expense.ExpenseType,
DateTime.Now, expense.Price, expense.Name, gameStateId);
}
}
}