public void TryCreateField_ShortJumpsField()
{
var oldField = CommonValues.ShortJumpsField;
var correctTurns = new List <GameTurn> {
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 17, 35),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 19, 33),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 26, 12),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 24, 10),
};
var incorrectTurns = new List <GameTurn> {
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 17, 33),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 30, 12),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 58, 44),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 21, 35),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 21, 39),
};
foreach (var turn in incorrectTurns)
{
Assert.IsFalse(GameFieldUtils.TryCreateField(oldField, turn, out _));
}
foreach (var turn in correctTurns)
{
TestUtils.CheckTurnResult(oldField, turn);
}
}
public Result TryMakeTurn(int start, int end)
{
var gameTurn = GameTurnUtils.CreateTurnByTwoCells(_curField, Side, start, end);
if (gameTurn == null || (gameTurn.IsSimple && _requiredJumps.Any()))
{
return(Result.Fail);
}
_turns.Add(gameTurn);
GameFieldUtils.TryCreateField(_curField, gameTurn, out GameField newField);
// Not the last jump
if (!gameTurn.IsSimple && !gameTurn.IsLevelUp &&
GameTurnUtils.FindTurnsForCell(newField, gameTurn.Steps.Last(), TurnType.Jump).Any())
{
_statusReporter.Status = $"{Side}: {Resources.WpfPlayer_JumpTurn_Continue}";
DoJumpsContinue = true;
_curField = newField;
return(Result.Continue);
}
_sender?.Send(GameTurnUtils.CreateCompositeJump(_turns));
return(Result.Ok);
}
private static List <Vector3> GetPositionListForSingleChild(int playerId, List <Vector3> piecePositions, Transform[] childrenTransform, PositionMapElement[,] playerPositionMapElement, GameObject playerField, GameObject playerForSeeWindow, int mapVerticalStartPosition)
{
int mapSingleHorizontalPosition;
if (ApplicationUtils.IsInMultiPlayerMode())
{
mapSingleHorizontalPosition = GameFieldUtils.PositionToMapValue(childrenTransform.First().position.x, playerId, playerField, playerForSeeWindow);
}
else
{
mapSingleHorizontalPosition = (int)Mathf.Round(childrenTransform.First().position.x - 0.5f);
}
for (int j = mapVerticalStartPosition; j >= 0; j--)
{
if (playerPositionMapElement[j, mapSingleHorizontalPosition].IsOccupied)
{
piecePositions.Add(playerPositionMapElement[j, mapSingleHorizontalPosition].CurrentMapElement.transform.position);
break;
}
if (j == 0)
{
piecePositions.Add(new Vector3(GameFieldUtils.MapValueToPosition(mapSingleHorizontalPosition, playerId, playerField, playerForSeeWindow), 0.5f, -0.5f));
}
}
return(piecePositions);
}
public static List <Vector3> GetBottomPiecePositions(int playerId, GameObject parentPiece)
{
List <Vector3> piecePositions = new List <Vector3>();
Transform[] childrenTransform = parentPiece
.GetComponentsInChildren <Transform>()
.Where(childTransform => childTransform.gameObject != parentPiece)
.OrderBy(childTransform => childTransform.position.x)
.ToArray();
PositionMapElement[,] playerPositionMapElement = GameUtils.FetchPlayerPositionMap(playerId);
GameObject highestPiece = GameFieldUtils.FetchHighestPieceInPlayerField(playerId);
if (highestPiece == null)
{
return(null);
}
GameObject playerField = GameUtils.FetchPlayerField(playerId);
GameObject playerForSeeWindow = GameUtils.FetchPlayerForSeeWindow(playerId);
int mapVerticalStartPosition = Mathf.RoundToInt(highestPiece.transform.position.z - 0.5f);
if (childrenTransform.Length == 1)
{
return(GetPositionListForSingleChild(playerId, piecePositions, childrenTransform, playerPositionMapElement, playerField, playerForSeeWindow, mapVerticalStartPosition));
}
else
{
return(GetPositionListForMultipleChild(playerId, piecePositions, childrenTransform, playerPositionMapElement, playerField, playerForSeeWindow, mapVerticalStartPosition));
}
}
public void TryCreateField_NullTurn()
{
Assert.IsFalse(GameFieldUtils.TryCreateField(CommonValues.DefaultField, null, out _));
Assert.IsFalse(GameFieldUtils.TryCreateField(CommonValues.ShortJumpsField, null, out _));
Assert.IsFalse(GameFieldUtils.TryCreateField(CommonValues.DefaultField, null, out _));
Assert.IsFalse(GameFieldUtils.TryCreateField(CommonValues.ShortJumpsField, null, out _));
}
private bool TryUpdateField(GameTurn newTurn)
{
if (newTurn == null ||
!GameFieldUtils.TryCreateField(_modelController.Field, newTurn, out GameField newGameField))
{
return(false);
}
_modelController.UpdateField(newGameField);
return(true);
}
public bool IsGameOver(int playerId)
{
GameObject highestPieceChild = GameFieldUtils.FetchHighestPieceInPlayerField(playerId);
if (highestPieceChild == null)
{
return(false);
}
int currentHighestPieceChildLine = (int)(highestPieceChild.transform.position.z - 0.5f);
return(currentHighestPieceChildLine > GameFieldUtils.maxAllowedPlayableLine);
}
public static IEnumerable <GameTurn> FindWorstTurn(CachedField oldField, IEnumerable <GameTurn> newTurns)
{
var index = -1;
var minPriority = double.PositiveInfinity;
foreach (var(turn, idx) in newTurns.Select((t, i) => (t, i)))
{
GameFieldUtils.TryCreateField(oldField.Origin, turn, out GameField newField);
var turnMetric = MetricsProcessor.CompareWithMetrics(oldField, new CachedField(newField), turn.Side);
if (turnMetric < minPriority)
{
minPriority = turnMetric;
index = idx;
}
}
return(newTurns.Any() ? new[] { newTurns.ElementAt(index) } : newTurns);
}
public void TryCreateField_DefaultField()
{
var oldField = CommonValues.DefaultField;
var correctTurns = new List <GameTurn> {
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 17, 26),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 23, 30),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 46, 39),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 42, 33),
};
var incorrectTurns = new List <GameTurn> {
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 7, 14),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 23, 24),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 24, 39),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 28, 35),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 42, 33),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.Black, 46, 39),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 17, 26),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 23, 30),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 33, 40),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 51, 44),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 51, 19),
GameTurnUtils.CreateTurnByTwoCells(oldField, PlayerSide.White, 55, 40),
};
foreach (var turn in incorrectTurns)
{
Assert.IsFalse(GameFieldUtils.TryCreateField(oldField, turn, out _));
}
foreach (var turn in correctTurns)
{
Assert.IsTrue(GameFieldUtils.TryCreateField(oldField, turn, out GameField newField));
foreach (var step in turn.Steps)
{
Assert.AreNotEqual(oldField[step], newField[step]);
}
}
}
private static IEnumerable <GameTurn> GetCompositeJumps(GameField oldField, IEnumerable <GameTurn> jumps)
{
foreach (var jump in jumps)
{
GameFieldUtils.TryCreateField(oldField, jump, out GameField newField);
var subJumps = GetCompositeJumps(newField, GameTurnUtils.FindTurnsForCell(newField, jump.Steps.Last(), TurnType.Jump));
if (subJumps.Any() && !jump.IsLevelUp)
{
foreach (var subJump in subJumps)
{
yield return(GameTurnUtils.CreateCompositeJump(new[] { jump, subJump }));
}
}
else
{
yield return(jump);
}
}
}
public void TryCreateField_LongJumpsField()
{
var oldField = CommonValues.LongJumpsField;
var correctTurns = new List <GameTurn> {
// PlayerSide.Black, new[] { 55, 46, 37, 30, 23, 14, 5, 12, 19 }
TestUtils.CreateCompositeJump(oldField, PlayerSide.Black, new[] { 55, 37, 23, 5, 19 }),
// PlayerSide.Black, new[] { 7, 14, 21, 30, 39, 46, 53 }
TestUtils.CreateCompositeJump(oldField, PlayerSide.Black, new[] { 7, 21, 39, 53 }),
// PlayerSide.White, new[] { 1, 10, 19, 28, 37, 44, 51, 42, 33 }
TestUtils.CreateCompositeJump(oldField, PlayerSide.White, new[] { 1, 19, 37, 51, 33 })
};
var incorrectTurns = new List <GameTurn> {
// PlayerSide.Black, new[] { 7, 14, 21, 28, 35, 42, 49 }
TestUtils.CreateCompositeJump(oldField, PlayerSide.Black, new[] { 7, 21, 35, 49 }),
// PlayerSide.Black, new[] { 7, 14, 21, 12, 3 }),
TestUtils.CreateCompositeJump(oldField, PlayerSide.Black, new[] { 7, 21, 3 }),
// PlayerSide.White, new[] { 1, 10, 19, 12, 5 }),
TestUtils.CreateCompositeJump(oldField, PlayerSide.White, new[] { 1, 19, 5 }),
// PlayerSide.White, new[] { 12, 10, 19, 28, 37, 44, 51, 42, 33 }),
TestUtils.CreateCompositeJump(oldField, PlayerSide.White, new[] { 12, 19, 37, 51, 33 })
};
foreach (var turn in incorrectTurns)
{
Assert.IsFalse(GameFieldUtils.TryCreateField(oldField, turn, out _));
}
foreach (var turn in correctTurns)
{
TestUtils.CheckTurnResult(oldField, turn);
}
}
public static void CheckTurnResult(GameField oldField, GameTurn turn)
{
Assert.IsTrue(GameFieldUtils.TryCreateField(oldField, turn, out GameField newField));
if (turn.IsLevelUp)
{
Assert.IsTrue(newField[turn.Steps.Last()].IsKing());
Assert.IsFalse(oldField[turn.Steps.First()].IsKing());
}
else
{
Assert.AreEqual(oldField[turn.Steps.First()], newField[turn.Steps.Last()]);
}
Assert.AreNotEqual(oldField[turn.Steps.First()], newField[turn.Steps.First()]);
Assert.AreNotEqual(oldField[turn.Steps.Last()], newField[turn.Steps.Last()]);
foreach (var step in turn.Steps.Skip(1).SkipLast(1))
{
Assert.AreEqual(CellState.Empty, newField[step]);
}
}
private void UpdateMapDatasForObject(GameObject parentObject, GameManager gameManagerScript, int playerId)
{
Transform[] childrenTransform = parentObject.GetComponentsInChildren <Transform>();
foreach (Transform childTransform in childrenTransform)
{
int linePosition = (int)Math.Round(childTransform.position.z - 0.5f);
int columnPosition = 0;
if (ApplicationUtils.IsInMultiPlayerMode())
{
columnPosition = GameFieldUtils.PositionToMapValue(childTransform.position.x, playerId, gameManagerScript.PlayersField[playerId], gameManagerScript.PlayersForeSeeWindow[playerId]);
}
else
{
columnPosition = (int)Math.Round(childTransform.position.x - 0.5f);
}
gameManagerScript.PlayersPositionMap[playerId][linePosition, columnPosition].IsOccupied = true;
gameManagerScript.PlayersPositionMap[playerId][linePosition, columnPosition].CurrentMapElement = childTransform.gameObject;
childTransform.gameObject.layer = LayerMask.NameToLayer(LayerConstants.LAYER_NAME_DESTROYABLE_PIECE);
}
}
public GameField(int dimension)
: this(GameFieldUtils.ConstructInitialField(dimension), dimension)
{
}
