public void KnightCantCaptureFriendlyPieces()
{
//BK - black knight
//PM - possible move
//BP - black piece
//7 BK
//6 BP
//5 BP BP
//4
//3
//2
//1
//0
// 0 1 2 3 4 5 6 7
var boardMock = new Mock <IChessBoard>(MockBehavior.Strict);
var knightMock = new Mock <IReadOnlyChessPiece>(MockBehavior.Strict);
var knightPosition = new Position(6, 7);
var blackPiece1Position = new Position(4, 6);
var blackPiece2Position = new Position(5, 5);
var blackPiece3Position = new Position(7, 5);
knightMock
.SetupGet(p => p.Color)
.Returns(ChessColor.Black);
knightMock
.SetupGet(p => p.PieceType)
.Returns(ChessPieceType.Knight);
knightMock
.SetupGet(p => p.Position)
.Returns(knightPosition);
knightMock
.SetupGet(p => p.HasMoved)
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(blackPiece1Position))
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(blackPiece2Position))
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(blackPiece3Position))
.Returns(true);
boardMock
.Setup(b => b.IsEnemyOnPosition(blackPiece1Position, ChessColor.White))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(blackPiece2Position, ChessColor.White))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(blackPiece3Position, ChessColor.White))
.Returns(false);
var movement = new KnightMovement(boardMock.Object);
var availableMoves = movement.GetAvailableMoves(knightMock.Object);
Assert.AreEqual(0, availableMoves.Count());
}
public override void TriggerBattle(KnightMovement src)
{
if (enemy == null || enemy.name != src.name)
{
SoundManager.PLAY_SOUND("SUDDEN", 0.9f, 0.9f);
}
base.TriggerBattle(src);
SoundManager.SetOSTState(SoundManager.OSTEvent.BATTLE, true);
TriggerSwingZoom(10);
TutorialManager.SetTutorial("BattleSwing");
}
void Awake()
{
myPhotonView = this.GetComponent<PhotonView>();
myHealth = this.GetComponent<Health>();
myHealth.currentHealth = maxHealth;
fxManager = GameObject.FindObjectOfType<FXManager>();
fxManagerPhotonView = fxManager.GetComponent<PhotonView>();
netMan = GameObject.FindObjectOfType<NetMan>();
netManPhotonView = netMan.GetComponent<PhotonView>();
myMovement = this.GetComponent<KnightMovement>();
}
// A variable to change the color of the Player wen he changes the character
//private MeshRenderer render;
// Use this for initialization
void Start()
{
rb = GetComponent <Rigidbody2D>();
// The scripts of the other characters
c0Script = GetComponent <ElfMovement>();
c1Script = GetComponent <KnightMovement>();
c2Script = GetComponent <MagicMovement>();
//// The component to switch the color for each character
//render = GetComponent<MeshRenderer>();
anim = GetComponent <Animator>();
}
public virtual void AttackKnight(KnightMovement knight)
{
float dmg = knightDMG;
if (meleeAction == MELEE_ACTION.SWING)
{
dmg *= knightSwingBonusFactor;
}
uint dmgi = (uint)dmg;
float newHealth = (float)(knight.health - dmg);
if (newHealth < 0)
{
newHealth = 0;
}
knight.Hurt((int)dmgi, gameObject);
if (client != null)
{
client.SendDamageToServer(knight.client.playerIndex, newHealth);
}
}
private void Awake()
{
movement = new KnightMovement();
}
public virtual void UntriggerBattle(bool victory = false)
{
enemy = null;
inBattle = false;
}
public virtual void TriggerBattle(KnightMovement src)
{
inBattle = true;
enemy = src;
}
public void KnightCanJumpThroughAnyObstacle()
{
//BK - black knight
//PM - possible move
//EP - enemy piece
//BP - black piece
//7 BP BK BP
//6 EP BP EP PM
//5 PM PM
//4
//3
//2
//1
//0
// 0 1 2 3 4 5 6 7
var boardMock = new Mock <IChessBoard>(MockBehavior.Strict);
var knightMock = new Mock <IReadOnlyChessPiece>(MockBehavior.Strict);
var knightPosition = new Position(1, 7);
var blackPiece1Position = new Position(0, 7);
var blackPiece2Position = new Position(1, 6);
var blackPiece3Position = new Position(2, 7);
var enemyPiece1Position = new Position(0, 6);
var enemyPiece2Position = new Position(2, 6);
var availableFinishPosition01 = new Position(0, 5);
var availableFinishPosition02 = new Position(2, 5);
var availableFinishPosition03 = new Position(3, 6);
var friendlyPiecesPositions = new List <Position>()
{
blackPiece1Position, blackPiece2Position,
blackPiece3Position
};
var enemyPositions = new List <Position>()
{
enemyPiece1Position, enemyPiece2Position
};
var emptyPositions = new List <Position>()
{
availableFinishPosition01,
availableFinishPosition02,
availableFinishPosition03
};
knightMock
.SetupGet(p => p.Color)
.Returns(ChessColor.Black);
knightMock
.SetupGet(p => p.PieceType)
.Returns(ChessPieceType.Knight);
knightMock
.SetupGet(p => p.Position)
.Returns(knightPosition);
knightMock
.SetupGet(p => p.HasMoved)
.Returns(false);
boardMock
.Setup(b => b.IsPositionTaken(It.IsIn <Position>(friendlyPiecesPositions)))
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(It.IsIn <Position>(enemyPositions)))
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(It.IsIn <Position>(emptyPositions)))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(It.IsIn <Position>(friendlyPiecesPositions), ChessColor.White))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(It.IsIn <Position>(enemyPositions), ChessColor.White))
.Returns(true);
boardMock
.Setup(b => b.IsEnemyOnPosition(It.IsIn <Position>(emptyPositions), ChessColor.White))
.Returns(false);
var movement = new KnightMovement(boardMock.Object);
var availableMoves = movement.GetAvailableMoves(knightMock.Object);
Assert.AreEqual(3, availableMoves.Count());
Assert.IsTrue(availableMoves.All(m => m.StartingPosition == knightPosition));
var finishedPositions = availableMoves
.Select(m => m.FinishedPosition)
.ToList();
Assert.Contains(availableFinishPosition01, finishedPositions);
Assert.Contains(availableFinishPosition02, finishedPositions);
Assert.Contains(availableFinishPosition03, finishedPositions);
}
public void KnightCanCaptureEnemyPieces()
{
//WK - white knight
//PM - possible move
//EP - enemy piece
//7
//6
//5
//4
//3 EP
//2 PM
//1 WK
//0 PM
// 0 1 2 3 4 5 6 7
var boardMock = new Mock <IChessBoard>(MockBehavior.Strict);
var knightMock = new Mock <IReadOnlyChessPiece>(MockBehavior.Strict);
var knightPosition = new Position(7, 1);
var enemyPiecePosition = new Position(6, 3);
var availableFinishPosition01 = new Position(5, 0);
var availableFinishPosition02 = new Position(5, 2);
knightMock
.SetupGet(p => p.Color)
.Returns(ChessColor.White);
knightMock
.SetupGet(p => p.PieceType)
.Returns(ChessPieceType.Knight);
knightMock
.SetupGet(p => p.Position)
.Returns(knightPosition);
knightMock
.SetupGet(p => p.HasMoved)
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(enemyPiecePosition))
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(availableFinishPosition01))
.Returns(false);
boardMock
.Setup(b => b.IsPositionTaken(availableFinishPosition02))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(enemyPiecePosition, ChessColor.Black))
.Returns(true);
boardMock
.Setup(b => b.IsEnemyOnPosition(availableFinishPosition01, ChessColor.Black))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(availableFinishPosition02, ChessColor.Black))
.Returns(false);
var movement = new KnightMovement(boardMock.Object);
var availableMoves = movement.GetAvailableMoves(knightMock.Object);
Assert.AreEqual(3, availableMoves.Count());
Assert.IsTrue(availableMoves.All(m => m.StartingPosition == knightPosition));
var finishedPositions = availableMoves
.Select(m => m.FinishedPosition)
.ToList();
Assert.Contains(availableFinishPosition01, finishedPositions);
Assert.Contains(availableFinishPosition02, finishedPositions);
Assert.Contains(enemyPiecePosition, finishedPositions);
}
public void KnightMoveTest()
{
//WK - white knight
//PM - possible move
//7
//6
//5 PM PM
//4 PM PM
//3 WK
//2 PM PM
//1 PM PM
//0
// 0 1 2 3 4 5 6 7
var boardMock = new Mock <IChessBoard>(MockBehavior.Strict);
var knightMock = new Mock <IReadOnlyChessPiece>(MockBehavior.Strict);
var knightPosition = new Position(4, 3);
var availableFinishPosition01 = new Position(5, 1);
var availableFinishPosition02 = new Position(6, 2);
var availableFinishPosition03 = new Position(6, 4);
var availableFinishPosition04 = new Position(5, 5);
var availableFinishPosition05 = new Position(3, 5);
var availableFinishPosition06 = new Position(2, 4);
var availableFinishPosition07 = new Position(2, 2);
var availableFinishPosition08 = new Position(3, 1);
knightMock
.SetupGet(p => p.Color)
.Returns(ChessColor.White);
knightMock
.SetupGet(p => p.PieceType)
.Returns(ChessPieceType.Knight);
knightMock
.SetupGet(p => p.Position)
.Returns(knightPosition);
knightMock
.SetupGet(p => p.HasMoved)
.Returns(true);
boardMock
.Setup(b => b.IsPositionTaken(It.IsAny <Position>()))
.Returns(false);
boardMock
.Setup(b => b.IsEnemyOnPosition(It.IsAny <Position>(), It.IsAny <ChessColor>()))
.Returns(false);
var movement = new KnightMovement(boardMock.Object);
var availableMoves = movement.GetAvailableMoves(knightMock.Object);
Assert.AreEqual(8, availableMoves.Count());
Assert.IsTrue(availableMoves.All(m => m.StartingPosition == knightPosition));
var finishedPositions = availableMoves
.Select(m => m.FinishedPosition)
.ToList();
Assert.Contains(availableFinishPosition01, finishedPositions);
Assert.Contains(availableFinishPosition02, finishedPositions);
Assert.Contains(availableFinishPosition03, finishedPositions);
Assert.Contains(availableFinishPosition04, finishedPositions);
Assert.Contains(availableFinishPosition05, finishedPositions);
Assert.Contains(availableFinishPosition06, finishedPositions);
Assert.Contains(availableFinishPosition07, finishedPositions);
Assert.Contains(availableFinishPosition08, finishedPositions);
}
/// <summary>
/// Awake is called when the script instance is being loaded.
/// </summary>
protected override void Start()
{
base.Start();
movement = new KnightMovement(maxTeam);
}
