public CheckMovesResult CheckRule(CheckMovesResult result)
{
// no player figure is on the game field which means no player figure has movepoint score between 0 and up to 40
var numberOfFiguresOnBoard = nvp_RuleHelper.CountPlayersOnBoard(result.PlayerColor, result.PlayerFigures);
// at least on player figure is in the house
var numberOfPlayerInTheHouse = nvp_RuleHelper.CountPlayersInHouse(result.PlayerColor, result.PlayerFigures);
// general rule
if (numberOfPlayerInTheHouse == 0 || result.DiceValue < 6)
{
return(_nextRule.CheckRule(result));
}
// get figure to move
var pf = result.PlayerFigures
.Where(x => x.LocalPosition < 0 && x.Color == result.PlayerColor)
.OrderBy(x => x.Index)
.First();
result.CanMove = true;
result.AdditionalRollGranted = true;
result.LastActiveRule = "Must leave house";
result.PossibleMoves.Add(new PlayerMove
{
Color = result.PlayerColor,
Index = nvp_RuleHelper.GetNextFigureToLeaveHouse(result.PlayerColor, result.PlayerFigures).Index,
DiceValue = 0
});
return(result);
}
public CheckMovesResult Move(CheckMovesResult movesInfo, int indexMoveToMake = 0)
{
if (!movesInfo.CanMove)
{
return(movesInfo);
}
var move = movesInfo.PossibleMoves[indexMoveToMake];
var figure = playerFigures.Single(x =>
x.Color == move.Color &&
x.Index == move.Index);
figure.Move(move.DiceValue);
// check for killing other player
var figuresOnWorldPosition = nvp_RuleHelper.GetFiguresOnWorldPosition(movesInfo.PlayerFigures, figure.WorldPosition)
.Where(x => x.Color != figure.Color).ToList();
if (figuresOnWorldPosition.Count > 0)
{
figuresOnWorldPosition[0].LocalPosition = -1;
figuresOnWorldPosition[0].WorldPosition = -1;
}
return(movesInfo);
}
public CheckMovesResult CheckRule(PlayerColors playerColor, List <PlayerFigure> playerFigures, int diceValue)
{
CheckMovesResult result = null;
// no player figure is on the game field which means no player figure has movepoint score between 0 and up to 40
var numberOfFiguresOnBoard = nvp_RuleHelper.CountPlayersOnBoard(playerColor, playerFigures);
// at least on player figure is in the house
var numberOfPlayerInTheHouse = nvp_RuleHelper.CountPlayersInHouse(playerColor, playerFigures);
// general rule
if (numberOfPlayerInTheHouse == 0 || diceValue < 6)
{
return(_nextRule.CheckRule(playerColor, playerFigures, diceValue));
}
result = new CheckMovesResult(true, true, "nvp_Rule_6_all_in_house_class: move out");
// get figure to move
var pf = playerFigures.Single(x => x.Index == 0 && x.Color == playerColor);
// enlist the move for display
result.PossibleMoves = new List <PlayerMove>();
var move = new PlayerMove();
move.Color = playerColor;
move.Index = nvp_RuleHelper.GetNextFigureToLeaveHouse(playerColor, playerFigures).Index;
move.MovePoints = 0;
move.GameBoardLocation = pf.OffSet;
result.PossibleMoves.Add(move);
return(result);
}
public CheckMovesResult CheckRule(CheckMovesResult result)
{
if (!nvp_RuleHelper.IsLocalPositionAvailable(result.PlayerColor, result.PlayerFigures, 0))
{
if (nvp_RuleHelper.CanExitStart(result.PlayerColor, result.PlayerFigures, result.DiceValue))
{
var pf = nvp_RuleHelper.GetPlayerFigureFromByLocalPosition(result.PlayerColor, result.PlayerFigures, 0);
result.CanMove = true;
result.LastActiveRule = "Must Leave Start";
var pm = new PlayerMove
{
Color = result.PlayerColor,
Index = pf.Index,
DiceValue = result.DiceValue
};
result.PossibleMoves = new List <PlayerMove> {
pm
};
return(result);
}
else
{
result.CanMove = false;
result.AdditionalRollGranted = false;
result.LastActiveRule = "Must Leave Start";
return(result);
}
}
else
{
return(_nextRule.CheckRule(result));
}
}
public CheckMovesResult CheckRule(PlayerColors playerColor, List <PlayerFigure> playerFigures, int diceNumber)
{
if (nvp_RuleHelper.IsFieldOccupiedByOwnFigure(playerColor, playerFigures, 0))
{
if (nvp_RuleHelper.CanExitStart(playerColor, playerFigures, diceNumber))
{
var pf = nvp_RuleHelper.GetPlayerFigureOnField(playerColor, playerFigures, 0);
var result = new CheckMovesResult(true, false, "");
var pm = new PlayerMove();
pm.Color = playerColor;
pm.Index = pf.Index;
pm.MovePoints = diceNumber;
result.PossibleMoves = new List <PlayerMove>();
result.PossibleMoves.Add(pm);
return(result);
}
else
{
var result = new CheckMovesResult(false, false, "");
return(result);
}
}
else
{
return(_nextRule.CheckRule(playerColor, playerFigures, diceNumber));
}
}
public CheckMovesResult CheckRule(CheckMovesResult result)
{
result.CanMove = false;
result.AdditionalRollGranted = false;
result.LastActiveRule = "Rule Default.";
return(result);
}
public CheckMovesResult CheckRule(CheckMovesResult result)
{
// get players on board
var ownFigures = nvp_RuleHelper.GetFiguresOnBoardByColor(result.PlayerColor, result.PlayerFigures, result.DiceValue);
ownFigures = ownFigures.Where(x => x.LocalPosition < 40).ToList();
if (ownFigures.Count == 0)
{
return(_nextRule.CheckRule(result));
}
if (ownFigures.Count > 1)
{
var haveToKill = false;
haveToKill |= CheckRuleForFigure(result, ownFigures[0]);
haveToKill |= CheckRuleForFigure(result, ownFigures[1]);
if (haveToKill)
{
return(result);
}
}
return(_nextRule.CheckRule(result));
}
public CheckMovesResult CheckRule(CheckMovesResult result)
{
// get players on board
var playerFigures = nvp_RuleHelper.GetFiguresOnBoardByColor(result.PlayerColor, result.PlayerFigures, result.DiceValue);
if (playerFigures.Count == 0)
{
return(_nextRule.CheckRule(result));
}
for (int i = 0, n = playerFigures.Count; i < n; i++)
{
var pf = playerFigures[i];
if (pf.LocalPosition + result.DiceValue < 45)
{
result.CanMove = true;
result.LastActiveRule = "JustMove";
result.PossibleMoves.Add(new PlayerMove
{
Color = result.PlayerColor,
DiceValue = result.DiceValue,
Index = pf.Index
});
}
}
result.PossibleMoves = result.PossibleMoves.OrderBy(x => x.Index).ToList();
return(result);
}
public void test_rules_h4_b0_s0_d_g6_g6_g5_g5_g5()
{
/** roll sequence test
* Setting inital position 4 player game
* Player black rolls:
* 6 - 6 - 5 - 5 - 5
* Expected Result
* A green figure should be on world position 10 = ((21 + 30) % 41) and
* local position 21
*/
CheckMovesResult result = null;
var diceRolls = new[] { "g6", "g6", "g5", "g5", "g5" };
for (int i = 0, n = diceRolls.Length; i < n; i++)
{
result = CheckRules(diceRolls[i]);
if (!result.CanMove)
{
break;
}
result = _gameboard.Move(CheckRules(diceRolls[i]));
}
Assert.AreEqual(true, result.CanMove);
Assert.AreEqual(false, result.AdditionalRollGranted);
var pf = CheckWorldPosition((21 + 30) % 41);
Assert.IsNotNull(pf);
Assert.AreEqual(0, pf.Index);
Assert.AreEqual(21, pf.LocalPosition);
Assert.AreEqual(10, pf.WorldPosition);
Assert.AreEqual(PlayerColors.green, pf.Color);
}
public CheckMovesResult CheckRule(CheckMovesResult result)
{
if (result.DiceValue == 6)
{
result.AdditionalRollGranted = true;
}
return(_nextRule.CheckRule(result));
}
// +++ public Methods +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public CheckMovesResult CheckPossiblePlayerMoves(PlayerColors playerColor, int diceValue)
{
var defaultResult = new CheckMovesResult();
defaultResult.PlayerColor = playerColor;
defaultResult.DiceValue = diceValue;
defaultResult.PlayerFigures = playerFigures;
return(_ruleChain[0].CheckRule(defaultResult));
}
void OnPlayerDiceRoll(PlayerDiceRoll diceRoll)
{
_lastCalculatedMoveResult = _gameLogic.CheckPossiblePlayerMoves(
diceRoll.playerColor,
diceRoll.diceValue
);
// invoke event
OnPlayerMovesCalculated(_lastCalculatedMoveResult);
}
// +++ event handler ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void OnPlayerMovesCalculate(CheckMovesResult result)
{
Clear();
for (int i = 0, n = result.PossibleMoves.Count; i < n; i++)
{
_moveTexts[i].text = string.Format(
"Player {0} can move Figur {1} for {2}"
, result.PossibleMoves[i].Color
, result.PossibleMoves[i].Index
, result.PossibleMoves[i].DiceValue
);
}
}
public void test_rules_h4_b0_s0_d_rbyg6_rbyg6_rbyg2()
{
/** multiple player roll sequence test
* Setting inital position 4 player game
* each player rolls:
* 6 - 6 - 2
* Expected Result
* A figure of each player should local position 8
* world position red : 8
* world position black : 18
* world position yellow : 28
* world position green : 38
*/
CheckMovesResult result = null;
var diceRolls = new[] { "r6", "r6", "r2", "b6", "b6", "b2", "y6", "y6", "y2", "g6", "g6", "g2" };
for (int i = 0, n = diceRolls.Length; i < n; i++)
{
result = CheckRules(diceRolls[i]);
if (!result.CanMove)
{
break;
}
result = _gameboard.Move(CheckRules(diceRolls[i]));
}
int numberOfRedFigures = nvp_RuleHelper.CountPlayersOnBoard(PlayerColors.red, result.PlayerFigures);
int numberOfGreenFigures = nvp_RuleHelper.CountPlayersOnBoard(PlayerColors.green, result.PlayerFigures);
int numberOfYellowFigures = nvp_RuleHelper.CountPlayersOnBoard(PlayerColors.yellow, result.PlayerFigures);
int numberOfBlackFigures = nvp_RuleHelper.CountPlayersOnBoard(PlayerColors.black, result.PlayerFigures);
Assert.AreEqual(1, numberOfRedFigures);
Assert.AreEqual(1, numberOfYellowFigures);
Assert.AreEqual(1, numberOfGreenFigures);
Assert.AreEqual(1, numberOfBlackFigures);
var pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 8);
Assert.AreEqual(PlayerColors.red, pf.Color);
pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 18);
Assert.AreEqual(PlayerColors.black, pf.Color);
pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 28);
Assert.AreEqual(PlayerColors.yellow, pf.Color);
pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 38);
Assert.AreEqual(PlayerColors.green, pf.Color);
}
private void OnPlayerMovesCalculated(CheckMovesResult result)
{
DeactivateButtons();
if (result.CanMove)
{
Invoke("InvokeTurn", 0.1f);
// if(result.PossibleMoves.Count > 1) {
// ActivateButtons(result.PossibleMoves.Count);
// }
// else{
// Invoke("InvokeTurn", 0.1f);
// }
}
}
public CheckMovesResult Move(CheckMovesResult movesInfo, int indexMoveToMake = 0)
{
if (!movesInfo.CanMove)
{
return(movesInfo);
}
var move = movesInfo.PossibleMoves[indexMoveToMake];
var figure = playerFigures.Single(x =>
x.Color == move.Color &&
x.Index == move.Index);
figure.Move(move.DiceValue);
return(movesInfo);
}
public void test_rules_h4_b0_s0_d_g6_g6_g6_g5_g6_g4_g4()
{
/** multiple figures of red player on board
* Setting inital position 4 player game
* red player rolls:
* 6-6-6-5-6-4-4
* Expected Result
* world position red-0 : 6
* world position red-1 : 5
* world position red-2 : 8
*/
CheckMovesResult result = null;
var diceRolls = new[] { "r6", "r6", "r6", "r5", "r6", "r4", "r4" };
for (int i = 0, n = diceRolls.Length; i < n; i++)
{
result = CheckRules(diceRolls[i]);
if (!result.CanMove)
{
break;
}
result = result.PossibleMoves.Count == 1
? _gameboard.Move(CheckRules(diceRolls[i]))
: _gameboard.Move(CheckRules(diceRolls[i]), 2);
}
// There should be 3 figures on board
int numberOfGreenfigures = nvp_RuleHelper.CountPlayersOnBoard(PlayerColors.red, result.PlayerFigures);
Assert.AreEqual(3, numberOfGreenfigures);
// 3 move should be possible after the last roll
Assert.AreEqual(true, result.CanMove);
Assert.AreEqual(3, result.PossibleMoves.Count);
// if we move the figure with the index 2 for the last roll
//
var pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 5);
Assert.AreEqual(PlayerColors.red, pf.Color);
pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 6);
Assert.AreEqual(PlayerColors.red, pf.Color);
pf = nvp_RuleHelper.GetFigureOnWorldPosition(_gameboard.playerFigures, 8);
Assert.AreEqual(PlayerColors.red, pf.Color);
Assert.AreEqual(2, pf.Index);
}
public void test_throwing_out_black_player()
{
var player_red_0 = nvp_RuleHelper.GetPlayerFigure(_gameboard.playerFigures, PlayerColors.red, 0);
var player_black_0 = nvp_RuleHelper.GetPlayerFigure(_gameboard.playerFigures, PlayerColors.black, 0);
// move black player to position
CheckMovesResult result = null;
var diceRolls = new[] { "b6", "b1", "r6", "r6" };
for (int i = 0, n = diceRolls.Length; i < n; i++)
{
result = CheckRules(diceRolls[i]);
if (!result.CanMove)
{
break;
}
result = result.PossibleMoves.Count == 1
? _gameboard.Move(CheckRules(diceRolls[i]))
: _gameboard.Move(CheckRules(diceRolls[i]), 0);
}
Assert.AreEqual(1, player_black_0.LocalPosition);
Assert.AreEqual(11, player_black_0.WorldPosition);
Assert.AreEqual(6, player_red_0.LocalPosition);
Assert.AreEqual(6, player_red_0.WorldPosition);
diceRolls = new[] { "r5" };
for (int i = 0, n = diceRolls.Length; i < n; i++)
{
result = CheckRules(diceRolls[i]);
if (!result.CanMove)
{
break;
}
result = result.PossibleMoves.Count == 1
? _gameboard.Move(CheckRules(diceRolls[i]))
: _gameboard.Move(CheckRules(diceRolls[i]), 0);
}
Assert.AreEqual(-1, player_black_0.LocalPosition);
Assert.AreEqual(-1, player_black_0.WorldPosition);
Assert.AreEqual(11, player_red_0.LocalPosition);
Assert.AreEqual(11, player_red_0.WorldPosition);
}
public CheckMovesResult CheckRule(CheckMovesResult result)
{
// no player figure is on the game field which means no player figure has movepoint score between 0 and up to 40
var numberOfFiguresOnBoard = nvp_RuleHelper.CountPlayersOnBoard(result.PlayerColor, result.PlayerFigures);
// at least on player figure is in the house
var numberOfPlayerInTheHouse = nvp_RuleHelper.CountPlayersInHouse(result.PlayerColor, result.PlayerFigures);
// general rule
if (numberOfFiguresOnBoard > 0 || numberOfPlayerInTheHouse == 0)
{
return(_nextRule.CheckRule(result));
}
_numberOfTries++;
if (_numberOfTries >= 3 && result.DiceValue < 6)
{
// used all free rolls
result.LastActiveRule = "nvp_Rule_40_Cant_leave_house_class";
result.CanMove = false;
result.AdditionalRollGranted = false;
_numberOfTries = 0;
return(result);
}
if (result.DiceValue == 6)
{
result.LastActiveRule = "nvp_Rule_40_Cant_leave_house_class";
result.CanMove = true;
result.AdditionalRollGranted = true;
_numberOfTries = 0;
return(result);
}
else
{
result.CanMove = false;
result.AdditionalRollGranted = true;
result.LastActiveRule = "nvp_Rule_40_Cant_leave_house_class";
return(result);
}
}
public void test_rule_must_kill_v0()
{
CheckMovesResult result = new CheckMovesResult {
DiceValue = 2
};
var rf1 = new PlayerFigure(PlayerColors.red, 0, 1, 1, 0);
var rf2 = new PlayerFigure(PlayerColors.red, 1, 2, 2, 0);
var gf1 = new PlayerFigure(PlayerColors.green, 0, 13, 3, 10);
result.PlayerFigures.AddRange(new[] { rf1, rf2, gf1 });
var rule = new nvp_Rule_50_HaveToKill().SetNextRule(new nvp_RuleDefault_class());
result = rule.CheckRule(result);
Assert.AreEqual(true, result.CanMove);
Assert.AreEqual(false, result.AdditionalRollGranted);
Assert.AreEqual(1, result.PossibleMoves.Count);
Assert.AreEqual(0, result.PossibleMoves[0].Index);
}
private bool CheckRuleForFigure(CheckMovesResult result, PlayerFigure figureToCheck)
{
int worlPositionToCheck = (figureToCheck.WorldPosition + result.DiceValue) % 41;
PlayerFigure playerFigureFound = nvp_RuleHelper.GetFigureOnWorldPosition(result.PlayerFigures, worlPositionToCheck);
if (playerFigureFound == null || (playerFigureFound != null && playerFigureFound.Color == result.PlayerColor))
{
return(false);
}
result.CanMove = true;
result.LastActiveRule = "nvp_Rule_50_HaveToKill";
result.PossibleMoves.Add(new PlayerMove
{
Color = result.PlayerColor,
DiceValue = result.DiceValue,
Index = figureToCheck.Index
});
return(true);
}
public CheckMovesResult CheckRule(PlayerColors playerColor, List <PlayerFigure> playerFigures, int diceNumber)
{
// no player figure is on the game field which means no player figure has movepoint score between 0 and up to 40
var numberOfFiguresOnBoard = nvp_RuleHelper.CountPlayersOnBoard(playerColor, playerFigures);
// at least on player figure is in the house
var numberOfPlayerInTheHouse = nvp_RuleHelper.CountPlayersInHouse(playerColor, playerFigures);
// general rule
if (numberOfFiguresOnBoard > 0 || numberOfPlayerInTheHouse == 0)
{
return(_nextRule.CheckRule(playerColor, playerFigures, diceNumber));
}
CheckMovesResult result = null;
_numberOfTries++;
if (_numberOfTries >= 3 && diceNumber < 6)
{
// used all free rolls
result = new CheckMovesResult(false, false, "nvp_Rule_5to1_all_in_house_class");
_numberOfTries = 0;
return(result);
}
if (diceNumber == 6)
{
result = new CheckMovesResult(true, true, "nvp_Rule_5to1_all_in_house_class");
_numberOfTries = 0;
return(result);
}
else
{
result = new CheckMovesResult(false, true, "nvp_Rule_5to1_all_in_house_class");
return(result);
}
}
void OnPlayerMovesCalculated(CheckMovesResult result)
{
_lastCalculatedMoveResult = result;
}
public CheckMovesResult CheckRule(PlayerColors playerColor, List <PlayerFigure> playerFigures, int diceNumber)
{
var result = new CheckMovesResult(false, false, "End of rule chain reached.");
return(result);
}
