private void DrawEdge(Edge edge)
{
int x, y, width, height;
if (edge.origin.direction == Directions.Left || edge.origin.direction == Directions.Down)
{
x = Translate(edge.exit.x);
y = Translate(edge.exit.y);
}
else
{
x = Translate(edge.origin.x);
y = Translate(edge.origin.y);
}
if (edge.origin.direction == Directions.Left || edge.origin.direction == Directions.Right)
{
width = cellSize * 2 + cellWallSize;
height = cellSize;
}
else
{
width = cellSize;
height = cellSize * 2 + cellWallSize;
}
var color = rainbow ? ColorE.HSVToRGB(Mathf.Repeat(edge.origin.depth / 360f, 1), 1, 1) : Color.white;
texture.DrawRect(x, y, width, height, color);
}
private void ClearCastles()
{
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Castle[(byte)color].AnyCastle = false;
}
}
public static DataSet ModifyChallenge(ColorE colorIDE, GameType gameTypeIDE, int challengeID, int roomID, int chessTypeID, bool IsRated, bool WithClock, bool ChallengerSendsGame, int opponentUserID, int timeMin, int gainPerMove)
{
ChallengeDataKv kv = new ChallengeDataKv();
kv.Kv.Set("MethodName", (int)MethodNameE.ModifyChallenge);
kv.Kv.Set(StdKv.CurrentUserID, Ap.CurrentUserID);
kv.ChallengeID = challengeID;
kv.ChallengerUserID = Ap.CurrentUserID;
kv.ChallengeTypeIDE = ChallengeTypeE.Modify;
kv.ChessTypeID = chessTypeID;
kv.ColorIDE = colorIDE;
kv.IsRated = IsRated;
kv.WithClock = WithClock;
kv.IsChallengerSendsGame = ChallengerSendsGame;
kv.Description = "";
kv.OpponentUserID = opponentUserID;
kv.GameTypeIDE = gameTypeIDE;
kv.StatusIDE = StatusE.Active;
kv.TimeMin = timeMin;
kv.GainPerMoveMin = gainPerMove;
kv.RoomID = roomID;
//kv.ChessTypeID = PlayingMode.ChessTypeID;
DataSet ds = SocketClient.Instance.Invoke(kv.Kv.DataTable.Copy());
return(ds);
}
private void Generate()
{
GeneratePalette();
config.gradient = ColorE.Gradient(GetMainColorHSV(), GetSecondaryColorHSV());
breakout.Generate(config);
}
private void InitCastles()
{
Castle = new Castle[Color.Colors];
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Castle[(byte)color] = new Castle();
}
ClearCastles();
}
internal static ColorE Switch(ref ColorE color)
{
switch (color)
{
case ColorE.White: return(color = ColorE.Black);
case ColorE.Black: return(color = ColorE.White);
case ColorE.NoColor:
default: return(color = ColorE.NoColor);
}
}
public void SwitchSideOnMove()
{
switch (OnMove)
{
case ColorE.White: OnMove = ColorE.Black; break;
case ColorE.Black: OnMove = ColorE.White; break;
case ColorE.NoColor:
default: Debug.Assert(false, "No Side to Move"); break;
}
}
private void CountPieces()
{
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Bitboard occupy = Occupies[(byte)color];
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
Bitboard piece = Pieces[(byte)type];
PieceCount[(byte)color, (byte)type] = BitBoard.CountSets(occupy & piece);
}
}
}
public void Generate()
{
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[0], targetPalette[1], 0.5f));
config.gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
var draft = LowPolyTerrainGenerator.TerrainDraft(config);
draft.Move(Vector3.left * config.terrainSize.x / 2 + Vector3.back * config.terrainSize.z / 2);
meshFilter.mesh = draft.ToMesh();
}
private void DrawEdge(Edge edge)
{
int x, y, width, height;
if (edge.origin.direction == Directions.Left || edge.origin.direction == Directions.Down)
{
x = Translate(edge.exit.x);
y = Translate(edge.exit.y);
}
else
{
x = Translate(edge.origin.x);
y = Translate(edge.origin.y);
}
if (edge.origin.direction == Directions.Left || edge.origin.direction == Directions.Right)
{
width = cellSize * 2 + wallSize;
height = cellSize;
}
else
{
width = cellSize;
height = cellSize * 2 + wallSize;
}
Color color;
if (useRainbowGradient)
{
float hue = Mathf.Repeat(edge.origin.depth / 360f, 1);
color = ColorE.HSVToRGB(hue, 1, 1);
}
else
{
color = Color.white;
}
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
heights[x + i, y + j] = floorHeight;
}
}
texture.DrawRect(x, y, width, height, color);
}
public void Generate()
{
Vector3 terrainSize = new Vector3(terrainSizeX, terrainSizeY, terrainSizeZ);
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[0], targetPalette[1], 0.5f));
var gradient = ColorE.Gradient(targetPalette[2].WithS(0.8f).WithV(0.8f),
targetPalette[3].WithS(0.8f).WithV(0.8f));
var draft = LowPolyTerrainGenerator.TerrainDraft(terrainSize, cellSize, noiseScale, gradient);
draft.Move(Vector3.left * terrainSizeX / 2 + Vector3.back * terrainSizeZ / 2);
meshFilter.mesh = draft.ToMesh();
}
public Gradient BlendGradient(Gradient terrain_gradient, Gradient object_gradient)
{
List <ColorHSV> targetPalette = new List <ColorHSV>();
List <ColorHSV> currentPalette = new List <ColorHSV>();
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
Debug.Log(targetPalette.Count);
ColorHSV groundColor = new ColorHSV(terrain_gradient.Evaluate(0));
ColorHSV newColor = new ColorHSV(object_gradient.Evaluate(1));
targetPalette.Add(ColorHSV.Lerp(groundColor, newColor, 0.5f));
var gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
return(object_gradient);
}
public void Generate(bool randomizeConfig = true)
{
if (constantSeed)
{
Random.InitState(0);
}
if (randomizeConfig)
{
GeneratePalette();
config.gradient = ColorE.Gradient(from: GetMainColorHSV(), to: GetSecondaryColorHSV());
}
var draft = LowPolyTerrainGenerator.TerrainDraft(config);
draft.Move(Vector3.left * config.terrainSize.x / 2 + Vector3.back * config.terrainSize.z / 2);
AssignDraftToMeshFilter(draft, terrainMeshFilter, ref terrainMesh);
}
public static DataSet AddChallengeData
(
int WhiteUserID
, int blackUserID
, ChallengeTypeE challengeTypeE
, GameType gameTypeIDE
, ColorE colorIDE
, int roomID
, int timeMin
, int gainPerMove
, int chessTypeID
, bool isRated
, bool withClock
, bool challengerSendsGame
, string description
, int statke
, int flate
)
{
ChallengeDataKv kv = new ChallengeDataKv();
kv.Kv.Set("MethodName", (int)MethodNameE.AddChallengeData);
kv.Kv.Set(StdKv.CurrentUserID, WhiteUserID);
kv.ChallengerUserID = WhiteUserID;
kv.ChallengeTypeIDE = challengeTypeE;
kv.ChessTypeID = chessTypeID;
kv.ColorIDE = colorIDE;
kv.IsRated = isRated;
kv.WithClock = withClock;
kv.IsChallengerSendsGame = challengerSendsGame;
kv.Description = description;
kv.OpponentUserID = blackUserID;
kv.RoomID = roomID;
kv.StatusIDE = StatusE.Active;
kv.GameTypeIDE = gameTypeIDE;
kv.TimeMin = timeMin;
kv.GainPerMoveMin = gainPerMove;
kv.Stake = statke;
kv.Flate = flate;
DataSet ds = SocketClient.Instance.Invoke(kv.Kv.DataTable.Copy());
return(ds);
}
private void ClearBitboards()
{
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Occupies[(byte)color] = BitBoard.EmptySquares;
}
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
Pieces[(byte)type] = BitBoard.EmptySquares;
}
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
PieceCount[(byte)color, (byte)type] = 0;
}
}
}
private void Awake()
{
RenderSettings.skybox = new Material(RenderSettings.skybox);
meshCollider = terrain.GetComponents <MeshCollider>()[0];
//Generate Gradient for scene
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[0], targetPalette[1], 0.5f));
var gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
grad = gradient;
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[0], targetPalette[1], 0.5f));
var gradient2 = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
grad2 = gradient2;
Generate();
currentPalette.AddRange(targetPalette);
for (int i = 0; i < 10; i++)
{
Vector3 terrainSize = new Vector3(terrainSizeX, terrainSizeY, terrainSizeZ);
var temp_draft = LowPolyTerrainGenerator.TerrainDraft(terrainSize, cellSize, noiseScale, grad);
temp_draft.Move(Vector3.left * terrainSizeX / 2 + Vector3.back * terrainSizeZ / 2);
pregen_graphs.Add(temp_draft);
GameObject temp = (GameObject)Instantiate(terrain, new Vector3(0, -100, 0), terrain.transform.rotation);
UpdateDraft(temp, temp_draft);
pre_terrains.Add(temp);
// temp.GetComponent<BoxCollider>().
}
foreach (GameObject g in pre_terrains)
{
g.GetComponent <ObjectSpawner>().gradient1 = grad;
g.GetComponent <ObjectSpawner>().gradient2 = grad2;
}
}
private void ClearSquare(SquareE square)
{
//bool isPiece = false;
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Bitboard occupy = Occupies[(byte)color];
if (BitBoard.GetSquare(occupy, square))
{
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
Bitboard piece = Pieces[(byte)type];
if (BitBoard.GetSquare(piece, square)) // occupy & piece
{
BitBoard.RstSquare(ref Occupies[(byte)color], square);
BitBoard.RstSquare(ref Pieces[(byte)type], square);
break;
//Debug.Assert(!isPiece, "Piece Overlaps");
//isPiece = true;
}
}
}
}
}
public Piece PickPiece(SquareE sqr)
{
Piece p = new Piece();
//bool isPiece = false;
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Bitboard occupy = Occupies[(byte)color];
if (BitBoard.GetSquare(occupy, sqr))
{
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
Bitboard piece = Pieces[(byte)type];
if (BitBoard.GetSquare(piece, sqr)) // occupy & piece
{
//Debug.Assert(!isPiece, "Piece Overlaps");
//isPiece = true;
return(new Piece(color, type));
}
}
}
}
return(p);
}
internal static string ToString(Board board)
{
if (board == default(Board))
{
Debug.Assert(false, "Null or Empty FEN");
return(string.Empty);
}
StringBuilder fenString = new StringBuilder();
#region Pieces
for (RankE rank = RankE.Rank_8; ; --rank)
{
byte emptySqr = 0;
for (FileE file = FileE.File_A; file <= FileE.File_H; ++file)
{
bool isPiece = false;
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Bitboard occupy = board.Occupies[(byte)color];
SquareE sqr = Square._Square(file, rank);
if (BitBoard.GetSquare(occupy, sqr))
{
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
Bitboard piece = board.Pieces[(byte)type];
if (BitBoard.GetSquare(piece, sqr)) // occupy & piece
{
isPiece = true;
if (emptySqr > 0)
{
fenString.Append(emptySqr);
emptySqr = 0;
}
fenString.Append(Piece.mapPiece[(byte)color, (byte)type]);
break;
}
}
}
}
if (!isPiece)
{
++emptySqr;
}
}
if (emptySqr > 0)
{
fenString.Append(emptySqr);
emptySqr = 0;
}
if (rank == RankE.Rank_1)
{
break;
}
fenString.Append(rankSep);
}
#endregion
fenString.Append(recordSep);
#region OnMove
switch (board.OnMove)
{
case ColorE.White: fenString.Append('w'); break;
case ColorE.Black: fenString.Append('b'); break;
case ColorE.NoColor:
default: fenString.Append('-'); break;
}
#endregion
fenString.Append(recordSep);
#region Castle
if (board.Castle[(byte)ColorE.White].AnyCastle ||
board.Castle[(byte)ColorE.Black].AnyCastle)
{
if (board.Castle[(byte)ColorE.White].ShortCastle)
{
fenString.Append('K');
}
if (board.Castle[(byte)ColorE.White].LongCastle)
{
fenString.Append('Q');
}
if (board.Castle[(byte)ColorE.Black].ShortCastle)
{
fenString.Append('k');
}
if (board.Castle[(byte)ColorE.Black].LongCastle)
{
fenString.Append('q');
}
}
else
{
fenString.Append('-');
}
#endregion
fenString.Append(recordSep);
#region EnPassant
SquareE ep = board.EnPassant;
if (Square.IsValid(ep))
{
fenString.Append(ep.ToString().ToLower());
}
else
{
fenString.Append('-');
}
#endregion
fenString.Append(recordSep);
#region HalfMove Clock
fenString.Append(board.HalfMoveClock);
#endregion
fenString.Append(recordSep);
#region FullMove Counter
fenString.Append(board.FullMoveCount);
#endregion
return(fenString.ToString());
}
/// Split Method
internal static Board ToBoard(string fenString)
{
const Board emptyBoard = default(Board);
if (string.IsNullOrEmpty(fenString))
{
return(emptyBoard);
}
string[] records = fenString.Split(new char[] { recordSep }, StringSplitOptions.RemoveEmptyEntries);
int numRecord = records.Length;
// --- full fenString check
//if( numRecord != 6 ) return emptyBoard;
Board board = new Board();
#region Piece placement
string[] ranks = records[0].Split(rankSep);
if (ranks.Length != Rank.Ranks)
{
return(emptyBoard);
}
byte baseSqr = (byte)SquareE.A8;
foreach (string rank in ranks)
{
byte offsetFile = 0;
foreach (char achar in rank)
{
if (achar >= '1' && achar <= '8')
{
offsetFile += (byte)(achar - '0');
}
else
{
Piece piece = Piece.Parse(achar);
if (piece != default(Piece))
{// there is a piece
ColorE color = piece.Color;
PieceE type = piece.Type;
if (color != ColorE.NoColor && type != PieceE.NoPiece)
{
if (offsetFile >= File.Files)
{
return(emptyBoard);
}
SquareE sqr = (SquareE)(baseSqr + offsetFile);
switch (type)
{
case PieceE.Pawn:
RankE pawnRank = Square._Rank(sqr);
if (pawnRank == RankE.Rank_1 || pawnRank == RankE.Rank_8)
{
return(emptyBoard);
}
if (board.PieceCount[(byte)color, (byte)type] >= 8)
{
return(emptyBoard);
}
break;
case PieceE.King:
if (board.PieceCount[(byte)color, (byte)type] >= 1)
{
return(emptyBoard);
}
break;
case PieceE.Knight:
case PieceE.Bishop:
case PieceE.Rook:
case PieceE.Queen:
if (board.PieceCount[(byte)color, (byte)PieceE.Pawn] +
board.PieceCount[(byte)color, (byte)PieceE.Knight] +
board.PieceCount[(byte)color, (byte)PieceE.Bishop] +
board.PieceCount[(byte)color, (byte)PieceE.Rook] +
board.PieceCount[(byte)color, (byte)PieceE.Queen]
>= 15)
{
return(emptyBoard);
}
break;
}
board.PutPiece(piece, sqr); // put the piece on board
}
}
else
{
return(emptyBoard);
}
++offsetFile;
}
}
if (offsetFile == 0) // Allow null lines = /8/
{
offsetFile = File.Files;
}
if (offsetFile != File.Files)
{
return(emptyBoard);
}
baseSqr -= File.Files;
}
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Bitboard occupy = board.Occupies[(byte)color];
// check too many total pieces
if (BitBoard.CountSets(occupy) > 16)
{
return(emptyBoard);
}
// check if the number of Pawns plus the number of extra Queens, Rooks, Bishops, Knights
// (which can result only by promotion) exceeds 8
// check too many color pieces
if (board.PieceCount[(byte)color, (byte)PieceE.Pawn] +
Math.Max(board.PieceCount[(byte)color, (byte)PieceE.Knight] - 2, 0) +
Math.Max(board.PieceCount[(byte)color, (byte)PieceE.Bishop] - 2, 0) +
Math.Max(board.PieceCount[(byte)color, (byte)PieceE.Rook] - 2, 0) +
Math.Max(board.PieceCount[(byte)color, (byte)PieceE.Queen] - 1, 0)
> 8)
{
return(emptyBoard);
}
if (board.PieceCount[(byte)color, (byte)PieceE.Bishop] > 1)
{
Bitboard bishops = occupy & board.Pieces[(byte)PieceE.Bishop];
byte[] bishopCount = new byte[Color.Colors];
//SquareE[] square = BitBoard.GetSquares(occupy & board.Pieces[ (byte) PieceE.Bishop ]);
//foreach( SquareE sqr in square )
// ++bishopCount[ (byte) Square._Color(sqr) ];
bishopCount[(byte)ColorE.White] = BitBoard.CountSets(BitBoard.LightSquares & bishops);
bishopCount[(byte)ColorE.Black] = BitBoard.CountSets(BitBoard.DarkSquares & bishops);
if (board.PieceCount[(byte)color, (byte)PieceE.Pawn] +
Math.Max(bishopCount[(byte)ColorE.White] - 1, 0) +
Math.Max(bishopCount[(byte)ColorE.Black] - 1, 0)
> 8)
{
return(emptyBoard);
}
}
// check for King
byte king = board.PieceCount[(byte)color, (byte)PieceE.King];
if (king != 1) //Illegal King
{
return(emptyBoard);
}
}
#endregion
if (numRecord > 1)
{
#region Active color
string aColor = records[1];
if (string.IsNullOrEmpty(aColor) || aColor.Length != 1)
{
return(emptyBoard);
}
char activeColor = char.ToLower(aColor[0]);
if (activeColor == 'w')
{
board.OnMove = ColorE.White;
}
else if (activeColor == 'b')
{
board.OnMove = ColorE.Black;
}
else
{
board.OnMove = ColorE.NoColor;
return(emptyBoard);
}
#endregion
}
if (numRecord > 2)
{
#region Castling privileges
string castles = records[2];
if (string.IsNullOrEmpty(castles))
{
return(emptyBoard);
}
if (castles == "-")
{
board.Castle[(byte)ColorE.White].AnyCastle = false;
board.Castle[(byte)ColorE.Black].AnyCastle = false;
}
else
{
int length = castles.Length;
if (length > 4)
{
return(emptyBoard);
}
for (byte i = 0; i < length - 1; ++i)
{
for (byte j = (byte)(i + 1); j < length; ++j)
{
if (castles[i] == castles[j])
{
return(emptyBoard);
}
}
}
foreach (char castle in castles)
{
switch (castle)
{
case 'K':
{
Bitboard occupy = board.Occupies[(byte)ColorE.White];
if (BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.King], SquareE.E1) &&
BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.Rook], SquareE.H1))
{
board.Castle[(byte)ColorE.White].ShortCastle = true;
}
else
{
return(emptyBoard);
}
} break;
case 'Q':
{
Bitboard occupy = board.Occupies[(byte)ColorE.White];
if (BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.King], SquareE.E1) &&
BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.Rook], SquareE.A1))
{
board.Castle[(byte)ColorE.White].LongCastle = true;
}
else
{
return(emptyBoard);
}
} break;
case 'k':
{
Bitboard occupy = board.Occupies[(byte)ColorE.Black];
if (BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.King], SquareE.E8) &&
BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.Rook], SquareE.H8))
{
board.Castle[(byte)ColorE.Black].ShortCastle = true;
}
else
{
return(emptyBoard);
}
} break;
case 'q':
{
Bitboard occupy = board.Occupies[(byte)ColorE.Black];
if (BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.King], SquareE.E8) &&
BitBoard.GetSquare(occupy & board.Pieces[(byte)PieceE.Rook], SquareE.A8))
{
board.Castle[(byte)ColorE.Black].LongCastle = true;
}
else
{
return(emptyBoard);
}
} break;
default:
return(emptyBoard);
}
}
}
#endregion
}
if (numRecord > 3)
{
#region EnPassant Target square
string epSqr = records[3];
if (string.IsNullOrEmpty(epSqr))
{
return(emptyBoard);
}
if (epSqr == "-")
{
board.EnPassant = SquareE.NoSquare;
}
else
{
if (epSqr.Length != 2)
{
return(emptyBoard);
}
char epFile = char.ToLower(epSqr[0]);
if (!(epFile >= 'a' && epFile <= 'h'))
{
return(emptyBoard);
}
char epRank = epSqr[1];
if (!(epRank == '3' || epRank == '6'))
{
return(emptyBoard);
}
if (epRank == '3' &&
(
board.OnMove != ColorE.Black ||
!BitBoard.GetSquare(board.Occupies[(byte)ColorE.White] & board.Pieces[(byte)PieceE.Pawn], Square._Square(epFile, (char)(epRank + 1)))
)
||
epRank == '6' &&
(
board.OnMove != ColorE.White ||
!BitBoard.GetSquare(board.Occupies[(byte)ColorE.Black] & board.Pieces[(byte)PieceE.Pawn], Square._Square(epFile, (char)(epRank - 1)))
)
)
{
return(emptyBoard);
}
board.EnPassant = Square._Square(epFile, epRank);
}
#endregion
}
if (numRecord > 4)
{
#region HalfMove Clock (Ply)
byte halfMoveClock;
if (!byte.TryParse(records[4], out halfMoveClock))
{
return(emptyBoard);
}
if (halfMoveClock > 100)
{
return(emptyBoard);
}
board.HalfMoveClock = halfMoveClock;
#endregion
}
if (numRecord > 5)
{
#region FullMove Counter
ushort fullMoveCount;
if (!ushort.TryParse(records[5], out fullMoveCount))
{
return(emptyBoard);
}
if (fullMoveCount == 0)
{
fullMoveCount = 1;
}
board.FullMoveCount = fullMoveCount;
#endregion
}
return(board);
}
//internal virtual ColorE Color { get { return ColorE.NoColor;} }
internal Piece(ColorE color, PieceE type)
{
Color = color;
Type = type;
}
internal static Bitboard FrontRank(ColorE color, SquareE sqr)
{
return(SquaresOfFrontRank[(byte)color, (byte)Square._Rank(sqr)]);
}
// TODO::
//internal Bitboard AttacksTo( Bitboard occupied, SquareE sqr, ColorE side )
//{
// //Bitboard knights, kings, bishopsQueens, rooksQueens;
// //knights = pieceBB[ nWhiteKnight ] | pieceBB[ nBlackKnight ];
// //kings = pieceBB[ nWhiteKing ] | pieceBB[ nBlackKing ];
// //rooksQueens =
// //bishopsQueens = pieceBB[ nWhiteQueen ] | pieceBB[ nBlackQueen ];
// //rooksQueens |= pieceBB[ nWhiteRook ] | pieceBB[ nBlackRook ];
// //bishopsQueens |= pieceBB[ nWhiteBishop ] | pieceBB[ nBlackBishop ];
// //return (arrPawnAttacks[ nWhite ][ sqr ] & pieceBB[ nBlackPawn ])
// // | (arrPawnAttacks[ nBlack ][ sqr ] & pieceBB[ nWhitePawn ])
// // | (arrKnightAttacks[ sqr ] & knights)
// // | (arrKingAttacks[ sqr ] & kings)
// // | (bishopAttacks(occupied, sqr) & bishopsQueens)
// // | (rookAttacks(occupied, sqr) & rooksQueens)
// // ;
// ColorE oppside = ColorE.NoColor;
// if( side == ColorE.White )
// {
// oppside = ColorE.Black;
// }
// else if( side == ColorE.Black )
// {
// oppside = ColorE.White;
// }
// Bitboard sideOccupied = Occupies[ (byte) side ];
// Bitboard rooksQueens = Pieces[ (byte) PieceE.Rook ] | Pieces[ (byte) PieceE.Queen ];
// Bitboard bishopsQueens = Pieces[ (byte) PieceE.Bishop ] | Pieces[ (byte) PieceE.Queen ];
// return (MoveAttack._PawnAttacks[ (byte) sqr, (byte) side ] & (Pieces[ (byte) PieceE.Pawn ] & Occupies[ (byte) oppside ]))
// | (MoveAttack._PawnAttacks[ (byte) sqr, (byte) oppside ] & (Pieces[ (byte) PieceE.Pawn ] & Occupies[ (byte) side ]))
// | (MoveAttack._KnightMoves[ (byte) sqr ] & Pieces[ (byte) PieceE.Knight ])
// | (MoveAttack._KingMoves[ (byte) sqr ] & Pieces[ (byte) PieceE.King ])
// | (MoveAttack._RookMoves[ (byte) sqr ] & rooksQueens)
// | (MoveAttack._BishopMoves[ (byte) sqr ] & bishopsQueens);
//}
public override string ToString()
{
StringBuilder sboard = new StringBuilder();
sboard.AppendLine(" +-+-+-+-+-+-+-+-+");
//SquareE begSqr = SquareE.A8;
//SquareE endSqr = SquareE.H1;
//for( SquareE sqr = begSqr; ; Square.BackwardInc(ref sqr) )
//{
// if( (byte) sqr % File.Files == 0 )
// {
// if( sqr != begSqr ) sboard.AppendLine();
// sboard.Append(Rank.mapRank[ (byte) sqr / File.Files ]);
// }
// bool isPiece = false;
// sboard.Append(" ");
// for( ColorE color = ColorE.White; color <= ColorE.Black; ++color )
// {
// Bitboard occupy = Occupies[ (byte) color ];
// for( PieceE type = PieceE.Pawn; type <= PieceE.King; ++type )
// {
// Bitboard piece = Pieces[ (byte) type ];
// if( BitBoard.GetSquare(occupy & piece, sqr) )
// {
// //if( isPiece ) sboard.Append('x'); // '*'
// isPiece = true;
// sboard.Append(Piece.mapPiece[ (byte) color, (byte) type ]);
// break;
// }
// }
// }
// if( !isPiece )
// sboard.Append(".");
// if( sqr == endSqr )
// break;
//}
for (RankE rank = RankE.Rank_8; ; --rank)
{
sboard.Append(Rank.mapRank[(byte)rank]);
for (FileE file = FileE.File_A; file <= FileE.File_H; ++file)
{
bool isPiece = false;
sboard.Append(" ");
for (ColorE color = ColorE.White; color <= ColorE.Black; ++color)
{
Bitboard occupy = Occupies[(byte)color];
SquareE sqr = Square._Square(file, rank);
if (BitBoard.GetSquare(occupy, sqr))
{
for (PieceE type = PieceE.Pawn; type <= PieceE.King; ++type)
{
Bitboard piece = Pieces[(byte)type];
if (BitBoard.GetSquare(piece, sqr)) // occupy & piece
{
//if( isPiece ) sboard.Append('x'); // '*'
isPiece = true;
sboard.Append(Piece.mapPiece[(byte)color, (byte)type]);
break;
}
}
}
}
if (!isPiece)
{
sboard.Append(".");
}
}
if (rank == RankE.Rank_1)
{
break;
}
sboard.AppendLine();
}
sboard.AppendLine().Append(" +-+-+-+-+-+-+-+-+").AppendLine();
sboard.Append(" ");
foreach (char file in File.mapFile)
{
sboard.Append(" " + file);
}
return(sboard.ToString());
}
