public void SelectField_WhenFirstFieldHasBeenSelected_ThenMovementIsNotFinished()
{
BoardField startField = BoardField.Empty;
Player player = new Player(Colors.Cyan);
startField.Token = new Token(TokenType.Advocate, player);
BoardField selectedField = BoardField.Empty;
AngleMovement testee = new AngleMovement(startField);
var result = testee.SelectField(selectedField);
result.Should().BeFalse();
}
public void CheckBoardFieldStatusHit()
{
BoardConfig boardConfig = new BoardConfig
{
RowsNumber = 3,
ColumnsNumber = 3
};
Board board = new Board(boardConfig);
BoardField boardField = board.GetField(0, 0);
boardField.Shoot();
Assert.AreEqual(BoardField.State.ShotDown, boardField.Status);
}
public void SelectField_WhenEnemyParagraphTokenIsBetweenStartAndDestinationField_ThenRemoveEnemyParagraphToken()
{
Player enemyPlayer = new Player(Colors.Transparent);
Token enemyToken = new Token(TokenType.Paragraph, enemyPlayer);
BoardField enemyField = this.board.Fields[1][2];
enemyField.Token = enemyToken;
BoardField selectedField = new BoardField(new Position(1, 3));
this.testee.SelectField(selectedField);
enemyField.Token.Should().BeNull();
}
/// <summary>
/// Заполнить указанные клетки
/// </summary>
/// <param name="positions">Строка с координатами, разделёнными пробелом</param>
/// <param name="bf">Тип поля</param>
void Fill(string positions, BoardField bf)
{
if (positions == null || positions == "")
{
return;
}
var coords = from c in positions.Split(new[] { ' ' }) select new { C = c[0] - 'a', R = int.Parse(c[1].ToString()) - 1 };
foreach (var pos in coords)
{
this[pos.R, pos.C] = bf;
}
}
public void SelectField_WhenFirstFieldHasBeenSelected_ThenParagraphTokenShoulBePlaced()
{
Token token = new Token(TokenType.Advocate);
BoardField startField = BoardField.Empty;
startField.Token = token;
BoardField selectedField = BoardField.Empty;
AngleMovement testee = new AngleMovement(startField);
testee.SelectField(selectedField);
selectedField.Token.Type.Should().Be(TokenType.Paragraph);
}
public bool IsGameOver(Board board, Player currentPlayer)
{
BoardField playerField = this.GetAdvokateTokenField(board, currentPlayer);
if (this.CanMoveDown(board, playerField) ||
this.CanMoveUp(board, playerField) ||
this.CanMoveRight(board, playerField) ||
this.CanMoveLeft(board, playerField))
{
return(false);
}
return(true);
}
private void InitBoardFields()
{
_fields = new BoardField[_size.y, _size.x];
for (int row = 0; row < _size.y; row++)
{
for (int column = 0; column < size.x; column++)
{
BoardField field = new BoardField();
field.row = row;
field.column = column;
_fields[row, column] = field;
}
}
}
public void SelectField_WhenFirstFieldHasBeenSelected_ThenParagraphTokenShoulBeFromCorrectPlayer()
{
Player player = new Player(Colors.Cyan);
Token token = new Token(TokenType.Advocate, player);
BoardField startField = BoardField.Empty;
startField.Token = token;
BoardField selectedField = BoardField.Empty;
AngleMovement testee = new AngleMovement(startField);
testee.SelectField(selectedField);
selectedField.Token.Player.Should().Be(player);
}
public IEnumerator moveForwardTo(BoardField destination)
{
while (currentPlace != destination)
{
yield return(goToField(currentPlace.nextField));
yield return(currentPlace.passThrough(this));
if (currentPlace is StartField || currentPlace is DummyFieldCorner)
{
yield return(rotate(90));
}
}
yield return(null);
}
public IEnumerator moveBackwardTo(BoardField destination)
{
while (currentPlace != destination)
{
var previousField = Array.Find(GameObject.FindObjectsOfType <BoardField>(), (field => field.nextField == currentPlace));
yield return(goToField(previousField));
if (currentPlace is StartField || currentPlace is DummyFieldCorner)
{
yield return(rotate(-90));
}
}
yield return(null);
}
// Bewegt GENAU 1 BoardField nach unten
public void MoveOneBoardField_Down(BoardField boardfield)
{
if (this.Board.Array_Board[boardfield.x, boardfield.y + 1].block != CurrentBlock)
{
// Übernimmt oberes BoardField um 1 nach unten
this.Board.Array_Board[boardfield.x, boardfield.y + 1].block = boardfield.block;
this.Board.Array_Board[boardfield.x, boardfield.y + 1].Color = boardfield.Color;
//Lösche oberes Feld
if (this.Board.Array_Board[boardfield.x, boardfield.y].block != CurrentBlock)
{
this.Board.Array_Board[boardfield.x, boardfield.y].Clear();
}
}
}
public void AddTerritoryTest()
{
//set up
BoardField[,] fields = BoardTest.CreateTestMap().Board;
var tailFields = new BoardField[]
{
fields[0, 2],
fields[0, 1],
fields[0, 0],
fields[1, 0],
fields[2, 0],
fields[2, 1],
fields[2, 2],
};
var expectedClaimedFields = new BoardField[] {
fields[0, 2],
fields[0, 1],
fields[0, 0],
fields[1, 2],
fields[1, 1],
fields[1, 0],
fields[2, 2],
fields[2, 1],
fields[2, 0]
};
var expectedNotClaimedFields = new BoardField[] {
fields[3, 2],
fields[3, 1],
fields[3, 0]
};
var player = new PlayerModel(new Color(), fields[1, 2]);
fields[1, 2].Owner = player;
player.Tail.Positions.AddRange(tailFields);
//test
PlayerServices.AddTerritory(player);
foreach (BoardField field in expectedClaimedFields)
{
Assert.IsTrue(field.Owner == player);
}
foreach (BoardField field in expectedNotClaimedFields)
{
Assert.IsTrue(field.Owner == MissingPlayer.Instance);
}
}
public void NotMoveWhileDeadTest()
{
//set up
var startField = new BoardField(MissingPlayer.Instance, new Point());
var player = new PlayerModel(new Color(), startField);
var controller = new PlayerController(player, startField, 0, 0);
controller.MovingState = new WaitingForRespawnState(controller);
//test
Assert.IsTrue(player.Position == startField);
controller.ChangeNextDirection(Direction.Up);
controller.Update();
Assert.IsTrue(player.Position == startField);
}
public void GetMovement_WhenFieldIsEmpty_ThenShouldReturnAngleMovement()
{
Player player = new Player(Colors.Transparent);
BoardField selectedField = BoardField.Empty;
BoardField playerField = BoardField.Empty;
playerField.Token = new Token(TokenType.Advocate, player);
Board board = new Board(new List <List <BoardField> >(new[] { new List <BoardField> {
selectedField, playerField
} }));
MovementFinder testee = new MovementFinder(board);
var result = testee.GetMovement(selectedField, player);
result.Should().BeOfType <AngleMovement>();
}
private void InitializeStartFields(List <List <BoardField> > fields, IEnumerable <Player> players)
{
int index = 0;
var playerEnumerable = players as IList <Player> ?? players.ToList();
foreach (var player in playerEnumerable)
{
int row = this.startPositionDictionary[playerEnumerable.Count][index] / 8;
int column = this.startPositionDictionary[playerEnumerable.Count][index] % 8;
BoardField startField = fields[row][column];
startField.FieldColor = new SolidColorBrush(player.Color);
startField.Token = new Token(TokenType.Advocate, player);
index++;
}
}
public void GetMovement_WhenSelectingEnemyParagraphTokenField_ThenReturnNullMovement()
{
Player player = new Player(Colors.Transparent);
Player enemyPlayer = new Player(Colors.Transparent);
BoardField selectedField = new BoardField(0, default(Brush), new Position(1, 1));
selectedField.Token = new Token(TokenType.Paragraph, enemyPlayer);
Board board = new Board(new List <List <BoardField> >(new[] { new List <BoardField> {
selectedField
} }));
MovementFinder testee = new MovementFinder(board);
var result = testee.GetMovement(selectedField, player);
result.Should().BeNull();
}
/// <summary>
/// Владелец шашки на указанном поле
/// </summary>
/// <param name="r">Строка</param>
/// <param name="c">Столбец</param>
/// <returns>Владелец</returns>
public Player Owner(int r, int c)
{
BoardField t = this[r, c];
if (t == BoardField.BLACK || t == BoardField.BLACK_KING)
{
return(Player.BLACK);
}
else if (t == BoardField.WHITE || t == BoardField.WHITE_KING)
{
return(Player.WHITE);
}
else
{
throw new ArgumentException();
}
}
public void GetMovement_WhenFieldIsOccupied_ThenShouldReturnParagraphMovement()
{
Player player = new Player(Colors.Transparent);
BoardField selectedField1 = new BoardField(0, default(Brush), new Position(1, 1));
selectedField1.Token = new Token(TokenType.Paragraph, player);
BoardField selectedField2 = new BoardField(0, default(Brush), new Position(1, 2));
Board board = new Board(new List <List <BoardField> >(new[] { new List <BoardField> {
selectedField1, selectedField2
} }));
MovementFinder testee = new MovementFinder(board);
var result = testee.GetMovement(selectedField1, player);
result.Should().BeOfType <ParagraphMovement>();
}
private bool CanMoveLeft(Board board, BoardField playerField)
{
for (int column = playerField.Position.Y - 1; column >= 0; column--)
{
var row = playerField.Position.Y;
if (board.Fields[row][column].HasToken)
{
break;
}
if (this.CanDoSecondMoveVertically(board, row, column))
{
return(true);
}
}
return(false);
}
private bool CanMoveUp(Board board, BoardField playerField)
{
for (int row = playerField.Position.Y - 1; row >= 0; row--)
{
var column = playerField.Position.X;
if (board.Fields[row][column].HasToken)
{
break;
}
if (this.CanDoSecondMoveHorizontally(board, row, column))
{
return(true);
}
}
return(false);
}
public void SelectField_WhenSecondFieldHasBeenSelected_ThenMoveTokenToSecondField()
{
Token token = new Token(TokenType.Advocate);
BoardField startField = BoardField.Empty;
startField.Token = token;
BoardField firstSelectedField = BoardField.Empty;
BoardField secondSelectedField = BoardField.Empty;
AngleMovement testee = new AngleMovement(startField);
testee.SelectField(firstSelectedField);
testee.SelectField(secondSelectedField);
startField.Token.Should().BeNull("start field should not have a token after angle move");
firstSelectedField.Token.Type.Should().Be(TokenType.Paragraph);
secondSelectedField.Token.Should().Be(token);
}
public bool SelectField(BoardField field)
{
if (field.Token != null)
{
return(false);
}
if (this.IsNotInSameRowOrColumn(field))
{
return(false);
}
this.RemoveEnemyToken(field);
field.Token = this.startField.Token;
this.startField.Token = null;
return(true);
}
public void MakeMove(int playerMove, BoardField who)
{
if (who != BoardField.One && who != BoardField.Two)
{
throw new ArgumentException("Not player move", "who");
}
if (playerMove < 0 || playerMove > 8)
{
throw new ArgumentException("PlayerMove not in array bounds: 0-8", "playerMove");
}
if (_board[playerMove] != BoardField.Empty)
{
throw new BoardFieldNotEmptyException();
}
_board[playerMove] = who;
}
void CreateField(string name, int score)
{
//Creating a new gameobject to the scene with emptyfield
GameObject newfieldGO = Instantiate(emptyfield);
//Parenting our gameobject to the verticle layout
newfieldGO.transform.parent = VerticalLayout;
newfieldGO.transform.localScale = Vector3.one;
//Creating a new empty field class and passing in our newfieldGO gameobject we made earlier
EField newfield = newfieldGO.GetComponent <EmptyScoreField>().field;
newfield.name.text = name;
newfield.score.text = score.ToString();
//Creating a new Boardfield with the name,score, and empty field we created earlier
BoardField field = new BoardField(name, score, newfield);
//Adding the field and the newfieldGO gameobject to lists
Allfields.Add(newfieldGO);
AddedBoard.Add(field);
}
public void FindTheWay()
{
GameObject startField = GameObject.FindWithTag("StartField");
BoardField bf = startField.GetComponent <BoardField>();
int col = 0, row = 0;
for (int i = 0; i < boardController.fields.GetLength(0); i++)
{
for (int j = 0; j < boardController.fields.GetLength(1); j++)
{
if (boardController.fields[i, j] == startField)
{
col = j;
row = i;
}
}
}
theWay.Add(boardController.fields[row, col]);
FindNextField(row, col, bf.direction);
}
public IMovement GetMovement(BoardField selectedField, Player currentPlayer)
{
if (this.IsAngleMovement(selectedField))
{
var advokateTokenField = this.GetAdvokateTokenField(currentPlayer);
AngleMovement angleMovement = new AngleMovement(advokateTokenField);
angleMovement.SelectField(selectedField);
return(angleMovement);
}
if (this.IsParagraphMovement(selectedField, currentPlayer))
{
ParagraphMovement paragraphMovement = new ParagraphMovement(this.board, selectedField);
return(paragraphMovement);
}
return(null);
}
public void ChangeNextDirectionTest()
{
//set up
var startField = new BoardField(MissingPlayer.Instance, new Point(0, 1));
var endField = new BoardField(MissingPlayer.Instance, new Point(0, 0));
startField.Neighbours.Add(Direction.Up, endField);
var player = new PlayerModel(new Color(), startField);
var controller = new PlayerController(player, startField, 0, 0);
player.Direction = Direction.Up;
controller.MovingState = new DefensiveState(controller);
//test
controller.ChangeNextDirection(Direction.Left);
Assert.IsTrue(player.Direction == Direction.Up);
//player will go up because that is his buffered direction and then change it to left
controller.Update();
Assert.IsTrue(player.Direction == Direction.Left);
}
public void RegisterBoardField(BoardField field)
{
if (field == _field)
{
return;
}
if (_field != null)
{
WeakEventManager <BoardField, PropertyChangedEventArgs> .RemoveHandler(
_field, nameof(_field.PropertyChanged), Field_PropertyChanged);
}
_field = field;
if (_field != null)
{
WeakEventManager <BoardField, PropertyChangedEventArgs> .AddHandler(
_field, nameof(_field.PropertyChanged), Field_PropertyChanged);
OnPropertyChanged(nameof(Field));
Field_PropertyChanged(_field, new PropertyChangedEventArgs(""));
}
}
public void StartMovingTest()
{
//set up
var startField = new BoardField(MissingPlayer.Instance, new Point(0, 1));
var endField = new BoardField(MissingPlayer.Instance, new Point(0, 0));
startField.Neighbours.Add(Direction.Up, endField);
var player = new PlayerModel(new Color(), startField);
var controller = new PlayerController(player, startField, 0, 0);
//test
Assert.IsTrue(player.Direction == Direction.None);
controller.Update();
Assert.IsTrue(player.Position == startField);
controller.ChangeNextDirection(Direction.Up);
controller.Update();
Assert.IsTrue(player.Direction == Direction.Up);
Assert.IsTrue(player.Position == endField);
}
private static bool ClaimTerritoryAlgorithm(PlayerModel player, BoardField currentField, List <BoardField> outerNeighbours, List <BoardField> joinedArea)
{
joinedArea.Add(currentField);
if (currentField.Neighbours.Values.Any(f => f == null))
{
outerNeighbours.AddRange(joinedArea.ToArray());
return(false);
}
//For each of neighbours thatarent in joined area list and does not belong to player make recurrent call
bool eachNeighbourReturnsTrue = true;
foreach (BoardField neighbour in currentField.Neighbours.Values)
{
if (neighbour.Owner != player && !joinedArea.Contains(neighbour))
{
if (!ClaimTerritoryAlgorithm(player, neighbour, outerNeighbours, joinedArea))
{
eachNeighbourReturnsTrue = false;
}
}
}
return(eachNeighbourReturnsTrue);
}
private bool IsPlayerField(BoardField boardField)
{
return boardField == BoardField.One || boardField == BoardField.Two;
}
private GameStatus PlayerToGamesStatus(BoardField boardField)
{
if (boardField != BoardField.One && boardField != BoardField.Two)
{
throw new ArgumentException("Boardfield is not connected with player", "boardField");
}
if (boardField == BoardField.One)
{
return GameStatus.PlayerOneWins;
}
else
{
return GameStatus.PlayerTwoWins;
}
}
private void FindNextField(int _row, int _col, Direction _dir)
{
bool jumpOutOfBoard = false;
Direction dir = _dir;
int row = _row, col = _col;
if (dir == Direction.Down)
{
if (_row == 0)
{
jumpOutOfBoard = true;
}
else
{
row--;
}
}
else if (dir == Direction.Right)
{
if (_col == size - 1)
{
jumpOutOfBoard = true;
}
else
{
col++;
}
}
else if (dir == Direction.Up)
{
if (_row == size - 1)
{
jumpOutOfBoard = true;
}
else
{
row++;
}
}
else if (dir == Direction.Left)
{
if (_col == 0)
{
jumpOutOfBoard = true;
}
else
{
col--;
}
}
if (jumpOutOfBoard)
{
return;
}
else
{
if (boardController.fields[row, col].tag == "ArrowField" || boardController.fields[row, col].tag == "StartField")
{
if (theWay.Contains(boardController.fields[row, col]))
{
return;
}
else
{
BoardField bf = boardController.fields[col, row].GetComponent <BoardField>();
dir = bf.direction;
}
}
else if (boardController.fields[row, col].tag == "BarrierField")
{
return;
}
else if (boardController.fields[row, col].tag == "FinishField")
{
isWin = true;
theWay.Add(boardController.fields[row, col]);
return;
}
theWay.Add(boardController.fields[row, col]);
FindNextField(row, col, dir);
}
}
private bool IsTrippleEquals(BoardField first, BoardField second, BoardField third)
{
return first == second && second == third;
}
public PlayerBoardAdapter(GameBoard gameBoard, BoardField player)
{
_player = player;
_gameBoard = gameBoard;
}
