public PieceMetrics this[PieceName pieceName]
{
get
{
return(_pieceMetrics[(int)pieceName]);
}
}
protected int CountNeighbors(PieceName pieceName)
{
int friendlyCount;
int enemyCount;
return(CountNeighbors(GetPiece(pieceName), out friendlyCount, out enemyCount));
}
private MoveSet GetValidMoves(PieceName pieceName)
{
if (null == _cachedValidMovesByPiece)
{
_cachedValidMovesByPiece = new MoveSet[EnumUtils.NumPieceNames];
}
int pieceNameIndex = (int)pieceName;
if (null == _cachedValidMovesByPiece[pieceNameIndex])
{
#if DEBUG
// MoveSet is not cached in L1 cache
ValidMoveCacheMetricsSet["ValidMoves." + EnumUtils.GetShortName(pieceName)].Miss();
#endif
// Calculate MoveSet
Piece targetPiece = GetPiece(pieceName);
MoveSet moves = GetValidMovesInternal(targetPiece);
// Populate cache
_cachedValidMovesByPiece[pieceNameIndex] = moves;
}
#if DEBUG
else
{
// MoveSet is cached in L1 cache
ValidMoveCacheMetricsSet["ValidMoves." + EnumUtils.GetShortName(pieceName)].Hit();
}
#endif
return(_cachedValidMovesByPiece[pieceNameIndex]);
}
protected static bool TryParse(string pieceString, out PieceName pieceName, out Position position)
{
if (string.IsNullOrWhiteSpace(pieceString))
{
throw new ArgumentNullException(nameof(pieceString));
}
pieceString = pieceString.Trim();
try
{
Match match = Regex.Match(pieceString, PieceRegex, RegexOptions.IgnoreCase);
string nameString = match.Groups[1].Value;
string positionString = match.Groups[2].Value;
pieceName = EnumUtils.ParseShortName(nameString);
position = Position.Parse(positionString);
return(true);
}
catch (Exception) { }
pieceName = PieceName.INVALID;
position = null;
return(false);
}
public static Color GetColor(PieceName value)
{
switch (value)
{
case PieceName.wQ:
case PieceName.wS1:
case PieceName.wS2:
case PieceName.wB1:
case PieceName.wB2:
case PieceName.wG1:
case PieceName.wG2:
case PieceName.wG3:
case PieceName.wA1:
case PieceName.wA2:
case PieceName.wA3:
return(Color.White);
case PieceName.bQ:
case PieceName.bS1:
case PieceName.bS2:
case PieceName.bB1:
case PieceName.bB2:
case PieceName.bG1:
case PieceName.bG2:
case PieceName.bG3:
case PieceName.bA1:
case PieceName.bA2:
case PieceName.bA3:
return(Color.Black);
}
return(Color.NumColors);
}
protected static void Parse(string pieceString, out PieceName pieceName, out Position position)
{
if (!TryParse(pieceString, out pieceName, out position))
{
throw new ArgumentException(string.Format("Unable to parse \"{0}\".", pieceString));
}
}
public static string BuildMoveString(bool isPass, PieceName startPiece, char beforeSeperator, PieceName endPiece, char afterSeperator)
{
if (isPass)
{
return(Constants.PassMoveString);
}
var sb = new StringBuilder();
sb.Append(startPiece.ToString());
if (endPiece != PieceName.INVALID)
{
sb.Append(' ');
if (beforeSeperator != '\0')
{
sb.Append($"{beforeSeperator}{endPiece}");
}
else if (afterSeperator != '\0')
{
sb.Append($"{endPiece}{afterSeperator}");
}
else
{
sb.Append(endPiece.ToString());
}
}
return(sb.ToString());
}
private void GetValidSlides(PieceName target, Position currentPosition, HashSet <Position> visitedPositions, int currentRange, int?maxRange, MoveSet validMoves)
{
if (!maxRange.HasValue || currentRange < maxRange.Value)
{
for (int slideDirection = 0; slideDirection < EnumUtils.NumDirections; slideDirection++)
{
Position slidePosition = currentPosition.NeighborAt(slideDirection);
if (!visitedPositions.Contains(slidePosition) && !HasPieceAt(slidePosition))
{
// Slide position is open
int right = EnumUtils.RightOf(slideDirection);
int left = EnumUtils.LeftOf(slideDirection);
if (HasPieceAt(currentPosition.NeighborAt(right)) != HasPieceAt(currentPosition.NeighborAt(left)))
{
// Can slide into slide position
Move move = new Move(target, slidePosition);
if (validMoves.Add(move))
{
// Sliding from this position has not been tested yet
visitedPositions.Add(move.Position);
GetValidSlides(target, slidePosition, visitedPositions, currentRange + 1, maxRange, validMoves);
}
}
}
}
}
}
private bool IsPinned(PieceName pieceName, out int noisyCount, out int quietCount)
{
noisyCount = 0;
quietCount = 0;
bool isPinned = true;
foreach (Move move in GetValidMoves(pieceName))
{
if (move.PieceName == pieceName)
{
isPinned = false;
}
if (IsNoisyMove(move))
{
noisyCount++;
}
else
{
quietCount++;
}
}
return(isPinned);
}
public void ToggleLastMovedPiece(PieceName pieceName)
{
if (pieceName != PieceName.INVALID)
{
Value ^= _hashPartByLastMovedPiece[(int)pieceName];
}
}
public static Piece Get(PieceName pieceName)
{
if (pieceName == PieceName.Amazon || pieceName == PieceName.Arrow)
{
throw new ArgumentException("Don't use this for amazons or arrows. Must specify an owner");
}
return(_pieces[(int)pieceName, 0]);
}
public Position GetPiecePosition(PieceName pieceName)
{
if (pieceName == PieceName.INVALID)
{
throw new ArgumentOutOfRangeException("pieceName");
}
return(GetPiece(pieceName).Position);
}
private void Start()
{
InitializeEvents();
// Inicializacion de varibales
added = init = stopLeft = stopRight = stopRotate = false;
type = Type();
table = GameObject.FindGameObjectWithTag("Table");
}
public static string GetShortName(PieceName pieceName)
{
if (pieceName == PieceName.INVALID)
{
return("");
}
return(PieceShortName[(int)pieceName]);
}
private void PieceCanvas_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
Canvas pieceCanvas = sender as Canvas;
if (null != pieceCanvas)
{
PieceName clickedPiece = EnumUtils.ParseShortName(pieceCanvas.Name);
VM.PieceClick(clickedPiece);
}
}
private void Init(PieceName pieceName, Position position)
{
if (pieceName == PieceName.INVALID)
{
throw new ArgumentOutOfRangeException("pieceName");
}
PieceName = pieceName;
Position = position;
}
public static Piece Get(PieceName pieceName, Owner owner)
{
int ownerNum = (int)owner;
if (ownerNum > 0)
{
ownerNum--;
}
return(_pieces[(int)pieceName, ownerNum]);
}
public AmazonPieceControl(PieceName pieceName, Owner owner)
{
InitializeComponent();
Piece = Piece.Get(pieceName, owner);
PieceImage = PieceToImage(Piece);
if (PieceImage != null)
{
Cell.Children.Add(PieceImage);
}
}
public static IPiece CreatePiece(PieceName Piece, PieceColor Color)
{
return(Piece switch
{
PieceName.Bishop => new Bishop(Color),
PieceName.Queen => new Queen(Color),
PieceName.Rook => new Rook(Color),
PieceName.King => new King(Color),
PieceName.Knight => new Knight(Color),
_ => new Pawn(Color),
});
public MoveCommand(IntegerVector2 startPosition, PieceName pieceName, IntegerVector2 endPosition)
{
if (pieceName == PieceName.None)
{
throw new InvalidOperationException();
}
this.startPosition = startPosition;
this.pieceName = pieceName;
this.endPosition = endPosition;
}
public static string ToBoardSpacePieceName(PieceName pieceName)
{
string name = EnumUtils.GetShortName(pieceName);
if (null != name && name.Length > 0)
{
name = name[0].ToString().ToLower() + name.Substring(1);
}
return(name);
}
internal void CanvasClick(double cursorX, double cursorY)
{
if (AppVM.EngineWrapper.CurrentTurnIsHuman)
{
CanvasCursorX = cursorX;
CanvasCursorY = cursorY;
PieceName clickedPiece = AppVM.EngineWrapper.GetPieceAt(CanvasCursorX, CanvasCursorY, CanvasHexRadius, AppVM.ViewerConfig.HexOrientation);
Position clickedPosition = AppVM.EngineWrapper.GetTargetPositionAt(CanvasCursorX, CanvasCursorY, CanvasHexRadius, AppVM.ViewerConfig.HexOrientation);
// Make sure the first move is on the origin, no matter what
if (Board.BoardState == BoardState.NotStarted && AppVM.EngineWrapper.TargetPiece != PieceName.INVALID)
{
if (AppVM.EngineWrapper.TargetPosition == Position.Origin)
{
AppVM.EngineWrapper.TargetPiece = PieceName.INVALID;
}
else
{
clickedPosition = Position.Origin;
}
}
if (AppVM.EngineWrapper.TargetPiece == PieceName.INVALID && clickedPiece != PieceName.INVALID)
{
// No piece selected, select it
AppVM.EngineWrapper.TargetPiece = clickedPiece;
}
else if (AppVM.EngineWrapper.TargetPiece != PieceName.INVALID)
{
// Piece is selected
if (clickedPiece == AppVM.EngineWrapper.TargetPiece || clickedPosition == AppVM.EngineWrapper.TargetPosition)
{
// Unselect piece
AppVM.EngineWrapper.TargetPiece = PieceName.INVALID;
}
else
{
// Get the move with the clicked position
Move targetMove = new Move(AppVM.EngineWrapper.TargetPiece, clickedPosition);
if (!AppVM.ViewerConfig.BlockInvalidMoves || AppVM.EngineWrapper.CanPlayMove(targetMove))
{
// Move is selectable, select position
AppVM.EngineWrapper.TargetPosition = clickedPosition;
}
else
{
// Move is not selectable, (un)select clicked piece
AppVM.EngineWrapper.TargetPiece = clickedPiece;
}
}
}
}
}
internal void PieceClick(PieceName clickedPiece)
{
if (AppVM.EngineWrapper.CurrentTurnIsHuman)
{
if (AppVM.EngineWrapper.TargetPiece == clickedPiece)
{
clickedPiece = PieceName.INVALID;
}
AppVM.EngineWrapper.TargetPiece = clickedPiece;
}
}
private void VerifyCanMoveWithoutBreakingHive(MockBoard board, PieceName pieceName, bool canMoveExpected)
{
Assert.IsNotNull(board);
Piece piece = board.GetPiece(pieceName);
Assert.IsNotNull(piece);
bool canMoveActual = board.CanMoveWithoutBreakingHive(piece);
Assert.AreEqual(canMoveExpected, canMoveActual);
}
internal Piece(Color color, PieceName name, bool hidden = false)
{
#if DEBUG
if (name == PieceName.General && hidden)
{
throw new InvalidOperationException("Tướng không thể úp !");
}
#endif
this.color = color;
this.name = name;
this.hidden = hidden;
}
public static BugType GetBugType(PieceName pieceName)
{
switch (pieceName)
{
case PieceName.WhiteQueenBee:
case PieceName.BlackQueenBee:
return(BugType.QueenBee);
case PieceName.WhiteSpider1:
case PieceName.WhiteSpider2:
case PieceName.BlackSpider1:
case PieceName.BlackSpider2:
return(BugType.Spider);
case PieceName.WhiteBeetle1:
case PieceName.WhiteBeetle2:
case PieceName.BlackBeetle1:
case PieceName.BlackBeetle2:
return(BugType.Beetle);
case PieceName.WhiteGrasshopper1:
case PieceName.WhiteGrasshopper2:
case PieceName.WhiteGrassHopper3:
case PieceName.BlackGrasshopper1:
case PieceName.BlackGrasshopper2:
case PieceName.BlackGrassHopper3:
return(BugType.Grasshopper);
case PieceName.WhiteSoldierAnt1:
case PieceName.WhiteSoldierAnt2:
case PieceName.WhiteSoldierAnt3:
case PieceName.BlackSoldierAnt1:
case PieceName.BlackSoldierAnt2:
case PieceName.BlackSoldierAnt3:
return(BugType.SoldierAnt);
case PieceName.WhiteMosquito:
case PieceName.BlackMosquito:
return(BugType.Mosquito);
case PieceName.WhiteLadybug:
case PieceName.BlackLadybug:
return(BugType.Ladybug);
case PieceName.WhitePillbug:
case PieceName.BlackPillbug:
return(BugType.Pillbug);
}
throw new ArgumentOutOfRangeException("pieceName");
}
// 現在はColumnSelectorを継承しているが, ColumnSelectorの内部処理は分離してPureC#にした方がいいかも
protected override void OnColumnSelected(IntegerVector2 start, IntegerVector2 via, IntegerVector2 last)
{
IGame game = GameController.Instance.Game;
if (game == null)
{
return;
}
PieceName pieceName = game.Board.GetPiece(start).Name;
PieceMoveData pieceMoveData = new PieceMoveData(string.Empty, start, pieceName, last);
GameController.Instance.ServerDelegate.PostMoveData(pieceMoveData);
}
private void VerifyMoveProperties(Move actualMove, PieceName expectedPieceName, Position expectedPosition)
{
Assert.IsNotNull(actualMove);
Assert.AreEqual(expectedPieceName, actualMove.PieceName);
if (expectedPieceName != PieceName.INVALID)
{
Assert.AreEqual(EnumUtils.GetColor(expectedPieceName), actualMove.Color);
Assert.AreEqual(EnumUtils.GetBugType(expectedPieceName), actualMove.BugType);
}
Assert.AreEqual(expectedPosition, actualMove.Position);
}
public ICommand CreateMoveCommandInstance(string[] words)
{
if (!analyzer.CheckFormat(words, 4) /* || words[0] != CommandEnum.move.ToString()*/)
{
return(null);
}
IntegerVector2 startPosition = analyzer.GetPosition(words[1]);
PieceName pieceName = PieceName.None;
Enum.TryParse(words[2], true, out pieceName);
IntegerVector2 endPosition = analyzer.GetPosition(words[3]);
return(new MoveCommand(startPosition, pieceName, endPosition));
}
public static string NormalizeBoardSpaceMoveString(string moveString)
{
if (string.IsNullOrWhiteSpace(moveString))
{
throw new ArgumentNullException(nameof(moveString));
}
moveString = moveString.Trim();
if (moveString.Equals(Move.PassString, StringComparison.InvariantCultureIgnoreCase))
{
return(Move.PassString.ToLower());
}
string[] moveStringParts = moveString.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
PieceName movingPiece = EnumUtils.ParseShortName(moveStringParts[0]);
if (moveStringParts.Length == 1)
{
return(ToBoardSpacePieceName(movingPiece));
}
string targetString = moveStringParts[1].Trim('-', '/', '\\');
int seperatorIndex = moveStringParts[1].IndexOfAny(new char[] { '-', '/', '\\' });
PieceName targetPiece = EnumUtils.ParseShortName(targetString);
if (seperatorIndex < 0)
{
return(string.Format("{0} {1}", ToBoardSpacePieceName(movingPiece), ToBoardSpacePieceName(targetPiece)));
}
char seperator = moveStringParts[1][seperatorIndex];
if (seperatorIndex == 0)
{
// Moving piece on the left-hand side of the target piece
return(string.Format("{0} {1}{2}", ToBoardSpacePieceName(movingPiece), seperator, ToBoardSpacePieceName(targetPiece)));
}
else if (seperatorIndex == targetString.Length)
{
// Moving piece on the right-hand side of the target piece
return(string.Format("{0} {1}{2}", ToBoardSpacePieceName(movingPiece), ToBoardSpacePieceName(targetPiece), seperator));
}
return(null);
}
