public List <List <Field> > CreateInitialBoard(int goalsHeight, int tasksHeight, int boardWidth)
{
List <List <Field> > board = new List <List <Field> >();
for (int i = 0; i < boardWidth; i++)
{
board.Add(new List <Field>());
for (int j = 0; j < tasksHeight + 2 * goalsHeight; j++)
{
if (j >= goalsHeight && j < goalsHeight + tasksHeight)
{
TaskField tF = new TaskField();
tF.x = (uint)i;
tF.y = (uint)j;
tF.pieceIdSpecified = false;
tF.distanceToPiece = -3;
board[i].Add(tF);
}
else
{
GoalField gF = new GoalField();
gF.x = (uint)i;
gF.y = (uint)j;
gF.type = GoalFieldType.unknown;
gF.team = (i < goalsHeight) ? TeamColour.blue : TeamColour.red;
board[i].Add(gF);
}
}
}
return(board);
}
public void PlayerMovesFromTaskFieldToEmptyTaskField()
{
// from (2, 4) to (2, 5)
InitGameMaster();
var Player = GetPlayer("testGUID-0004", 10, TeamColour.blue, ActionType.Move);
Player.SetLocation(2, 4);
RegisterPlayer(Player, Player.GUID);
var taskField = new TaskField(2, 5)
{
pieceIdSpecified = true,
pieceId = 250,
timestamp = DateTime.Now,
};
DataAgent data = new DataAgent(Player.ID)
{
PlayerGUID = guid,
GameFinished = false,
PlayerLocation = new GameArea.GameObjects.Location(2, 5),
Tasks = new GameArea.GameObjects.TaskField[] { new GameArea.GameObjects.TaskField(taskField) }
};
// action: Player moves up to (2,5)
data.Process(Player.Controller);
// assert
Assert.AreEqual(new GameArea.GameObjects.Location(2, 5), Player.Location);
Assert.IsNull(Player.GetBoard.GetField(2, 4).Player);
Assert.IsNull(Player.GetBoard.GetField(2, 5).Player);
Assert.AreEqual(taskField.pieceId, Player.GetBoard.GetTaskField(2, 5).Piece.ID);
}
public async Task <IHttpActionResult> PutTaskField(int id, TaskField taskField)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != taskField.Id)
{
return(BadRequest());
}
db.Entry(taskField).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TaskFieldExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task TestDestroyAsync()
{
var conf = GenerateConfiguration();
var socketClient = GenerateSocketClient();
var player = GenerateGMPlayer(conf, socketClient);
var piece = new ShamPiece();
player.Holding = piece;
var field = new TaskField(0, 0);
Assert.True(field.MoveHere(player));
// Act
bool detroyed = await player.DestroyHoldingAsync(CancellationToken.None);
Assert.True(detroyed);
Assert.True(player.Holding is null);
Assert.Equal(MessageID.DestructionAnswer, lastSended.MessageID);
Assert.Null(prevSended);
// delay
await Task.Delay(conf.DestroyPenalty * 2);
lastSended = null;
detroyed = await player.DestroyHoldingAsync(CancellationToken.None);
Assert.False(detroyed);
}
public async Task TestCheckHoldingAsync()
{
var conf = GenerateConfiguration();
var socketClient = GenerateSocketClient();
var player = GenerateGMPlayer(conf, socketClient);
var piece = new ShamPiece();
var field = new TaskField(0, 0);
Assert.True(field.MoveHere(player));
Assert.True(player.Holding is null);
// Act
await player.CheckHoldingAsync(CancellationToken.None);
Assert.True(player.Holding is null);
Assert.Null(prevSended);
await Task.Delay(conf.CheckForShamPenalty * 2);
player.Holding = piece;
lastSended = null;
await player.CheckHoldingAsync(CancellationToken.None);
Assert.Equal(MessageID.CheckAnswer, lastSended.MessageID);
}
public async Task TestMoveAsyncToFull()
{
var gm = GenerateGM();
Func <AbstractField, int?> getClosestPiece = (AbstractField pos) => InvokeGetClosestPiece(gm, pos);
var firstPlayer = GenerateGMPlayer();
var firstPlayerField = new TaskField(0, 0);
Assert.True(firstPlayerField.MoveHere(firstPlayer));
var secondPlayer = GenerateGMPlayer();
var secondPlayerField = new TaskField(0, 1);
Assert.True(secondPlayerField.MoveHere(secondPlayer));
// Act
bool moved = await firstPlayer.MoveAsync(secondPlayerField, getClosestPiece, CancellationToken.None);
Assert.False(moved);
Assert.Equal(firstPlayerField, firstPlayer.Position);
Assert.Equal(secondPlayerField, secondPlayer.Position);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
Assert.Null(prevSended);
var payload = (MoveAnswerPayload)lastSended.Payload;
Assert.False(payload.MadeMove);
Position expectedPos = firstPlayerField.GetPosition();
Assert.True(payload.CurrentPosition.Equals(expectedPos));
}
public List <List <Field> > SetInitialBoard(int goalAreaLength, int taskAreaLength, int boardWidth)
{
List <List <Field> > boardList = new List <List <Field> >();
for (int i = 0; i < boardWidth; i++)
{
boardList.Add(new List <Field>());
for (int j = 0; j < taskAreaLength + 2 * goalAreaLength; j++)
{
if (j >= goalAreaLength && j < goalAreaLength + taskAreaLength)
{
TaskField tF = new TaskField();
tF.x = (uint)i;
tF.y = (uint)j;
tF.pieceIdSpecified = false;
boardList[i].Add(tF);
}
else
{
GoalField gF = new GoalField();
gF.x = (uint)i;
gF.y = (uint)j;
gF.type = GoalFieldType.nongoal;
gF.team = (i < goalAreaLength) ? TeamColour.blue : TeamColour.red;
boardList[i].Add(gF);
}
}
}
return(boardList);
}
public async Task TestMoveAsyncToRelease()
{
var gm = GenerateGM();
Func <AbstractField, int?> getClosestPiece = (AbstractField pos) => InvokeGetClosestPiece(gm, pos);
var firstPlayer = GenerateGMPlayer();
var firstPlayerField = new TaskField(0, 0);
Assert.True(firstPlayerField.MoveHere(firstPlayer));
var secondPlayer = GenerateGMPlayer();
var secondPlayerField = new TaskField(0, 1);
var secondPlayerEndField = new TaskField(1, 1);
Assert.True(secondPlayerField.MoveHere(secondPlayer));
// Act
bool moved = await secondPlayer.MoveAsync(secondPlayerEndField, getClosestPiece, CancellationToken.None);
Assert.True(moved);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
var payload = (MoveAnswerPayload)lastSended.Payload;
Assert.True(payload.MadeMove);
Assert.Null(prevSended);
lastSended = null;
moved = await firstPlayer.MoveAsync(secondPlayerField, getClosestPiece, CancellationToken.None);
Assert.True(moved);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
payload = (MoveAnswerPayload)lastSended.Payload;
Assert.True(payload.MadeMove);
}
private void ClearPieceFromField(TaskField taskField)
{
if (taskField.PieceId.HasValue)
{
taskField.PieceId = null;
}
}
public async Task TestMoveAsyncToEmpty()
{
var gm = GenerateGM();
Func <AbstractField, int?> getClosestPiece =
(AbstractField pos) => gm.Invoke <GM, int?>("FindClosestPiece", new object[] { pos });
var player = GenerateGMPlayer();
var playerStartField = new TaskField(0, 0);
var playerEndField = new TaskField(0, 1);
Assert.True(playerStartField.MoveHere(player));
bool moved = await player.MoveAsync(playerEndField, getClosestPiece, CancellationToken.None);
Assert.True(moved);
Assert.Equal(playerEndField, player.Position);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
Assert.Null(prevSended);
var payload = (MoveAnswerPayload)lastSended.Payload;
Assert.True(payload.MadeMove);
Position expectedPos = playerEndField.GetPosition();
Assert.True(payload.CurrentPosition.Equals(expectedPos));
}
private TaskField FindFieldWithPiece(int pieceId)
{
TaskField result = null;
for (var i = 0; i < Width; ++i)
{
for (var j = GoalAreaSize; j < TaskAreaSize + GoalAreaSize; ++j)
{
var field = Content[i, j];
if (!IsLocationInTaskArea(field))
{
continue;
}
var taskFiled = (TaskField)field;
if (taskFiled.PieceId != pieceId)
{
continue;
}
result = taskFiled;
break;
}
}
return(result);
}
private void HandlePieceInField(int playerId, TaskField taskField)
{
if (!taskField.PieceId.HasValue)
{
return;
}
var oldPieceField = FindFieldWithPiece(taskField.PieceId.Value);
if (oldPieceField != null)
{
if (taskField.IsNewerThan(oldPieceField))
{
oldPieceField.PieceId = null;
}
else
{
taskField.PieceId = null;
}
}
//place piece
if (Players[playerId].Piece != null && taskField.PieceId == Players[playerId].Piece.Id)
{
Players[playerId].Piece = null;
}
}
public async Task TestPickAsync()
{
var conf = GenerateConfiguration();
var socketClient = GenerateSocketClient();
var player = GenerateGMPlayer(conf, socketClient);
var piece = new ShamPiece();
var field = new TaskField(0, 0);
Assert.True(field.MoveHere(player));
Assert.True(player.Holding is null);
// Act
bool picked = await player.PickAsync(CancellationToken.None);
Assert.False(picked);
Assert.True(player.Holding is null);
Assert.Equal(MessageID.PickError, lastSended.MessageID);
var payload = (PickErrorPayload)lastSended.Payload;
Assert.Equal(PickError.NothingThere, payload.ErrorSubtype);
Assert.Null(prevSended);
// delay
await Task.Delay(conf.PickupPenalty * 2);
field.Put(piece);
lastSended = null;
picked = await player.PickAsync(CancellationToken.None);
Assert.True(picked);
Assert.Equal(piece, player.Holding);
Assert.Equal(MessageID.PickAnswer, lastSended.MessageID);
// delay
await Task.Delay(conf.PickupPenalty * 2);
lastSended = null;
picked = await player.PickAsync(CancellationToken.None);
Assert.False(picked);
Assert.Equal(piece, player.Holding);
Assert.Equal(MessageID.PickError, lastSended.MessageID);
payload = (PickErrorPayload)lastSended.Payload;
Assert.Equal(PickError.Other, payload.ErrorSubtype);
// delay
await Task.Delay(conf.PickupPenalty * 2);
var secondPiece = new NormalPiece();
field.Put(secondPiece);
lastSended = null;
picked = await player.PickAsync(CancellationToken.None);
Assert.False(picked);
Assert.Equal(piece, player.Holding);
Assert.Equal(MessageID.PickError, lastSended.MessageID);
payload = (PickErrorPayload)lastSended.Payload;
Assert.Equal(PickError.Other, payload.ErrorSubtype);
}
public async Task TestMoveAsyncAfterPenalty()
{
var gm = GenerateGM();
Func <AbstractField, int?> getClosestPiece = (AbstractField pos) => InvokeGetClosestPiece(gm, pos);
var conf = GenerateConfiguration();
var socketClient = GenerateSocketClient();
var player = GenerateGMPlayer(conf, socketClient);
var startField = new TaskField(0, 0);
var firstField = new TaskField(0, 1);
var secondField = new TaskField(1, 1);
Assert.True(startField.MoveHere(player));
// Act
var moved = await player.MoveAsync(firstField, getClosestPiece, CancellationToken.None);
Assert.True(moved);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
Assert.Null(prevSended);
await Task.Delay(conf.MovePenalty * 2);
lastSended = null;
moved = await player.MoveAsync(secondField, getClosestPiece, CancellationToken.None);
Assert.True(moved);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
}
private int GetPieceCount(TaskField taskField)
{
var taskFieldInfo = typeof(AbstractField).GetProperty("Pieces",
BindingFlags.NonPublic | BindingFlags.Instance);
var pieces = (HashSet <AbstractPiece>)taskFieldInfo.GetValue(taskField);
return(pieces.Count);
}
public TaskAssert AssertField(TaskField field, object value)
{
var actualValue = _task.GetValue(field);
var equals = Equals(value, actualValue);
Assert.True(equals, $"Task {_task.Ordinal + 1} {field.Name} should have been '{value}' but was '{actualValue}'");
return(this);
}
public async Task <IHttpActionResult> GetTaskField(int id)
{
TaskField taskField = await db.TaskFields.FindAsync(id);
if (taskField == null)
{
return(NotFound());
}
return(Ok(taskField));
}
public async Task <IHttpActionResult> PostTaskField(TaskField taskField)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TaskFields.Add(taskField);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = taskField.Id }, taskField));
}
public void DiscoverTest(TaskField field, int pieceCount)
{
var conf = new MockGameConfiguration();
var queue = new BufferBlock <Message>();
var lifetime = Mock.Of <IApplicationLifetime>();
var client = new TcpSocketClient <Message, Message>(logger);
var gameMaster = new GM(lifetime, conf, queue, client, logger);
gameMaster.Invoke("InitGame");
for (int i = 0; i < pieceCount; ++i)
{
gameMaster.Invoke("GeneratePiece");
}
// Act
var discoveryActionResult = gameMaster.Invoke <GM, Dictionary <Direction, int?> >("Discover", field);
// Assert
var board = gameMaster.GetValue <GM, AbstractField[][]>("board");
List <(AbstractField field, int dist, Direction dir)> neighbours = GetNeighbours(field, board, conf.Height, conf.Width);
for (int k = 0; k < neighbours.Count; k++)
{
for (int i = conf.GoalAreaHeight; i < conf.Height - conf.GoalAreaHeight; i++)
{
for (int j = 0; j < board[i].Length; j++)
{
int dist = ManhattanDistance(neighbours[k].field, board[i][j]);
if (dist < neighbours[k].dist)
{
neighbours[k] = (neighbours[k].field, dist, neighbours[k].dir);
}
}
}
if (discoveryActionResult[neighbours[k].dir] != neighbours[k].dist)
{
Assert.False(discoveryActionResult[neighbours[k].dir] == neighbours[k].dist,
$"Incorect value for distance: {discoveryActionResult[neighbours[k].dir]} != {neighbours[k].dist}");
}
}
int discoveredFields = 0;
foreach (var distance in discoveryActionResult)
{
if (distance.Value >= 0)
{
++discoveredFields;
}
}
Assert.Equal(neighbours.Count, discoveredFields);
}
public async Task <IHttpActionResult> DeleteTaskField(int id)
{
TaskField taskField = await db.TaskFields.FindAsync(id);
if (taskField == null)
{
return(NotFound());
}
db.TaskFields.Remove(taskField);
await db.SaveChangesAsync();
return(Ok(taskField));
}
public void TaskFieldTest()
{
TaskField message = new TaskField();
message.distanceToPiece = 5;
message.pieceId = 1;
message.pieceIdSpecified = true;
string xml = XmlMessageConverter.ToXml(message);
TaskField result = (TaskField)XmlMessageConverter.ToObject(xml);
Assert.AreEqual((int)5, result.distanceToPiece);
Assert.AreEqual((ulong)1, result.pieceId);
Assert.AreEqual(true, result.pieceIdSpecified);
}
public void MoveHereTest(List <GMPlayer> players, bool expected)
{
// Arrange
TaskField taskField = new TaskField(2, 2);
bool result = false;
// Act
foreach (GMPlayer p in players)
{
result = taskField.MoveHere(p);
}
// Assert
Assert.Equal(expected, result);
}
public async Task TestDiscoverAsync()
{
var gm = GenerateGM();
Func <AbstractField, Dictionary <Direction, int?> > discover = (AbstractField pos) => InvokeDiscover(gm, pos);
var player = GenerateGMPlayer();
var field = new TaskField(2, 2);
Assert.True(field.MoveHere(player));
// Act
await player.DiscoverAsync(discover, CancellationToken.None);
Assert.Equal(MessageID.DiscoverAnswer, lastSended.MessageID);
Assert.Null(prevSended);
}
public TaskAssert AssertFieldCollection <T>(TaskField field, IEnumerable <T> value)
{
var actualValue = _task.GetValue(field);
try
{
Assert.Equal(value, (IEnumerable <T>)actualValue);
}
catch (Exception ex)
{
Assert.True(false, $"Task {_task.Ordinal + 1} {field.Name} {ex.Message}'");
}
return(this);
}
public void HandleTaskField(int playerId, TaskField taskField)
{
var oldTaskField = (TaskField)this[taskField];
if (taskField.IsNewerThan(oldTaskField))
{
ClearPlayerFromField(oldTaskField);
ClearPieceFromField(oldTaskField);
HandlePlayerInField(taskField);
HandlePieceInField(playerId, taskField);
this[taskField] = new TaskField(taskField, taskField.DistanceToPiece, taskField.PieceId,
taskField.PlayerId);
}
}
public DataMessageBuilder AddTaskField(TaskField taskField)
{
if (taskFields == null)
{
taskFields = new TaskField[] { taskField }
}
;
else
{
var l = new List <TaskField>(taskFields)
{
taskField
};
taskFields = l.ToArray();
}
return(this);
}
public void DataTest()
{
Data message = new Data();
message.playerId = 0;
message.gameFinished = true;
GoalField[] goalFieldsTab = new GoalField[3];
goalFieldsTab[0] = new GoalField()
{
team = TeamColour.red
};
message.GoalFields = goalFieldsTab;
Piece[] pieceTab = new Piece[2];
pieceTab[0] = new Piece()
{
playerId = 2, playerIdSpecified = true
};
message.Pieces = pieceTab;
message.PlayerLocation = new Location()
{
x = 3
};
TaskField[] taskFieldTab = new TaskField[3];
taskFieldTab[0] = new TaskField()
{
x = 3
};
message.TaskFields = taskFieldTab;
string xml = XmlMessageConverter.ToXml(message);
Data result = (Data)XmlMessageConverter.ToObject(xml);
Assert.AreEqual((ulong)0, result.playerId);
Assert.AreEqual(true, result.gameFinished);
Assert.AreEqual(TeamColour.red, result.GoalFields[0].team);
Assert.AreEqual((ulong)2, result.Pieces[0].playerId);
Assert.AreEqual((uint)3, result.PlayerLocation.x);
Assert.AreEqual((ulong)3, result.TaskFields[0].x);
}
public void PlayerPlacesShamPieceOnNotOccupiedTaskField()
{
InitGameMaster();
var Player = GetPlayer("testGUID-0003", 10, TeamColour.blue, ActionType.PlacePiece);
// equip an Player with a sham piece
var messagePieceKnown = new Piece(PieceType.sham, 100)
{
timestamp = DateTime.Now,
};
EquipPlayerWithPiece(messagePieceKnown, Player);
Player.SetLocation(1, 5); // we change a location of an original object
var taskField = new TaskField(1, 5)
{
pieceIdSpecified = true,
pieceId = messagePieceKnown.id,
playerIdSpecified = true,
playerId = Player.ID,
timestamp = DateTime.Now,
};
DataAgent data = new DataAgent(Player.ID)
{
PlayerGUID = guid,
GameFinished = false,
PlayerLocation = Player.Location,
Tasks = new GameArea.GameObjects.TaskField[] { new GameArea.GameObjects.TaskField(taskField) }
};
// action: Player places a piece
data.Process(Player.Controller);
// assert
Assert.IsNull(Player.GetPiece);
Assert.IsNotNull(Player.GetBoard.GetTaskField(Player.Location));
Assert.AreEqual(messagePieceKnown.id, Player.GetBoard.GetTaskField(Player.Location).Piece.ID);
//Assert.AreEqual(PieceType.sham, Player.GetBoard.GetTaskField(Player.Location).Piece.Type);
}
public void PickUpTaskTest(int numPut, int numPick, bool expected)
{
// Arrange
var conf = Mock.Of <GameConfiguration>();
var socketClient = new TcpSocketClient <Message, Message>(logger);
GMPlayer gmPlayer = new GMPlayer(1, conf, socketClient, Shared.Enums.Team.Red, logger);
TaskField taskField = new TaskField(2, 2);
for (int i = 0; i < numPut; i++)
{
taskField.Put(new NormalPiece());
}
bool result = false;
// Act
for (int i = 0; i < numPick; i++)
{
result = taskField.PickUp(gmPlayer);
}
// Assert
Assert.Equal(expected, result);
}
public async Task TestMoveAsyncActivePenalty()
{
var gm = GenerateGM();
Func <AbstractField, int?> getClosestPiece = (AbstractField pos) => InvokeGetClosestPiece(gm, pos);
var player = GenerateGMPlayer();
var startField = new TaskField(0, 0);
var firstField = new TaskField(0, 1);
var secondField = new TaskField(1, 1);
Assert.True(startField.MoveHere(player));
// Act
var moved = await player.MoveAsync(firstField, getClosestPiece, CancellationToken.None);
Assert.True(moved);
Assert.Equal(MessageID.MoveAnswer, lastSended.MessageID);
Assert.Null(prevSended);
lastSended = null;
moved = await player.MoveAsync(secondField, getClosestPiece, CancellationToken.None);
Assert.False(moved);
Assert.Equal(MessageID.NotWaitedError, lastSended.MessageID);
}