/// <summary>
/// Constructor used to create a game board from an <see cref="InitialSetup">initial setup</see>.
/// </summary>
/// <param name="setup">Initial setup used to create board.</param>
public GameBoard(InitialSetup setup)
: this()
{
InitialSetup = setup;
for (var x = 0; x < setup.BoardSize; x++)
{
Pieces.Add(new List <Piece>());
for (var y = 0; y < setup.BoardSize; y++)
{
Pieces[x].Add(new Piece {
Coordinate = new Coordinate {
X = x, Y = y
}, Type = PieceType.Empty
});
}
}
foreach (var dragon in setup.Dragons)
{
foreach (var piece in dragon)
{
Pieces[piece.Coordinate.X][piece.Coordinate.Y] = piece;
}
}
foreach (var additionalPiece in setup.AdditionalPieces)
{
Pieces[additionalPiece.Coordinate.X][additionalPiece.Coordinate.Y] = additionalPiece;
}
}
public override void Do()
{
base.Do();
MovedPiece.IsTaken = true;
var promotedPiecePos = new Position(MovedPiece.Position.X, MovedPiece.Position.Y);
switch (PromotionType)
{
case "queen":
PromotedPiece = new Queen(promotedPiecePos);
break;
case "rook":
PromotedPiece = new Rook(promotedPiecePos);
break;
case "bishop":
PromotedPiece = new Bishop(promotedPiecePos);
break;
case "knight":
PromotedPiece = new Knight(promotedPiecePos);
break;
}
Pieces.Add(PromotedPiece);
}
private void CreateMajorPiecesLine(PieceColor color, int rowIndex)
{
Pieces.Add(new Rook()
{
Color = color, Position = new Position(rowIndex, 0), Game = this
});
Pieces.Add(new Knight()
{
Color = color, Position = new Position(rowIndex, 1), Game = this
});
Pieces.Add(new Bishop()
{
Color = color, Position = new Position(rowIndex, 2), Game = this
});
Pieces.Add(new Queen()
{
Color = color, Position = new Position(rowIndex, 3), Game = this
});
Pieces.Add(new King()
{
Color = color, Position = new Position(rowIndex, 4), Game = this
});
Pieces.Add(new Bishop()
{
Color = color, Position = new Position(rowIndex, 5), Game = this
});
Pieces.Add(new Knight()
{
Color = color, Position = new Position(rowIndex, 6), Game = this
});
Pieces.Add(new Rook()
{
Color = color, Position = new Position(rowIndex, 7), Game = this
});
}
/// <summary>
/// Create the pieces of the board in a random way
/// </summary>
public void InitialicePiecesRandom()
{
SetCells();
var colorPlayer = PlayerColor.Black;
for (int i = 0; i < 2; i++)
{
Pieces.Add(new Tower(colorPlayer, RandomNum(NeedValidationColor.None)));
Pieces.Add(new Horse(colorPlayer, RandomNum(NeedValidationColor.None)));
Pieces.Add(new Bishop(colorPlayer, RandomNum(NeedValidationColor.White)));
Pieces.Add(new King(colorPlayer, RandomNum(NeedValidationColor.None)));
Pieces.Add(new Queen(colorPlayer, RandomNum(NeedValidationColor.None)));
Pieces.Add(new Bishop(colorPlayer, RandomNum(NeedValidationColor.Black)));
Pieces.Add(new Horse(colorPlayer, RandomNum(NeedValidationColor.None)));
Pieces.Add(new Tower(colorPlayer, RandomNum(NeedValidationColor.None)));
colorPlayer = PlayerColor.White;
}
for (int i = 1; i <= 8; i++)
{
Pieces.Add(new Pawn(PlayerColor.Black, RandomNum(NeedValidationColor.None)));
Pieces.Add(new Pawn(PlayerColor.White, RandomNum(NeedValidationColor.None)));
}
}
public void SetPiecesDefaultState()
{
if (Pieces.FirstOrDefault().Color == Color.White)
{
Pieces.Clear();
Pieces.Add(new Piece(new Point(1, 5), Color.White));
Pieces.Add(new Piece(new Point(3, 5), Color.White));
Pieces.Add(new Piece(new Point(5, 5), Color.White));
Pieces.Add(new Piece(new Point(7, 5), Color.White));
Pieces.Add(new Piece(new Point(0, 6), Color.White));
Pieces.Add(new Piece(new Point(2, 6), Color.White));
Pieces.Add(new Piece(new Point(4, 6), Color.White));
Pieces.Add(new Piece(new Point(6, 6), Color.White));
Pieces.Add(new Piece(new Point(1, 7), Color.White));
Pieces.Add(new Piece(new Point(3, 7), Color.White));
Pieces.Add(new Piece(new Point(5, 7), Color.White));
Pieces.Add(new Piece(new Point(7, 7), Color.White));
}
else
{
Pieces.Clear();
Pieces.Add(new Piece(new Point(0, 0), Color.Blue));
Pieces.Add(new Piece(new Point(2, 0), Color.Blue));
Pieces.Add(new Piece(new Point(4, 0), Color.Blue));
Pieces.Add(new Piece(new Point(6, 0), Color.Blue));
Pieces.Add(new Piece(new Point(1, 1), Color.Blue));
Pieces.Add(new Piece(new Point(3, 1), Color.Blue));
Pieces.Add(new Piece(new Point(5, 1), Color.Blue));
Pieces.Add(new Piece(new Point(7, 1), Color.Blue));
Pieces.Add(new Piece(new Point(0, 2), Color.Blue));
Pieces.Add(new Piece(new Point(2, 2), Color.Blue));
Pieces.Add(new Piece(new Point(4, 2), Color.Blue));
Pieces.Add(new Piece(new Point(6, 2), Color.Blue));
}
}
//returns a list of pieces on the current opening
public static Pieces GetPieces(int pageNumber)
{
var pieces = new Pieces();
try
{
//gets the xelements representing the two pages of the opening (e.g. 1r, 2v)
XElement root = SurfaceWindow1.xOldFr.Root;
string verso = "#" + (pageNumber-2).ToString() + "v";
string recto = "#" + (pageNumber-1).ToString() + "r";
IEnumerable<XElement> pages =
from el in root.Descendants("pb")
where ((string)el.Attribute("facs") == verso || el.Attribute("facs").Value == recto)
select el;
//adds the pieces on each page to the pieceList
foreach (XElement page in pages)
{
//var foo = page.Attribute("facs");
IEnumerable<XElement> pieceElements =
from el in page.Elements("p")
select el; //.Attribute("id").Value;
foreach (XElement p in pieceElements)
{
var piece = new Piece(p);
pieces.Add(piece.ID,piece);
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return pieces;
}
private void CreatePieces()
{
//black
Pieces.Add(new Rook(ChessBoard[0, 0], PlayerType.Black));
Pieces.Add(new Knight(ChessBoard[1, 0], PlayerType.Black));
Pieces.Add(new Bishop(ChessBoard[2, 0], PlayerType.Black));
Pieces.Add(new King(ChessBoard[3, 0], PlayerType.Black));
Pieces.Add(new Queen(ChessBoard[4, 0], PlayerType.Black));
Pieces.Add(new Bishop(ChessBoard[5, 0], PlayerType.Black));
Pieces.Add(new Knight(ChessBoard[6, 0], PlayerType.Black));
Pieces.Add(new Rook(ChessBoard[7, 0], PlayerType.Black));
for (int i = 0; i < SIZE; i++)
{
Pieces.Add(new Pawn(ChessBoard[i, 1], PlayerType.Black));
}
//white
Pieces.Add(new Rook(ChessBoard[0, 7], PlayerType.White));
Pieces.Add(new Knight(ChessBoard[1, 7], PlayerType.White));
Pieces.Add(new Bishop(ChessBoard[2, 7], PlayerType.White));
Pieces.Add(new King(ChessBoard[4, 7], PlayerType.White));
Pieces.Add(new Queen(ChessBoard[3, 7], PlayerType.White));
Pieces.Add(new Bishop(ChessBoard[5, 7], PlayerType.White));
Pieces.Add(new Knight(ChessBoard[6, 7], PlayerType.White));
Pieces.Add(new Rook(ChessBoard[7, 7], PlayerType.White));
for (int i = 0; i < SIZE; i++)
{
Pieces.Add(new Pawn(ChessBoard[i, 6], PlayerType.White));
}
}
/// <summary>
/// Moves the piece to the desired destination
/// </summary>
/// <param name="origin"></param>
/// <param name="destination"></param>
public void MakeMove(Position origin, Position destination)
{
Piece capturedPiece = ExecuteMovement(origin, destination);
if (IsInCheck(CurrentPlayer))
{
UndoMovement(origin, destination, capturedPiece);
throw new BoardException("You can't put yourself in Check!");
}
Piece p = Board.GetPiece(destination);
// SPECIAL PLAY PROMOTION
if (p is Pawn)
{
if ((p.Color == Color.White && destination.Line == 0) || (p.Color == Color.Black && destination.Line == 7))
{
p = Board.RemovePiece(destination);
Pieces.Remove(p);
Piece queen = new Queen(Board, p.Color);
Board.PlacePiece(queen, destination);
Pieces.Add(queen);
}
}
if (IsInCheck(Opponent(CurrentPlayer)))
{
Check = true;
}
else
{
Check = false;
}
if (TestCheckmate(Opponent(CurrentPlayer)))
{
Finished = true;
}
else
{
Turn++;
changePlayer();
}
//Turn++;
//changePlayer();
// SPECIAL PLAY EN PASSANT
if (p is Pawn && (destination.Line == origin.Line - 2 || destination.Line == origin.Line + 2))
{
VulnerableEnPassant = p;
}
else
{
VulnerableEnPassant = null;
}
}
/// <summary>
/// Adds piece to the board (when dragged from options area)
/// </summary>
/// <param name="piece"></param>
public void AddPiece(CellData piece)
{
if (IsValidArrangeMove(piece.Pos))
{
Pieces.Add(piece);
piece.CompleteMove();
UpdateCapturesList();
}
}
public void ExecutePlay(Position origin, Position destiny)
{
Piece capturedPiece = ExecuteMovement(origin, destiny);
if (IsInCheck(ActualPlayer))
{
UndoMovement(origin, destiny, capturedPiece);
throw new BoardException("You can't put yourself in check");
}
Piece piece = Board.Piece(destiny);
// #Special Move Promotion
if (piece is Pawn)
{
if ((piece.Color == Color.White && destiny.Row == 0) ||
(piece.Color == Color.Black && destiny.Row == 7))
{
piece = Board.RemovePiece(destiny);
Pieces.Remove(piece);
Piece queen = new Queen(Board, piece.Color);
Board.PlacePiece(queen, destiny);
Pieces.Add(queen);
}
}
if (IsInCheck(enemyColor(ActualPlayer)))
{
Check = true;
}
else
{
Check = false;
}
if (TestCheckmate(enemyColor(ActualPlayer)))
{
Finished = true;
}
else
{
Turn++;
changePlayer();
}
//#Special Move en passant
if (piece is Pawn && (destiny.Row == origin.Row - 2 || destiny.Row == origin.Row + 2))
{
VulnerableEnPassant = piece;
}
else
{
VulnerableEnPassant = null;
}
}
public void ToPlay(Position origin, Position destiny)
{
ToMove(origin, destiny);
if (IsInCheck(CurrentPlayer))
{
UndoMoviment(origin, destiny);
throw new BoardException("Você não pode se colocar em xeque");
}
Piece p = Board.GetPiece(destiny);
//#Special Moviment: promotion
if (p is Pawn)
{
if ((p.Color == Color.White && destiny.Row == 0) || (p.Color == Color.Black && destiny.Row == 7))
{
p = Board.ToRemovePiece(destiny);
Pieces.Remove(p);
Piece queen = new Queen(Board, p.Color);
Board.ToSetPiece(queen, destiny);
Pieces.Add(queen);
}
}
if (IsInCheck(Adversary(CurrentPlayer)))
{
Check = true;
}
else
{
Check = false;
}
if (IsInCheck(Adversary(CurrentPlayer)))
{
Finished = true;
}
else
{
Turn++;
ChangePlyaer();
}
//#special moviment en passant
if (p is Pawn && (destiny.Row == origin.Row - 2) || (destiny.Row == origin.Row + 2))
{
CanPassant = p;
}
else
{
CanPassant = null;
}
}
private void CreatePawnsList(PieceColor color, int rowIndex)
{
for (int i = 0; i < 8; i++)
{
Pieces.Add(new Pawn()
{
Color = color, Position = new Position(rowIndex, i), Game = this
});
}
}
public void SetPieces(Dictionary <Vector2Int, Tuple <Type, PlayerColor> > pieces)
{
foreach (KeyValuePair <Vector2Int, Tuple <Type, PlayerColor> > pair in pieces)
{
Cell cell = Cells[pair.Key.x, pair.Key.y];
Object[] args = { pair.Value.Item2, cell.Position };
Piece piece = (Piece)Activator.CreateInstance(pair.Value.Item1, args);
Pieces.Add(piece);
cell.CurrentPiece = piece;
}
}
public void SetUpBoard(Board gameBoard)
{
foreach (var piece in gameBoard.GameBoard)
{
if (piece != null)
{
Pieces.Add(new GUIPiece(ToPoint(piece.Position), piece.Owner.Color,
GUIPiece.GetImageSource(piece.Owner.Color, piece.Type)));
}
}
}
private void BoardView_Loaded(object sender, RoutedEventArgs e)
{
foreach (var square in BoardGrid.Children.Where(x => x.GetType() == typeof(SquareView)))
{
Squares.Add(square as SquareView);
}
foreach (var piece in BoardGrid.Children.Where(x => x.GetType() == typeof(PieceView)))
{
Pieces.Add(piece as PieceView);
}
}
public void Play(Position origin, Position destiny)
{
GamePiece capturedPiece = PerformMove(origin, destiny);
GamePiece piece = Board.GetPiece(destiny);
// SPECIAL MOVE: Promotion
if (piece is Pawn)
{
if ((piece.Color == Color.White && destiny.Row == 0) || (piece.Color == Color.Black && destiny.Row == 7))
{
piece = Board.RemovePiece(destiny);
Pieces.Remove(piece);
GamePiece queen = new Queen(Board, piece.Color);
Board.PlacePiece(queen, destiny);
Pieces.Add(queen);
}
}
if (IsInCheck(CurrentPlayer))
{
UndoMove(origin, destiny, capturedPiece);
throw new BoardException("ERROR: A player may not put his own king in check or remain in check");
}
if (IsInCheck(Adversary(CurrentPlayer)))
{
Check = true;
}
else
{
Check = false;
}
if (IsInCheckmate(Adversary(CurrentPlayer)))
{
Finished = true;
}
else
{
Round++;
SwitchPlayer();
}
// SPECIAL MOVE: En Passent
if (piece is Pawn && (destiny.Row == origin.Row - 2 || destiny.Row == origin.Row + 2))
{
EnPassentTarget = piece;
}
else
{
EnPassentTarget = null;
}
}
public override (PutEvent putEvent, bool wasPieceRemoved) Put(AbstractPiece piece)
{
if (piece.CheckForSham() == false)
{
Pieces.Add(piece);
return(PutEvent.NormalOnNonGoalField, true);
}
else
{
Pieces.Add(piece);
return(PutEvent.ShamOnGoalArea, true);
}
}
public void AddNewPiece(ISquarePiece newPiece)
{
var piecesAtPosition = Pieces.Where(x => x.Position.x == newPiece.Position.x && x.Position.y == newPiece.Position.y);
if (piecesAtPosition.Any())
{
Debug.LogWarning($"Tried to insert a piece into position {newPiece.Position.x}:{newPiece.Position.y} but there is already a piece there");
return;
}
Pieces.Add(newPiece);
AvaiableSlots.Add(newPiece.Position);
}
private void InitializePieces()
{
for (int y = 0; y < Tiles.GetLength(0); y++)
{
for (int x = 0; x < Tiles.GetLength(1); x++)
{
Piece piece = default;
PieceColor color = (y < 2) ? PieceColor.White : PieceColor.Black;
if (y == 0 || y == 7)
{
switch (x)
{
case 0:
case 7:
piece = new Rook(color);
break;
case 1:
case 6:
piece = new Knight(color);
break;
case 2:
case 5:
piece = new Bishop(color);
break;
case 3:
piece = new Queen(color);
break;
case 4:
piece = new King(color);
break;
}
}
if (y == 1 || y == 6)
{
piece = new Pawn(color);
}
if (piece != null)
{
Pieces.Add(piece);
PlacePieceAtPosition(piece, x, y, true);
}
}
}
}
/// <summary>
/// Inicializa el tablero a la posición inicial
/// </summary>
public void Reset()
{
// Limpia el tablero
Clear();
// Inicializa el juego
if (Variation == null || !Variation.Setup.HasSetup)
{
// Añade las piezas blancas
Pieces.Add(PieceBaseModel.PieceType.Rook, PieceBaseModel.PieceColor.White, 7, 0);
Pieces.Add(PieceBaseModel.PieceType.Knight, PieceBaseModel.PieceColor.White, 7, 1);
Pieces.Add(PieceBaseModel.PieceType.Bishop, PieceBaseModel.PieceColor.White, 7, 2);
Pieces.Add(PieceBaseModel.PieceType.Queen, PieceBaseModel.PieceColor.White, 7, 3);
Pieces.Add(PieceBaseModel.PieceType.King, PieceBaseModel.PieceColor.White, 7, 4);
Pieces.Add(PieceBaseModel.PieceType.Bishop, PieceBaseModel.PieceColor.White, 7, 5);
Pieces.Add(PieceBaseModel.PieceType.Knight, PieceBaseModel.PieceColor.White, 7, 6);
Pieces.Add(PieceBaseModel.PieceType.Rook, PieceBaseModel.PieceColor.White, 7, 7);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 0);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 1);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 2);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 3);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 4);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 5);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 6);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.White, 6, 7);
// Añade las piezas negras
Pieces.Add(PieceBaseModel.PieceType.Rook, PieceBaseModel.PieceColor.Black, 0, 0);
Pieces.Add(PieceBaseModel.PieceType.Knight, PieceBaseModel.PieceColor.Black, 0, 1);
Pieces.Add(PieceBaseModel.PieceType.Bishop, PieceBaseModel.PieceColor.Black, 0, 2);
Pieces.Add(PieceBaseModel.PieceType.Queen, PieceBaseModel.PieceColor.Black, 0, 3);
Pieces.Add(PieceBaseModel.PieceType.King, PieceBaseModel.PieceColor.Black, 0, 4);
Pieces.Add(PieceBaseModel.PieceType.Bishop, PieceBaseModel.PieceColor.Black, 0, 5);
Pieces.Add(PieceBaseModel.PieceType.Knight, PieceBaseModel.PieceColor.Black, 0, 6);
Pieces.Add(PieceBaseModel.PieceType.Rook, PieceBaseModel.PieceColor.Black, 0, 7);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 0);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 1);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 2);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 3);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 4);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 5);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 6);
Pieces.Add(PieceBaseModel.PieceType.Pawn, PieceBaseModel.PieceColor.Black, 1, 7);
}
else
{
foreach (PieceBaseModel piece in Variation.Setup.Pieces)
{
Pieces.Add(piece.Type, piece.Color, piece.Cell);
}
}
}
public virtual void RefreshSquares()
{
ClearCurrentMoveData();
Pieces.Clear();
foreach (SquareViewModel square in Squares)
{
ChessPiece piece = basicBoardService.GetPiece(square.Coordinate);
if (piece != null)
{
Pieces.Add(new ChessPieceViewModel(piece, square.Coordinate));
}
}
}
/// <summary>
/// Deep copy constructor
/// </summary>
/// <param name="src"></param>
public PieceStack(PieceStack src) : this()
{
foreach (TakPiece piece in src.Pieces)
{
if (piece.IsCapstone)
{
Pieces.Add(new Capstone(piece as Capstone));
}
else
{
Pieces.Add(new TakPiece(piece));
}
}
}
public bool AddPiece(Piece newPiece)
{
if (newPiece.Affiliation != Affiliation)
{
return(false);
}
Pieces.Add(newPiece);
newPiece.Move += Piece_Move;
newPiece.Capture += Piece_Capture;
return(true);
}
public void SetPosition(Board board, Image image)
{
var isCalculated = false;
do
{
var rowNumber = Global.RandomNext(0, board.RowCount - image.RowCount + 1);
var columnNumber = Global.RandomNext(0, board.ColumnCount - image.ColumnCount + 1);
isCalculated = board.Pieces.OfType <Piece>().Any(p => p.RowNumber == rowNumber && p.ColumnNumber == columnNumber);
if (isCalculated)
{
//var upperTopPieceOfNest = board.Pieces.OfType<Piece>().FirstOrDefault(predicate);
for (int i = rowNumber, counter = 0; i < rowNumber + image.RowCount; i++)
{
for (int k = columnNumber; k < columnNumber + image.ColumnCount; k++, counter++)
{
//NestPieces.Add(new NestPiece()
//{
// Number = counter,
// RowCount = board.GetPiece(i,k).RowNumber,
// ColumnCount = board.GetPiece(i,k).ColumnNumber
//});
var piece = Piece.CreateACopy(board.GetPiece(i, k));
piece.SetImageNumber(counter);
Pieces.Add(piece);
}
}
}
} while (!isCalculated);
foreach (var piece in Pieces)
{
if (image.Pieces.Any(ip => ip.ImageNumber == piece.ImageNumber))
{
var img = image.Pieces.FirstOrDefault(ip => ip.ImageNumber == piece.ImageNumber);
piece.MakeNest(img.Texture, Color.White);
}
}
}
private PieceModel AddFinalPiece(String color, int x, int y, PieceModel last)
{
var newPiece = new PieceModel()
{
Color = color, BaseColor = color, Id = _nextIdx++, X = x, Y = y
};
Pieces.Add(newPiece);
if (last != null)
{
last.NextOptionalPiece = newPiece;
newPiece.LastPiece = last;
}
return(newPiece);
}
/// <summary>
/// Put piece
/// </summary>
/// <param name="piece">Piece</param>
/// <param name="column">Column</param>
/// <param name="line">Row</param>
private void PutPiece(Piece piece, char column, int line)
{
Board.PutPiece(piece, new ChessPosition(column, line).ToPosition());
Pieces.Add(piece);
StringBuilder text = new StringBuilder();
text.AppendLine("Put piece");
text.AppendLine(string.Concat("Piece: ", piece.GetType()));
text.AppendLine(string.Concat("Color: ", piece.Color.ToString()));
text.AppendLine(string.Concat("ChessPosition: ", column, line, " CanvasPosition(Column, Row): ", piece.Position.Column, piece.Position.Row));
text.AppendLine(string.Concat("Date: ", DateTime.Now.ToShortDateString(), " Time: ", DateTime.Now.ToShortTimeString()));
WriteLog.ChecksLogs(text);
}
private PieceModel AddPiece(String color, int x, int y)
{
var newPiece = new PieceModel()
{
Color = color, BaseColor = color, Id = _nextIdx++, X = x, Y = y
};
Pieces.Add(newPiece);
if (_lastPiece != null)
{
_lastPiece.NextPiece = newPiece;
newPiece.LastPiece = _lastPiece;
}
_lastPiece = newPiece;
return(newPiece);
}
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
Dictionary <string, Pieces> listOfPieces = new Dictionary <string, Pieces>();
for (int i = 0; i < n; i++)
{
string[] input = Console.ReadLine().Split('|', StringSplitOptions.RemoveEmptyEntries);
string pieceName = input[0];
string composerName = input[1];
string key = input[2];
listOfPieces.Add(pieceName, new Pieces()
{
Piece = pieceName, Composer = composerName, Key = key
});
}
string cmd = String.Empty;
while ((cmd = Console.ReadLine()) != "Stop")
{
string[] cmdArgs = cmd.Split('|', StringSplitOptions.RemoveEmptyEntries);
string cmdName = cmdArgs[0];
switch (cmdName)
{
case "Add":
Pieces.Add(listOfPieces, cmdArgs);
break;
case "Remove":
Pieces.Remove(listOfPieces, cmdArgs);
break;
case "ChangeKey":
Pieces.ChangeKey(listOfPieces, cmdArgs);
break;
}
}
foreach (var kvp in listOfPieces.OrderBy(x => x.Key).ThenBy(x => x.Value.Composer).ToDictionary(x => x.Key, x => x.Value))
{
Console.WriteLine($"{kvp.Key} -> Composer: {kvp.Value.Composer}, Key: {kvp.Value.Key}");
}
}
/// <summary>
/// Creates the parts list on air
/// </summary>
private void CreatePartListOnAir()
{
if (loopCounter < PartsOnAir.Count)
{
StructureParent sP = null;
string root = "";
if (PartsOnAir[loopCounter] == 1)
{
root = ReturnBridgePartRoot(PartsOnAir[loopCounter]);
}
else if (PartsOnAir[loopCounter] == 2)
{
root = ReturnBridgePartRoot(PartsOnAir[loopCounter]);
}
else if (PartsOnAir[loopCounter] == 3)
{
root = ReturnBridgePartRoot(PartsOnAir[loopCounter]);
}
else if (PartsOnAir[loopCounter] == 4)
{
root = ReturnBridgePartRoot(PartsOnAir[loopCounter]);
}
sP = StructureParent.CreateStructureParent(root, PlanesOnAirPos[loopCounter], BridgeUnit(),
container: transform,
startingStage: StartingStageForPieces);
if (_dominantSide == H.Vertic)
{
sP.transform.Rotate(new Vector3(0, 270, 0));
}
sP = ReSizeObj(sP, PartsOnAir[loopCounter], _dominantSide);
Pieces.Add(sP);
loopCounter++;
}
else
{
createAirPartsNow = false;
loopCounter = 0;
createSoilPartsNow = true;
//so crystals are added to ground right away
PrivHandleZoningAddCrystalsForBridge();
}
}
private void SetPieces(string p, GoColor goColor)
{
var split = p.Split(' ');
for (int index = 0; index < split.Length; index++)
{
var pos = split[index];
if (!String.IsNullOrWhiteSpace(pos) && Pieces.ContainsKey(pos))
{
Pieces[pos].Color = goColor;
}
else if (!String.IsNullOrWhiteSpace(pos))
{
// Can't set the sequence yet because index is not the correct value.
Pieces.Add(pos, new PieceStateViewModel(pos, null, goColor, false, false, false));
}
}
}
private IMeepleModel CreateMeeple(IPlayerModel player, int meepleId, string color, int x, int y)
{
var newPiece = new PieceModel()
{
Color = color, Id = _nextIdx++, X = x, Y = y
};
Pieces.Add(newPiece);
var meeple = new MeepleModel()
{
Player = player,
BasePosition = newPiece,
CurrentPosition = newPiece,
OnBase = true,
MeepleId = meepleId
};
newPiece.Meeple = meeple;
return(meeple);
}
