public void PlayStep_PlayerCanMoveUp()
{
const int maxRows = 4;
const int maxColumns = 4;
var processor = new GameStateProcessor();
var player = new PlayerState {
Column = 1, Row = 1, Moves = 0
};
IList <IList <Cell> > grid = TestUtils.MakeEmptyGrid(maxRows, maxColumns);
IGameState state = new GameState(player, grid, 5, maxRows, maxColumns);
processor.PlayStep(state, PlayerDirection.Up);
Assert.AreEqual(0, player.Row);
}
public void PlayStep_WhenPlayerAtRightmostOfGrid_PlayerDoesNotMoveRight()
{
const int maxRows = 4;
const int maxColumns = 4;
var processor = new GameStateProcessor();
var player = new PlayerState {
Column = maxColumns - 1, Row = 1, Moves = 0
};
IList <IList <Cell> > grid = TestUtils.MakeEmptyGrid(maxRows, maxColumns);
IGameState state = new GameState(player, grid, 5, maxRows, maxColumns);
processor.PlayStep(state, PlayerDirection.Right);
Assert.AreEqual(maxColumns - 1, player.Column);
}
public void PlayStep_WhenPlayerIsMoved_IncreasesPlayerMovesCounter()
{
const int maxRows = 4;
const int maxColumns = 4;
var processor = new GameStateProcessor();
var player = new PlayerState {
Column = 0, Row = 0, Moves = 0
};
IList <IList <Cell> > grid = TestUtils.MakeEmptyGrid(maxRows, maxColumns);
IGameState state = new GameState(player, grid, 5, maxRows, maxColumns);
processor.PlayStep(state, PlayerDirection.Right);
Assert.AreEqual(1, player.Moves);
}
public void FullStateResyncsCurTick()
{
var timingMock = new Mock <IGameTiming>();
timingMock.SetupProperty(p => p.CurTick);
var timing = timingMock.Object;
var processor = new GameStateProcessor(timing);
processor.AddNewState(GameStateFactory(0, 1));
processor.AddNewState(GameStateFactory(1, 2));
processor.AddNewState(GameStateFactory(2, 3)); // buffer is now full, otherwise cannot calculate states.
// calculate states for first tick
timing.CurTick = new GameTick(3);
processor.ProcessTickStates(timing.CurTick, out _, out _);
Assert.That(timing.CurTick.Value, Is.EqualTo(1));
}
public void FillBufferBlocksProcessing()
{
var timingMock = new Mock <IGameTiming>();
timingMock.SetupProperty(p => p.CurTick);
var timing = timingMock.Object;
var processor = new GameStateProcessor(timing);
processor.AddNewState(GameStateFactory(0, 1));
processor.AddNewState(GameStateFactory(1, 2)); // buffer is at 2/3, so processing should be blocked
// calculate states for first tick
timing.CurTick = new GameTick(3);
var result = processor.ProcessTickStates(new GameTick(1), out _, out _);
Assert.That(result, Is.False);
Assert.That(timing.CurTick.Value, Is.EqualTo(1));
}
public void PlayStep_WhenPlayerIsMoved_PreviousPositionIsUncovered()
{
const int maxRows = 4;
const int maxColumns = 4;
var processor = new GameStateProcessor();
var player = new PlayerState {
Column = 0, Row = 0, Moves = 0
};
IList <IList <Cell> > grid = TestUtils.MakeEmptyGrid(maxRows, maxColumns);
IGameState state = new GameState(player, grid, 5, maxRows, maxColumns);
state.GameGrid[0][0].IsUncovered = false;
processor.PlayStep(state, PlayerDirection.Right);
Assert.IsTrue(state.GameGrid[0][0].IsUncovered);
}
/// <summary>
/// Creates a new GameTiming and GameStateProcessor, fills the processor with enough states, and calculate the first tick.
/// CurTick = 1, states 1 - 3 are in the buffer.
/// </summary>
private static (IGameTiming timing, GameStateProcessor processor) SetupProcessorFactory()
{
var timingMock = new Mock <IGameTiming>();
timingMock.SetupProperty(p => p.CurTick);
timingMock.SetupProperty(p => p.TickTimingAdjustment);
var timing = timingMock.Object;
var processor = new GameStateProcessor(timing);
processor.AddNewState(GameStateFactory(0, 1));
processor.AddNewState(GameStateFactory(1, 2));
processor.AddNewState(GameStateFactory(2, 3)); // buffer is now full, otherwise cannot calculate states.
// calculate states for first tick
timing.CurTick = new GameTick(1);
processor.ProcessTickStates(timing.CurTick, out _, out _);
return(timing, processor);
}
public void FillBufferAndCalculateFirstState()
{
var timingMock = new Mock <IGameTiming>();
timingMock.SetupProperty(p => p.CurTick);
var timing = timingMock.Object;
var processor = new GameStateProcessor(timing);
processor.AddNewState(GameStateFactory(0, 1));
processor.AddNewState(GameStateFactory(1, 2));
processor.AddNewState(GameStateFactory(2, 3)); // buffer is now full, otherwise cannot calculate states.
// calculate states for first tick
timing.CurTick = new GameTick(1);
var result = processor.ProcessTickStates(new GameTick(1), out var curState, out var nextState);
Assert.That(result, Is.True);
Assert.That(curState, Is.Not.Null);
Assert.That(curState !.Extrapolated, Is.False);
Assert.That(curState.ToSequence.Value, Is.EqualTo(1));
Assert.That(nextState, Is.Null);
}
