public static Piece GetType(string s, ChessColor color)
{
Piece p;
switch (s)
{
case "Bishop":
p = new Bishop(color);
break;
case "King":
p = new King(color);
break;
case "Knight":
p = new Knight(color);
break;
case "Pawn":
p = new Pawn(color);
break;
case "Queen":
p = new Queen(color);
break;
case "Rook":
p = new Rook(color);
break;
default:
throw new Exception("Piece unknown : " + s);
}
return p;
}
protected override void ExecuteInsertUnitCommand(string[] commandWords)
{
switch (commandWords[1])
{
case "Tank":
var tank = new Tank(commandWords[2]);
this.InsertUnit(tank);
break;
case "Marine":
var marine = new Marine(commandWords[2]);
this.InsertUnit(marine);
break;
case "Parasite":
var parasite = new Parasite(commandWords[2]);
this.InsertUnit(parasite);
break;
case "Queen":
var queen = new Queen(commandWords[2]);
this.InsertUnit(queen);
break;
default:
base.ExecuteInsertUnitCommand(commandWords);
break;
}
}
protected override void ExecuteInsertUnitCommand(string[] commandWords)
{
Unit unit = null;
switch (commandWords[1])
{
case "Tank":
unit = new Tank(commandWords[2]);
break;
case "Marine":
unit = new Marine(commandWords[2]);
break;
case "Parasite":
unit = new Parasite(commandWords[2]);
break;
case "Queen":
unit = new Queen(commandWords[2]);
break;
default:
break;
}
if (unit != null)
{
base.InsertUnit(unit);
}
base.ExecuteInsertUnitCommand(commandWords);
}
public Queens(Queen white, Queen black)
{
White = white;
Black = black;
if (White.Rank == Black.Rank && White.File == Black.File)
throw new ArgumentException();
}
// Use this for initialization
void Start()
{
myQueen = new Queen();
myKing = new King();
currentCharacter = myQueen;
currentCharacter.outfit = queenOutfit;
currentCharacter.weapon.setWeapon(knife, "knife");
}
public void Setup()
{
_whiteQueen = new Queen(PlayerColor.White);
_blackQueen = new Queen(PlayerColor.Black);
_whiteStart = new BoardCoordinate(1, 1);
_board.AddPiece(_whiteQueen, _whiteStart);
}
public override ChessPiece Clone(Board board)
{
var clone = new Queen(board, Color)
{
MovingStrategy = MovingStrategy.Clone(board)
};
return clone;
}
public static void TestInequality_DifferentPieceAndPlayer()
{
Piece piece1 = new King(Player.White);
Piece piece2 = new Queen(Player.Black);
Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
Assert.False(piece1.Equals(piece2), "piece1.Equals(piece2) should be false");
Assert.False(piece2.Equals(piece1), "piece2.Equals(piece1) should be false");
Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
Assert.AreNotEqual(piece1.GetHashCode(), piece2.GetHashCode(), "Hash codes are equal");
}
public HomeModule()
{
Get["/"] = _ => {
return View["index.cshtml"];
};
Post["/output"] = _ =>
{
var newQueen = new Queen(Request.Form["queen-x"], Request.Form["queen-y"]);
var output = ( newQueen.AttackHorizontal(Request.Form["opp-x"], Request.Form["opp-y"])
|| newQueen.AttackVertical(Request.Form["opp-x"], Request.Form["opp-y"])
|| newQueen.AttackDiagonal(Request.Form["opp-x"], Request.Form["opp-y"]) );
return View["output.cshtml", output];
};
}
public Form1()
{
InitializeComponent();
comboBox1.SelectedIndex = 0;
Worker[] workers = new Worker[4];
workers[0] = new Worker(new string[] { "Nectar collector", "Honey manufacturing" },152);
workers[1] = new Worker(new string[] { "Egg care", "Baby bee tutoring" },200);
workers[2] = new Worker(new string[] { "Hive maintenance", "Sting patrol" },120);
workers[3] = new Worker(new string[] { "Nectar collector", "Honey manufacturing",
"Egg care", "Baby bee tutoring", "Hive maintenance", "Sting patrol" },112);
queen = new Queen(workers,355);
}
public void TestFromFenValid()
{
const string FEN_STRING = "pQ4N1/3k3R/1r4n1/KbBbBppP/8/8/q7/7n";
FENSerializer ser = new FENSerializer();
Board expected = new Board(null);
Board actual;
// Setup
expected['8', 'A'] = new Pawn('b');
expected['8', 'B'] = new Queen('w');
expected['8', 'G'] = new Knight('w');
expected['7', 'D'] = new King('b');
expected['7', 'H'] = new Rook('w');
expected['6', 'B'] = new Rook('b');
expected['6', 'G'] = new Knight('b');
expected['5', 'A'] = new King('w');
expected['5', 'B'] = new Bishop('b');
expected['5', 'C'] = new Bishop('w');
expected['5', 'D'] = new Bishop('b');
expected['5', 'E'] = new Bishop('w');
expected['5', 'F'] = new Pawn('b');
expected['5', 'G'] = new Pawn('b');
expected['5', 'H'] = new Pawn('w');
expected['2', 'A'] = new Queen('b');
expected['1', 'H'] = new Knight('b');
// Act
actual = ser.Deserialize(FEN_STRING);
// Test
for (int file = 0; file < Board.NUM_FILES; file++)
{
for (int row = 0; row < Board.NUM_ROWS; row++)
{
Piece expectedPiece = expected[row, file];
Piece actualPiece = actual[row, file];
bool areEqual = Piece.AreEqual(expectedPiece, actualPiece);
Assert.IsTrue(areEqual);
}
}
}
public void placeBlackFigures()
{
Figure[] pawns = new Figure[8];
Figure[] otherFigures = new Figure[8];
char currentChar = 'A';
char charPositionPawn = 'A';
for (int i = 0; i < 8; i++)
{
pawns[i] = new Pawn(charPositionPawn, 2, false);
charPositionPawn++;
if ((currentChar == 'A') || (currentChar == 'H'))
{
otherFigures[i] = new Rook(currentChar, 1, false);
}
else if ((currentChar == 'B') || (currentChar == 'G'))
{
otherFigures[i] = new Knight(currentChar, 1, false);
}
else if ((currentChar == 'C') || (currentChar == 'F'))
{
otherFigures[i] = new Bishop(currentChar, 1, false);
}
else if (currentChar == 'E')
{
otherFigures[i] = new King(currentChar, 1, false);
}
else
{
otherFigures[i] = new Queen(currentChar, 1, false);
}
currentChar++;
}
for (int i = 0; i < 8; i++)
{
placeFigure(pawns[i]);
placeFigure(otherFigures[i]);
}
}
public MainWindow()
{
InitializeComponent();
jobs = new string[] { "Nectar collector" , "Honey manufactoring", "Egg care",
"Baby bee tutoring", "Hive maintenance", "Sting patrol" };
foreach (string j in jobs)
{
cbJob.Items.Add(j);
}
//cbJob.Sorted = true;
cbJob.SelectedIndex = 0;
Worker[] workers = new Worker[4];
workers[0] = new Worker(new string[] { jobs[0], jobs[1] }, 175);
workers[1] = new Worker(new string[] { jobs[2], jobs[3] }, 114);
workers[2] = new Worker(new string[] { jobs[4], jobs[5] }, 149);
workers[3] = new Worker(new string[] { jobs[0], jobs[1], jobs[2], jobs[3], jobs[4], jobs[5] }, 155);
queen = new Queen(workers, 275);
}
static void Main(string[] args)
{
ChessBoard masa = new ChessBoard();
//masa.placeWhiteFigures();
//masa.placeBlackFigures();
//Console.WriteLine(masa);
Console.WriteLine(masa);
Queen C = new Queen('A', 2, true);
Queen D = new Queen('B',3, true);
Queen S = new Queen('C', 4, true);
masa.placeFigure(C);
masa.placeFigure(D);
masa.placeFigure(S);
Console.WriteLine(masa.PathBetweenBoxesFree(masa.getChessBoxByCoordinates('C', 4), masa.getChessBoxByCoordinates('A', 2)));
Console.WriteLine(masa);
}
public void BeforeEachTest()
{
Target = new Queen();
MovesFrom_1_1 = Target.GetMovesFrom(new BoardCoordinate(1, 1));
}
public void UserPlace_CanPlaceUserChar_True()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(true, testQueenAttack.UserPlace('2', '7'));
}
public void PlacementCheckStack_CanPlaceSameCoordinates_False()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(false, testQueenAttack.PlacementCheckStack(1, 1, 1, 1));
}
private bool IsCellDataCorrect(Queen queen)
{
return(queen.State == QueenState.Lopšys && queen.HatchingDate == null &&
queen.MarkingColor == null && queen.IsFertilized == false &&
queen.BroodStartDate == null);
}
public void QueenPlace_CanPlaceQueenChar_True()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(true, testQueenAttack.QueenPlace('4', '8'));
}
/* Numbers of chessmen are: 0 - King, 1 - Queen, 2 - Bishop, 3 - Knight, 4 - Tower,
* 5 - Pawn of Queen, 6 - Pawn of Bishop, 7 - Pawn of Knight, 8 - Pawn of Tower.
* Numbers of players are: 0 - Yellow, 1 - Red, 2 - Blue, 3 - Black.
* Number of arrangement - numberOfArrangement. */
public Chessman CreateNewChessman(string playersColor, string chessmanName, Chessboard chessboard)
{
int indexOfPlayer = -1;
int indexOfChessman = -1;
ChessmenParameters chessmanParam = new ChessmenParameters();
Chessman result;
//gets number of player
switch (playersColor)
{
case "Yellow": indexOfPlayer = 0;
break;
case "Red": indexOfPlayer = 1;
break;
case "Blue": indexOfPlayer = 2;
break;
case "Black": indexOfPlayer = 3;
break;
default:
{
MessageBox.Show("Внутренняя ошибка, невозможно выполнить действие");
return null;
}
}
//gets number of chessman
switch (chessmanName)
{
case "King": indexOfChessman = 0;
break;
case "Queen": indexOfChessman = 1;
break;
case "Bishop": indexOfChessman = 2;
break;
case "Knight": indexOfChessman = 3;
break;
case "Tower": indexOfChessman = 4;
break;
case "PawnOfQueen": indexOfChessman = 5;
chessmanName = "Pawn of Queen";
break;
case "PawnOfBishop": indexOfChessman = 6;
chessmanName = "Pawn of Bishop";
break;
case "PawnOfKnight": indexOfChessman = 7;
chessmanName = "Pawn of Knight";
break;
case "PawnOfTower": indexOfChessman = 8;
chessmanName = "Pawn of Tower";
break;
default:
{
MessageBox.Show("Внутренняя ошибка, невозможно выполнить действие");
return null;
}
}
//set parameters
chessmanParam.horizontal = positionOfChessmen[numberOfArrangement, indexOfPlayer, indexOfChessman, 1];
chessmanParam.vertical = positionOfChessmen[numberOfArrangement, indexOfPlayer, indexOfChessman, 0];
chessmanParam.ruNameNominative = GetNominativeRu(indexOfPlayer, indexOfChessman);
chessmanParam.engName = playersColor + ' ' + chessmanName;
chessmanParam.chessmanBitmap = chessmanBitmap[indexOfPlayer, indexOfChessman];
chessmanParam.ruNameAccusative = GetAccusativeRu(indexOfPlayer, indexOfChessman);
chessmanParam.kindOfChessman = (ChessmenNames)indexOfChessman;
chessmanParam.player = (Players)indexOfPlayer;
chessmanParam.ruAttack = GetAttackRu(indexOfChessman);
chessmanParam.ruMove = GetMoveRu(indexOfChessman);
switch (indexOfChessman)
{
case 0: result = new King(chessmanParam, chessboard);
break;
case 1: result = new Queen(chessmanParam, chessboard);
break;
case 2: result = new Bishop(chessmanParam, chessboard);
break;
case 3: result = new Knight(chessmanParam, chessboard);
break;
case 4: result = new Tower(chessmanParam, chessboard);
break;
case 5: result = GetNewCorrectPawn(chessmanParam, chessboard);
break;
case 6: result = GetNewCorrectPawn(chessmanParam, chessboard);
break;
case 7: result = GetNewCorrectPawn(chessmanParam, chessboard);
break;
case 8: result = GetNewCorrectPawn(chessmanParam, chessboard);
break;
default:
{
result = null;
break;
}
}
return result;
}
public void isAttackLeagal_AttackDiagonal_True()
{
Queen testQueen = new Queen();
Assert.AreEqual(true, testQueen.isAttackLeagal(5, 5, 4, 4));
}
public void CanAttack_CanAttackNegativeCoordinates_True()
{
Queen newQueen = new Queen(0, 0);
Assert.AreEqual(true, newQueen.CanAttack(-2, -2));
}
public void isAttackLeagal_AttackHorizontal_True()
{
Queen testQueen = new Queen();
Assert.AreEqual(true, testQueen.isAttackLeagal(2, 1, 2, 5));
}
public void CanAttack_DiagonalPosition_True()
{
Queen newQueen = new Queen(1, 2);
Assert.AreEqual(true, newQueen.CanAttack(2, 3));
}
public void CanAttack_CantAttack_False()
{
Queen newQueen = new Queen(0, 0);
Assert.AreEqual(false, newQueen.CanAttack(1, 2));
}
public void CanAttack_VerticalPosition_True()
{
Queen newQueen = new Queen(0, 0);
Assert.AreEqual(true, newQueen.CanAttack(0, 4));
}
public void CanAttack_HorizontalPosition_True()
{
Queen newQueen = new Queen(0, 0);
Assert.AreEqual(true, newQueen.CanAttack(3, 0));
}
public void QueenConstructor_CreateInstanceOfQueen_Queen()
{
Queen newQueen = new Queen(0, 0);
Assert.AreEqual(typeof(Queen), newQueen.GetType());
}
public static void initGame()
{
Console.Clear();
//initalize game
Random rnd = new Random ();
if (rnd.Next(2)==1)
{
State.playerOneColor = "White";
}
else
{
State.playerOneColor = "Black";
}
State.moveNumber = 0;
State.turn = "White";
State.strength = 18;
//Initiate White pieces
Piece k2 = new King (4, 0, "White");
Piece q1 = new Queen(3, 0, "White");
Piece r1 = new Rook(0, 0, "White");
Piece r2 = new Rook(7, 0, "White");
Piece b1 = new Bishop (5, 0, "White");
Piece b2 = new Bishop (2, 0, "White");
Piece n1 = new Knight (1, 0, "White");
Piece n2 = new Knight (6, 0, "White");
//pawns
Piece p0 = new Pawn (0, 1, "White");
Piece p1 = new Pawn (1, 1, "White");
Piece p2 = new Pawn (2, 1, "White");
Piece p3 = new Pawn (3, 1, "White");
Piece p4 = new Pawn (4, 1, "White");
Piece p5 = new Pawn (5, 1, "White");
Piece p6 = new Pawn (6, 1, "White");
Piece p7 = new Pawn (7, 1, "White");
//Initiate Black pieces
Piece k1 = new King (4, 7, "Black");
Piece q2 = new Queen (3, 7, "Black");
Piece r3 = new Rook (0, 7, "Black");
Piece r4 = new Rook (7, 7, "Black");
Piece b3 = new Bishop(5, 7, "Black");
Piece b4 = new Bishop(2, 7, "Black");
Piece n3 = new Knight (1,7, "Black");
Piece n4 = new Knight (6,7, "Black");
//pawns
Piece p8 = new Pawn (0, 6, "Black");
Piece p9 = new Pawn (1, 6, "Black");
Piece p10 = new Pawn (2, 6, "Black");
Piece p11 = new Pawn (3, 6, "Black");
Piece p12 = new Pawn (4, 6, "Black");
Piece p13 = new Pawn (5, 6, "Black");
Piece p14 = new Pawn (6, 6, "Black");
Piece p15 = new Pawn (7, 6, "Black");
//Add pieces to piece array
Piece[] pieces = new Piece[] {k1, k2, q1, q2,
r1, r2, r3, r4, n1, n2, n3, n4, b1, b2, b3, b4,
p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15};
//Send setup back to the state
State.addPiece(pieces);
}
public static new void AddMoves(PieceType type)
{
Queen.AddMoves(type);
type.CustomMoveGenerator = CustomMoveGenerationHandler;
}
private bool Equals(Queen other)
{
return !ReferenceEquals(null, other)
&& Color == other.Color;
}
StrandsToPieces(string strands)
{
var pieces = new List <Piece>();
Color color;
string sym;
char f;
char r;
int file;
int rank;
Piece piece;
foreach (var strand in strands.ToLower().Split())
{
if (strand.Length != 4)
{
continue;
}
// color
if (char.ToLower(strand[0]) == 'b')
{
color = Color.Black;
}
else if (char.ToLower(strand[0]) == 'w')
{
color = Color.White;
}
else
{
continue;
}
// sym
sym = char.ToLower(strand[1]).ToString();
if (!Regex.IsMatch(sym, @"[prnbqk]"))
{
continue;
}
// square
f = strand[2];
r = strand[3];
if (!ValidSquare(f, r))
{
continue;
}
file = ToFileNum(char.ToLower(f));
rank = ToRankNum(char.ToLower(r));
// piece
piece = new Pawn(color, file, rank);
if (sym == "r")
{
piece = new Rook(color, file, rank);
}
else if (sym == "n")
{
piece = new Knight(color, file, rank);
}
else if (sym == "b")
{
piece = new Bishop(color, file, rank);
}
else if (sym == "q")
{
piece = new Queen(color, file, rank);
}
else if (sym == "k")
{
piece = new King(color, file, rank);
}
pieces.Add(piece);
}
return(pieces);
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerChess"/> class.
/// </summary>
/// <param name="color">The piece color.</param>
/// <param name="gameboard">The gameboard.</param>
public PlayerChess(IPieceColor color, Gameboard gameboard)
: base(color)
{
IPiece newPiece;
int offset = 0;
this.gameboard = gameboard;
this.selectedPiece = null;
if (color == IPieceColor.White)
{
offset = 7;
}
else if (color == IPieceColor.Black)
{
offset = 0;
}
for (int i = 0; i < 8; i++)
{
newPiece = new Pawn(color, gameboard, new Position(i, Math.Abs(offset - 1)));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
}
newPiece = new Rook(color, gameboard, new Position(0, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Rook(color, gameboard, new Position(7, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Knight(color, gameboard, new Position(1, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Knight(color, gameboard, new Position(6, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Bishop(color, gameboard, new Position(2, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Bishop(color, gameboard, new Position(5, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new Queen(color, gameboard, new Position(3, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
newPiece = new King(color, gameboard, new Position(4, offset));
newPiece.GameEvent += new PieceEvent(this.Piece_GameEvent);
this.PieceList.Add(newPiece);
this.King = newPiece;
}
public static bool CanAttack(Queen white, Queen black)
{
return(white.Row == black.Row || white.Column == black.Column);
}
public static void Main()
{
string[][] matrix = new string[8][];
Pawn pawn = new Pawn();
Queen queen = new Queen();
Bishop bishop = new Bishop();
Rook rook = new Rook();
King king = new King();
for (int i = 0; i < 8; i++)
{
matrix[i] = Console.ReadLine()
.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
.ToArray();
}
string[] command = Console.ReadLine()
.Split("-", StringSplitOptions.RemoveEmptyEntries)
.ToArray();
while (!command[0].Equals("END"))
{
char figure = command[0][0];
int[] currentPosition = new[]
{
int.Parse(command[0][1].ToString()),
int.Parse(command[0][2].ToString())
};
int[] futurePosition = new[]
{
int.Parse(command[1][0].ToString()),
int.Parse(command[1][1].ToString())
};
if (!matrix[currentPosition[0]][currentPosition[1]].Equals(figure.ToString()))
{
Console.WriteLine("There is no such a piece!");
}
else
{
if (figure.Equals('K'))
{
king.Position = currentPosition;
if (king.ValidHorizontallMoves(futurePosition) == false &&
king.ValidDiagonallMoves(futurePosition) == false &&
king.ValidVerticallMoves(futurePosition) == false)
{
Console.WriteLine("Invalid move!");
}
else if (futurePosition[0] < 8 && futurePosition[1] < 8)
{
rook.Position = futurePosition;
ChangePosition(figure, matrix, currentPosition, futurePosition);
}
else
{
Console.WriteLine("Move go out of board!");
}
}
else if (figure.Equals('R'))
{
rook.Position = currentPosition;
if (rook.ValidHorizontallMoves(futurePosition) == false &&
rook.ValidVerticallMoves(futurePosition) == false)
{
Console.WriteLine("Invalid move!");
}
else if (futurePosition[0] < 8 && futurePosition[1] < 8)
{
rook.Position = futurePosition;
ChangePosition(figure, matrix, currentPosition, futurePosition);
}
else
{
Console.WriteLine("Move go out of board!");
}
}
else if (figure.Equals('B'))
{
bishop.Position = currentPosition;
if (bishop.ValidDiagonallMoves(futurePosition) == false)
{
Console.WriteLine("Invalid move!");
}
else if (futurePosition[0] < 8 && futurePosition[1] < 8)
{
bishop.Position = futurePosition;
ChangePosition(figure, matrix, currentPosition, futurePosition);
}
else
{
Console.WriteLine("Move go out of board!");
}
}
else if (figure.Equals('Q'))
{
queen.Position = currentPosition;
if (queen.ValidHorizontallMoves(futurePosition) == false &&
queen.ValidVerticallMoves(futurePosition) == false &&
queen.ValidDiagonallMoves(futurePosition) == false)
{
Console.WriteLine("Invalid move!");
}
else if (futurePosition[0] < 8 && futurePosition[1] < 8)
{
queen.Position = futurePosition;
ChangePosition(figure, matrix, currentPosition, futurePosition);
}
else
{
Console.WriteLine("Move go out of board!");
}
}
else if (figure.Equals('P'))
{
pawn.Position = currentPosition;
if (pawn.ValidOnceMove(futurePosition) == false)
{
Console.WriteLine("Invalid move!");
}
else if (futurePosition[0] < 8 && futurePosition[1] < 8)
{
pawn.Position = futurePosition;
ChangePosition(figure, matrix, currentPosition, futurePosition);
}
else
{
Console.WriteLine("Move go out of board!");
}
}
}
command = Console.ReadLine()
.Split("-", StringSplitOptions.RemoveEmptyEntries)
.ToArray();
}
}
private void ChessBoard_MouseDown(object sender, MouseEventArgs e)
{
if (isStopped == true)
{
return;
}
System.Windows.Point point = e.GetPosition(null);
byte rowIndex = (byte)((point.X-25) / size);
byte colIndex = (byte)((point.Y-205) / size);;
Queen queen = new Queen(rowIndex, colIndex);
Int16 index = Exists(ref queen);
if (Queens.Count < 8)
{
if (index > -1)
{
mCells[rowIndex, colIndex] = false;
Queens.RemoveAt(index);
}
else
{
//new SolidColorBrush(Colors.Green);
if (CanPutQueen(rowIndex, colIndex))
{
System.Diagnostics.Debug.WriteLine("adicionando");
mCells[rowIndex, colIndex] = true;
Queens.Add(new Queen(rowIndex, colIndex));
}
}
}
DrawBoard();
if (Queens.Count == 8) {
dt.Stop();
FinishGame();
}
}
public void QueenPlace_CanPlaceQueenInt_True()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(true, testQueenAttack.QueenPlace(3, 3));
}
private static void GetPieceForFENChar(char fench,
ChessSide
whites,
ChessSide
blacks,
int rank,
int file,
out ChessPiece
piece)
{
ColorType color;
ChessSide myside, oppside;
if (Char.IsUpper (fench))
{
color = ColorType.WHITE;
myside = whites;
oppside = blacks;
}
else
{
color = ColorType.BLACK;
myside = blacks;
oppside = whites;
}
char ch = Char.ToLower (fench);
switch (ch)
{
case 'p':
piece = new Pawn (color, rank, file,
myside, oppside);
break;
case 'k':
piece = new King (color, rank, file,
myside, oppside);
break;
case 'q':
piece = new Queen (color, rank,
file, myside,
oppside);
break;
case 'b':
piece = new Bishop (color, rank,
file, myside,
oppside);
break;
case 's':
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case 'n':
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case 'r':
piece = new Rook (color, rank, file,
myside, oppside);
break;
default:
throw new
ChessException
(Catalog.GetString("Invalid piece type ") +
ch);
}
}
public void UserPlace_CanPlaceUserInt_True()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(true, testQueenAttack.UserPlace(3, 4));
}
public static bool CanAttack(Queen white, Queen black)
{
(int row, int column)positionWhite = (white.Row, white.Column);
(int row, int column)positionBlack = (black.Row, black.Column);
(int row, int column)[] moves = new (int, int)[8];
public void PlacementCheckRange_CanPlaceOutsideRange_False()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(false, testQueenAttack.PlacementCheckRange(8, 9));
}
public override void Update(Queen queen)
{
Move();
}
public void CanAttack_CanAttackX_True()
{
Queen testQueenAttack = new Queen();
Assert.AreEqual(true, testQueenAttack.CanAttack(3, 8, 3, 2));
}
public void HorizontalAttack_CanAttackHorizontally_True()
{
Queen testQueen = new Queen("4", "5");
Assert.AreEqual(true, testQueen.HorizontalAttack("6", "5"));
}
protected virtual void ExecuteInsertUnitCommand(string[] commandWords)
{
switch (commandWords[1])
{
case "Dog":
var dog = new Dog(commandWords[2]);
this.InsertUnit(dog);
break;
case "Human":
var human = new Human(commandWords[2]);
this.InsertUnit(human);
break;
case "Tank":
var tank = new Tank(commandWords[2]);
this.InsertUnit(tank);
break;
case "Marine":
var marine = new Marine(commandWords[2]);
this.InsertUnit(marine);
break;
case "Parasite":
var parasite = new Parasite(commandWords[2]);
this.InsertUnit(parasite);
break;
case "Queen":
var queen = new Queen(commandWords[2]);
this.InsertUnit(queen);
break;
default:
break;
}
}
public void VerticalAttack_CanAttackVertically_True()
{
Queen testQueen = new Queen("4", "5");
Assert.AreEqual(true, testQueen.VerticalAttack("4", "8"));
}
public void Cannot_occupy_same_space()
{
var white = new Queen(2, 4);
var black = new Queen(2, 4);
Assert.Throws<ArgumentException>(() => new Queens(white, black));
}
public void DiagonalAttack_CanAttackDiagonally_True()
{
Queen testQueen = new Queen("4", "5");
Assert.AreEqual(true, testQueen.DiagonalAttack("6", "7"));
}
protected bool Equals(Queen other)
{
return _Suit == other._Suit;
}
public void InputCheck_InputIsNumber_True()
{
Queen testQueen = new Queen("4", "5");
Assert.AreEqual(true, testQueen.InputCheck("4", "5"));
}
/// <summary>
/// Checks all possible combinations and prints the list of all found successful.
/// </summary>
static void PlayGameFindAllMode()
{
Queen aliciaTheRed = new Queen();
aliciaTheRed.FindAndPrintAllSolutions();
}
// Start is called before the first frame update
void Start()
{
board = new GameObject[width][];
for (int x = 0; x < board.Length; x++)
{
board[x] = new GameObject[height];
for (int y = 0; y < board[x].Length; y++)
{
board[x][y] = new GameObject();
GameObject o = board[x][y];
o.name = letters[x] + (y + 1);
o.transform.parent = transform;
o.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
o.AddComponent <SpriteRenderer>();
o.AddComponent <Tile>();
SpriteRenderer r = o.GetComponent <SpriteRenderer>();
r.sprite = square;
if ((x + y) % 2 == 0)
{
r.color = new Color(0.6f, 0.3f, 0);
}
else
{
r.color = new Color(1, 0.6f, 0.3f);
}
if (y == 1 || y == 6)
{
GameObject p = new GameObject {
name = "Pawn"
};
p.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
p.transform.localScale = new Vector2(0.1f, 0.1f);
p.AddComponent <Pawn>();
p.AddComponent <SpriteRenderer>();
SpriteRenderer pr = p.GetComponent <SpriteRenderer>();
if (y > 3)
{
pr.sprite = GetComponent <Board>().blackPawn;
}
else
{
pr.sprite = GetComponent <Board>().whitePawn;
}
pr.sortingOrder = 1;
Pawn pawn = p.GetComponent <Pawn>();
pawn.transform.parent = o.transform;
pawn.SetBoard(GetComponent <Board>());
if (y > 3)
{
pawn.color = 0;
}
else
{
pawn.color = 1;
}
piecesOnBoard.Add(pawn);
}
else
{
if ((x == 0 || x == 7) && (y == 0 || y == 7))
{
GameObject ro = new GameObject {
name = "Rook"
};
ro.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
ro.transform.localScale = new Vector2(0.1f, 0.1f);
ro.AddComponent <Rook>();
ro.AddComponent <SpriteRenderer>();
SpriteRenderer rr = ro.GetComponent <SpriteRenderer>();
if (y > 3)
{
rr.sprite = GetComponent <Board>().blackRook;
}
else
{
rr.sprite = GetComponent <Board>().whiteRook;
}
rr.sortingOrder = 1;
Rook rook = ro.GetComponent <Rook>();
rook.transform.parent = o.transform;
rook.SetBoard(GetComponent <Board>());
if (y > 3)
{
rook.color = 0;
}
else
{
rook.color = 1;
}
piecesOnBoard.Add(rook);
}
if ((x == 1 || x == 6) && (y == 0 || y == 7))
{
GameObject kn = new GameObject {
name = "Knight"
};
kn.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
kn.transform.localScale = new Vector2(0.1f, 0.1f);
kn.AddComponent <Knight>();
kn.AddComponent <SpriteRenderer>();
SpriteRenderer knr = kn.GetComponent <SpriteRenderer>();
if (y > 3)
{
knr.sprite = GetComponent <Board>().blackKnight;
}
else
{
knr.sprite = GetComponent <Board>().whiteKnight;
}
knr.sortingOrder = 1;
Knight knight = kn.GetComponent <Knight>();
knight.transform.parent = o.transform;
knight.SetBoard(GetComponent <Board>());
if (y > 3)
{
knight.color = 0;
}
else
{
knight.color = 1;
}
piecesOnBoard.Add(knight);
}
if ((x == 2 || x == 5) && (y == 0 || y == 7))
{
GameObject b = new GameObject {
name = "Bishop"
};
b.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
b.transform.localScale = new Vector2(0.1f, 0.1f);
b.AddComponent <Bishop>();
b.AddComponent <SpriteRenderer>();
SpriteRenderer br = b.GetComponent <SpriteRenderer>();
if (y > 3)
{
br.sprite = GetComponent <Board>().blackBishop;
}
else
{
br.sprite = GetComponent <Board>().whiteBishop;
}
br.sortingOrder = 1;
Bishop bishop = b.GetComponent <Bishop>();
bishop.transform.parent = o.transform;
bishop.SetBoard(GetComponent <Board>());
if (y > 3)
{
bishop.color = 0;
}
else
{
bishop.color = 1;
}
piecesOnBoard.Add(bishop);
}
if ((x == 3) && (y == 0 || y == 7))
{
GameObject q = new GameObject {
name = "Queen"
};
q.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
q.transform.localScale = new Vector2(0.1f, 0.1f);
q.AddComponent <Queen>();
q.AddComponent <SpriteRenderer>();
SpriteRenderer qr = q.GetComponent <SpriteRenderer>();
if (y > 3)
{
qr.sprite = GetComponent <Board>().blackQueen;
}
else
{
qr.sprite = GetComponent <Board>().whiteQueen;
}
qr.sortingOrder = 1;
Queen queen = q.GetComponent <Queen>();
queen.transform.parent = o.transform;
queen.SetBoard(GetComponent <Board>());
if (y > 3)
{
queen.color = 0;
}
else
{
queen.color = 1;
}
piecesOnBoard.Add(queen);
}
if ((x == 4) && (y == 0 || y == 7))
{
GameObject k = new GameObject {
name = "King"
};
k.transform.position = new Vector2(transform.position.x + x * size, transform.position.y + y * size);
k.transform.localScale = new Vector2(0.1f, 0.1f);
k.AddComponent <King>();
k.AddComponent <SpriteRenderer>();
SpriteRenderer kr = k.GetComponent <SpriteRenderer>();
if (y > 3)
{
kr.sprite = GetComponent <Board>().blackKing;
}
else
{
kr.sprite = GetComponent <Board>().whiteKing;
}
kr.sortingOrder = 1;
King king = k.GetComponent <King>();
king.transform.parent = o.transform;
king.SetBoard(GetComponent <Board>());
if (y > 3)
{
king.color = 0;
}
else
{
king.color = 1;
}
piecesOnBoard.Add(king);
}
}
}
}
/*foreach (Transform piece in board[4][1].transform)
* {
* piece.gameObject.GetComponent<Piece>().Move("E4");
* }*/
foreach (Piece piece in piecesOnBoard)
{
Debug.Log(piece.Name());
foreach (string tileName in piece.Territory())
{
Debug.Log(tileName);
Tile tile = GetTile(tileName);
tile.SetTerritory(piece.color == 1); //color equals white
}
}
}
private Int16 Exists(ref Queen Queen)
{
if (Queens.Count == 0)
{
return -1;
}
for (byte i = 0; i < Queens.Count; i++)
{
if (Queens[i].Row == Queen.Row && Queens[i].Column == Queen.Column)
{
return i;
}
}
return -1;
}
public void isAttackLeagal_AttackVertrical_True()
{
Queen testQueen = new Queen();
Assert.AreEqual(true, testQueen.isAttackLeagal(5, 1, 2, 1));
}
// images[blksq/whtsq][side][idx] - idx = {KING, QUEEN, ROOK, KNIGHT, BISHOP}
public ChessPiece createPiece(PieceType type,
ColorType color,
int rank, int file)
{
ChessPiece piece = null;
ChessSide myside, oppside;
if (color == ColorType.WHITE)
{
myside = whites;
oppside = blacks;
}
else
{
myside = blacks;
oppside = blacks;
}
switch (type)
{
case PieceType.KING:
piece = new King (color, rank, file,
myside, oppside);
break;
case PieceType.QUEEN:
piece = new Queen (color, rank,
file, myside,
oppside);
break;
case PieceType.ROOK:
piece = new Rook (color, rank, file,
myside, oppside);
break;
case PieceType.KNIGHT:
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case PieceType.BISHOP:
piece = new Bishop (color, rank,
file, myside,
oppside);
break;
default:
return null;
}
return piece;
}
public void DrawBoard()
{
bool flip = true;
for (float i = 0; i <= 7; i++)
{
for (float j = 0; j <= 7; j++)
{
GeometryGroup geometry = new GeometryGroup();
RectangleGeometry rect = new RectangleGeometry();
rect.Rect = new Rect(0, 0, size, size);
Path path = new Path();
SolidColorBrush color = new SolidColorBrush();
if (flip)
{
color.Color = Colors.Red;
}
else
{
color.Color = Colors.White;
}
path.Fill = color;
path.Stroke = new SolidColorBrush(Colors.Black);
path.Stretch = Stretch.Fill;
path.StrokeThickness = 2.0;
path.SetValue(Canvas.LeftProperty, (double)(i * size));
path.SetValue(Canvas.TopProperty, (double)(j * size));
flip = ((j == 7) ? flip : ! flip);
geometry.Children.Add(rect);
EllipseGeometry ellipse = new EllipseGeometry();
ellipse.Center = new Point(size/2, size/2);
ellipse.RadiusX = size/4;
ellipse.RadiusY = size/4;
if (mCells[(int)i, (int)j])
{
Queen q = new Queen((byte)i, (byte)j);
Int16 index = Exists(ref q);
if (index > 0)
{
if (Queens[index] != null)
{
if (! (CheckAll(index)))
{
geometry.Children.Add(ellipse);
}
else
{
geometry.Children.Add(ellipse);
}
}
}
else
{
geometry.Children.Add(ellipse);
}
}
path.Data = geometry;
path.MouseLeftButtonDown += new MouseButtonEventHandler(ChessBoard_MouseDown);
this.contentPanel.Children.Add(path);
}
}
}
private static IPiece InitialPieceAtLocation(Rank rank, File file)
{
var emptyRanks = new[] { Rank.Three, Rank.Four, Rank.Five, Rank.Six};
if (emptyRanks.Contains(rank))
{
return null;
}
var colour = PlayerColour.Black;
if (rank == Rank.One || rank == Rank.Two)
{
colour = PlayerColour.White;
}
IPiece piece = new Rook(colour);
if (rank == Rank.Seven || rank == Rank.Two)
{
piece = new Pawn(colour);
}
else if (file == File.B || file == File.G)
{
piece = new Knight(colour);
}
else if (file == File.C || file == File.F)
{
piece = new Bishop(colour);
}
else if (file == File.D)
{
piece = new Queen(colour);
}
else if (file == File.E)
{
piece = new King(colour);
}
return piece;
}
public void InputCheck_InputIsNumber_False()
{
Queen testQueen = new Queen("4", "5");
Assert.AreEqual(false, testQueen.InputCheck("4t", "$5"));
}
