private void ValidateNextShot(GameSide side, string userId)
{
if (!side.PlayerFK.Equals(userId, StringComparison.InvariantCultureIgnoreCase))
{
throw new ResourceForbiddenException();
}
}
private void InitGame()
{
if (Globals.IS_SINGLE_PLAYER)
{
SoldierManager.Instance.InitPcBoard();
pcSide = (GameSide)Random.Range(0, 2);
if (pcSide == GameSide.LeftSide)
{
SoldierManager.Instance.FlipSide();
}
totalSoldiersLocalSide = SoldierManager.Instance.LocalPlayerList.Count - 1;
totalSoldiersEnemySide = SoldierManager.Instance.EnemyList.Count - 1;
CURRENT_TURN = (GameSide)Random.Range(0, 2);
SoldierManager.Instance.HideAllSoldiers();
UpdateStats();
PassTurn();
}
else //game is multiplayer
{
totalSoldiersLocalSide = SoldierManager.Instance.LocalPlayerList.Count - 1;
totalSoldiersEnemySide = SoldierManager.Instance.EnemyList.Count - 1;
UpdateStats();
Globals.Instance.UnityObjects["ResetBtn"].SetActive(false);
GameView.DisableButton("ResetWinBtn");
StartCoroutine(CountTime());
}
cloudInfo.SetActive(false);
stars.Stop();
UpdateTitles();
}
public override bool CanMove(GameSide side, IGameField field)
{
switch (side)
{
case GameSide.Left:
if (_gameBlock.Left.Column == 0 && _gameBlock.Right.Column == 0)
{
return(false);
}
return(field[_gameBlock.Left.Row, _gameBlock.Left.Column - 1].Type == GameCellType.None &&
field[_gameBlock.Right.Row, _gameBlock.Right.Column - 1].Type == GameCellType.None);
case GameSide.Right:
if (_gameBlock.Left.Column + 1 == field.Width && _gameBlock.Right.Column + 1 == field.Width)
{
return(false);
}
return(field[_gameBlock.Left.Row, _gameBlock.Left.Column + 1].Type == GameCellType.None &&
field[_gameBlock.Right.Row, _gameBlock.Right.Column + 1].Type == GameCellType.None);
case GameSide.Down:
return(_gameBlock.Left.CanFallDown(field) && _gameBlock.Right.CanFallDown(field));
default: throw new ArgumentException("Неверно указана сторона side (GameSide)");
}
}
internal DoublePushInfo(GameSide side)
{
side.EnsureDefined();
bool isWhite;
switch (side)
{
case GameSide.White:
isWhite = true;
break;
case GameSide.Black:
isWhite = false;
break;
default:
throw side.CreateEnumValueNotSupportedException();
}
Side = side;
StartRank = isWhite ? 1 : ChessConstants.RankCount - 2;
EndRank = StartRank + (isWhite ? Difference : -Difference);
CaptureTargetRank = (StartRank + EndRank) / 2;
}
private void ValidateExists(GameSide side, PositionModel position)
{
if (side.Shots.Any(x => x.X == position.X && x.Y == position.Y))
{
throw new ShotAlreadyExistsException();
}
}
public ChessGameHandler()
{
InnerGame = new ChessGame(GameSide.White);
Winner = GameSide.Undefined;
// заполняем изображения из файлов
PeiceImages = new Image[2, 6];
PeiceImages[0, 0] = Image.FromFile("Images/king_w.png");
PeiceImages[0, 1] = Image.FromFile("Images/queen_w.png");
PeiceImages[0, 2] = Image.FromFile("Images/rook_w.png");
PeiceImages[0, 3] = Image.FromFile("Images/bishop_w.png");
PeiceImages[0, 4] = Image.FromFile("Images/knight_w.png");
PeiceImages[0, 5] = Image.FromFile("Images/pawn_w.png");
//Black images
PeiceImages[1, 0] = Image.FromFile("Images/king_b.png");
PeiceImages[1, 1] = Image.FromFile("Images/queen_b.png");
PeiceImages[1, 2] = Image.FromFile("Images/rook_b.png");
PeiceImages[1, 3] = Image.FromFile("Images/bishop_b.png");
PeiceImages[1, 4] = Image.FromFile("Images/knight_b.png");
PeiceImages[1, 5] = Image.FromFile("Images/pawn_b.png");
GameImages = new Image[3];
//Misc images
GameImages[0] = Image.FromFile("images/selected.png");
GameImages[1] = Image.FromFile("images/checkglow.png");
GameImages[2] = Image.FromFile("images/selectglow.png");
}
// フィールド上のユニット数を取得する。
public int GetFightingUnitCount(GameSide side)
{
CardController[] cards = fieldTranform.GetComponentsInChildren <CardController>();
int count = Array.FindAll(cards, card => card.model.gameSide == side).Length;
return(count);
}
///
/// <summary>
/// Updates the world.
/// </summary>
///
/// <param name="k">The current keyboard state.</param>
///
public void update(
GameSide gameSide,
KeyboardState k,
Vector2 lookMovement)
{
switch (gameSide)
{
case GameSide.Client:
// Update the player.
this.player.update(this, k, lookMovement);
break;
case GameSide.Server:
// Perform nature ticks.
if (natureTickCounter >= 54000)
{
natureTickCounter = 0;
natureTick();
}
natureTickCounter++;
break;
}
}
public void WinGame(GameSide winSide, string msg = null)
{
isGameOver = true;
SoldierManager.Instance.CoverAllSoldiers();
Globals.Instance.UnityObjects["WinWindow"].SetActive(true);
if (Globals.IS_SINGLE_PLAYER && pcSide != winSide || !Globals.IS_SINGLE_PLAYER && winSide == MultiPlayerManager.Instance.PlayerSide)
{
GameView.SetText("TitleWinner", "You Won !");
SoundManager.Instance.SFX.PlayOneShot(SoundManager.Instance.SinglePlayerWin);
}
else
{
GameView.SetText("TitleWinner", "You Lost !");
SoundManager.Instance.SFX.PlayOneShot(SoundManager.Instance.SinglePlayerLose);
}
if (msg != null)
{
GameView.SetText("MsgWinner", msg);
}
CloseInfo();
SoundManager.Instance.Music.Stop();
GameView.MakeScreenDark();
isPaused = true;
Time.timeScale = 0; //Pause game here
}
public void OnGameStartedOccured(string _Sender, string _RoomId, string _NextTurn)
{
Debug.Log("OnGameStartedOccured: " + _Sender + " " + _RoomId + " " + _NextTurn);
if (_Sender != username)
{
realEnemyUsername = ParseUsername(_Sender);
}
currentUsernameTurn = _NextTurn;
ParseUsername(_NextTurn);
GameManager.CURRENT_TURN = GameSide.LeftSide;
if (currentUsernameTurn == username)
{
playerSide = GameSide.LeftSide;
isMyTurn = true;
var awaySoldiers = MiniJSON.Json.Deserialize(data["AwayPlayer"].ToString()) as List <object>;
SoldierManager.Instance.InitEnemyBoard(awaySoldiers);
}
else
{
playerSide = GameSide.RightSide;
isMyTurn = false;
var homeSoldiers = MiniJSON.Json.Deserialize(data["HomePlayer" + currentUsernameTurn].ToString()) as List <object>;
SoldierManager.Instance.InitEnemyBoard(homeSoldiers);
SoldierManager.Instance.FlipSide();
}
SoldierManager.Instance.HideAllSoldiers();
SwitchToGameScene();
}
// コンストラクタ
public CardModel(int card_id, GameSide side, CardPlace place)
{
// 整数4桁の0埋め
string str_id = card_id.ToString("D4");
// カード情報を読み込む。
CardEntity entity = Resources.Load <CardEntity>("CardEntityList/" + str_id);
id = entity.id;
name = entity.name;
attackPoints = new int[(int)Direction.NUM];
attackPoints[(int)Direction.UP] = entity.attackPointUp;
attackPoints[(int)Direction.DOWN] = entity.attackPointDown;
attackPoints[(int)Direction.LEFT] = entity.attackPointLeft;
attackPoints[(int)Direction.RIGHT] = entity.attackPointRight;
hp = entity.hp;
cost = entity.cost;
text = entity.text;
illust = entity.illust;
skillList = new List <Skill>();
foreach (SkillEntity s in entity.skillEntityList)
{
skillList.Add(new Skill(s));
}
gameSide = side;
canMoveToField = false;
waitAmount = 0.0f;
}
public Bitboard[] GetPinLimitations(int valuablePieceSquareIndex, GameSide attackingSide)
{
var result = DefaultPinLimitations.Copy();
var enemyPieces = PiecePosition[attackingSide];
var ownPieces = PiecePosition[attackingSide.Invert()];
var queens = PiecePosition[attackingSide.ToPiece(PieceType.Queen)];
var bishops = PiecePosition[attackingSide.ToPiece(PieceType.Bishop)];
var rooks = PiecePosition[attackingSide.ToPiece(PieceType.Rook)];
PopulatePinLimitations(
result,
enemyPieces,
valuablePieceSquareIndex,
ownPieces,
DiagonallySlidingAttacks,
queens | bishops);
PopulatePinLimitations(
result,
enemyPieces,
valuablePieceSquareIndex,
ownPieces,
StraightSlidingAttacks,
queens | rooks);
return(result);
}
private void GetPotentialMoveSquaresByRays(
Square sourceSquare,
GameSide sourceSide,
IEnumerable <SquareShift> rays,
int maxDistance,
bool allowCapturing,
ICollection <Square> resultCollection)
{
foreach (var ray in rays)
{
var distance = 1;
for (var square = sourceSquare + ray;
square.HasValue && distance <= maxDistance;
square = square.Value + ray, distance++)
{
var currentSquare = square.Value;
var piece = PiecePosition[currentSquare];
var currentSide = piece.GetSide();
if (piece == Piece.None || !currentSide.HasValue)
{
resultCollection.Add(currentSquare);
continue;
}
if (currentSide.Value != sourceSide && allowCapturing)
{
resultCollection.Add(currentSquare);
}
break;
}
}
}
private void CreatedNewGameEvent(GameEvent ge)
{
GameSide gs = ge.GameEventData.GameSide;
image.GetComponent <Image>().sprite = gs.RandomFaceImage();
text.text = gs.RandomName();
}
private StandardGamePosition(
[NotNull] PiecePosition piecePosition,
GameSide activeSide,
int fullMoveIndex,
CastlingOptions castlingOptions,
EnPassantCaptureInfo2?enPassantCaptureInfo,
int halfMoveCountBy50MoveRule)
: base(piecePosition, activeSide, fullMoveIndex)
{
if (piecePosition is null)
{
throw new ArgumentNullException(nameof(piecePosition));
}
if (halfMoveCountBy50MoveRule < 0)
{
throw new ArgumentOutOfRangeException(
nameof(halfMoveCountBy50MoveRule),
halfMoveCountBy50MoveRule,
@"The value cannot be negative.");
}
CastlingOptions = castlingOptions;
EnPassantCaptureInfo = enPassantCaptureInfo;
HalfMoveCountBy50MoveRule = halfMoveCountBy50MoveRule;
//// TODO [HarinezumiSama] IMPORTANT: This Zobrist key algorithm is different from the one used in the Polyglot opening book (in the en-passant part)
ZobristKey = PiecePosition.ZobristKey
^ ZobristHashHelper.GetCastlingHash(CastlingOptions)
^ ZobristHashHelper.GetEnPassantHash(
EnPassantCaptureInfo,
PiecePosition[ActiveSide.ToPiece(PieceType.Pawn)])
^ ZobristHashHelper.GetTurnHash(ActiveSide);
}
private static SquareDictionary <int> ToSquareWeightMap(GameSide side, int[,] weights)
{
if (weights is null)
{
throw new ArgumentNullException(nameof(weights));
}
if (weights.Length != ChessConstants.SquareCount)
{
throw new ArgumentException(@"Invalid array length.", nameof(weights));
}
var result = new SquareDictionary <int>();
var startRank = side == GameSide.White
? ChessConstants.RankRange.Upper
: ChessConstants.RankRange.Lower;
var rankIncrement = side == GameSide.White ? -1 : 1;
for (int rank = startRank, rankIndex = ChessConstants.RankRange.Lower;
rankIndex <= ChessConstants.RankRange.Upper;
rankIndex++, rank += rankIncrement)
{
for (var file = ChessConstants.FileRange.Lower; file <= ChessConstants.FileRange.Upper; file++)
{
var weight = weights[rankIndex, file];
result.Add(new Square(file, rank), weight);
}
}
return(result);
}
/// <summary>
/// 获取棋的另一战方
/// </summary>
public static GameSide GetOtherGameSide(GameSide currSide)
{
if (currSide == GameSide.Black)
{
return(GameSide.White);
}
return(GameSide.Black);
}
public bool IsInCheck(GameSide side)
{
var king = side.ToPiece(PieceType.King);
var oppositeSide = side.Invert();
var kingSquares = PiecePosition[king].GetSquares();
return(kingSquares.Length != 0 && IsAnyUnderAttack(kingSquares, oppositeSide));
}
private bool IsKingLeftOnly(GameSide side)
{
var sideBitboard = PiecePosition[side];
var kingBitboard = PiecePosition[side.ToPiece(PieceType.King)];
var otherPieces = sideBitboard & ~kingBitboard;
return(otherPieces.IsNone);
}
public void TestTwoKingsTooCloseToEachOther(GameSide activeSide)
{
var fen = $@"k7/K7/8/8/8/8/8/8 {activeSide.GetFenSnippet()} - - 0 1";
Assert.That(
() => new GameBoard(fen, PerformInternalBoardValidation),
Throws.TypeOf <ChessPlatformException>());
}
public static Piece ToPiece(this PieceType pieceType, GameSide side)
{
var result = pieceType == PieceType.None
? Piece.None
: (Piece)((int)pieceType | ((int)side << PieceConstants.BlackSideShift));
return(result);
}
protected void GeneratePotentialKingMoves(
[NotNull] ICollection <GameMoveData2> resultMoves,
GameSide side,
GeneratedMoveTypes moveTypes,
Bitboard target,
CastlingOptions allowedCastlingOptions)
{
if (resultMoves is null)
{
throw new ArgumentNullException(nameof(resultMoves));
}
var kingPiece = side.ToPiece(PieceType.King);
var kings = PiecePosition[kingPiece];
while (kings.IsAny)
{
var kingSquareIndex = Bitboard.PopFirstSquareIndex(ref kings);
var sourceSquare = new Square(kingSquareIndex);
var moves = KingAttacksOrMoves[kingSquareIndex];
var movesOnTarget = moves & target;
if (moveTypes.IsAnySet(GeneratedMoveTypes.Capture))
{
var enemies = PiecePosition[side.Invert()];
var captures = movesOnTarget & enemies;
PopulateSimpleMoves(resultMoves, sourceSquare, captures, GameMoveFlags.IsRegularCapture);
}
//// ReSharper disable once InvertIf
if (moveTypes.IsAnySet(GeneratedMoveTypes.Quiet))
{
var emptySquares = PiecePosition[Piece.None];
var nonCaptures = movesOnTarget & emptySquares;
PopulateSimpleMoves(resultMoves, sourceSquare, nonCaptures, GameMoveFlags.None);
var nonEmptySquares = ~emptySquares;
PopulateKingCastlingMoves(
resultMoves,
sourceSquare,
target,
allowedCastlingOptions,
nonEmptySquares,
CastlingSide.KingSide.ToCastlingType(side));
PopulateKingCastlingMoves(
resultMoves,
sourceSquare,
target,
allowedCastlingOptions,
nonEmptySquares,
CastlingSide.QueenSide.ToCastlingType(side));
}
}
}
public void CheckWin(GameSide potentialLoserSide)
{
GameSide potentialWinnerSide = potentialLoserSide == GameSide.LeftSide ? GameSide.RightSide : GameSide.LeftSide;
if (!SoldierManager.Instance.HasZombies(potentialLoserSide))
{
WinGame(potentialWinnerSide);
}
}
public virtual void Init(int x, int y)
{
SetPos(x, y);
mGameSide = GameManager.GetGameSideFromXY(x, y);
InitColorBySide();
gameObject.SetActive(true);
}
private void PopulateShips(GameSide gameSide, IList <ShipModel> ships)
{
foreach (ShipModel ship in ships)
{
gameSide.Ships.Add(new Ship()
{
Positions = ToPositions(ship.Positions)
});
}
}
private void GenerateSlidingPieceMoves(
[NotNull] ICollection <GameMoveData2> resultMoves,
GameSide side,
GeneratedMoveTypes moveTypes,
PieceType pieceType,
[NotNull] ShiftDirection[] directions)
{
var piece = pieceType.ToPiece(side);
var pieces = PiecePosition[piece];
var emptySquares = PiecePosition[Piece.None];
var enemies = PiecePosition[side.Invert()];
var shouldGenerateQuiets = moveTypes.IsAnySet(GeneratedMoveTypes.Quiet);
var shouldGenerateCaptures = moveTypes.IsAnySet(GeneratedMoveTypes.Capture);
//// TODO [HarinezumiSama] NEW-DESIGN: IDEA: Generate for all pieces rather for one by one
while (pieces.IsAny)
{
var sourceSquareIndex = Bitboard.PopFirstSquareIndex(ref pieces);
var sourceBitboard = Bitboard.FromSquareIndex(sourceSquareIndex);
var sourceSquare = new Square(sourceSquareIndex);
foreach (var direction in directions)
{
var current = sourceBitboard;
while ((current = current.Shift(direction)).IsAny)
{
if ((current & emptySquares).IsAny)
{
if (shouldGenerateQuiets)
{
var move = new GameMove2(sourceSquare, current.GetFirstSquare());
resultMoves.Add(new GameMoveData2(move, GameMoveFlags.None));
}
continue;
}
if ((current & enemies).IsAny)
{
if (shouldGenerateCaptures)
{
var move = new GameMove2(sourceSquare, current.GetFirstSquare());
resultMoves.Add(
new GameMoveData2(move, GameMoveFlags.IsRegularCapture));
}
}
break;
}
}
}
}
public void GenerateKingMoves(
[NotNull] ICollection <GameMoveData> resultMoves,
GameSide side,
CastlingOptions allowedCastlingOptions,
Bitboard target)
{
if (resultMoves is null)
{
throw new ArgumentNullException(nameof(resultMoves));
}
var kingPiece = side.ToPiece(PieceType.King);
var king = PiecePosition[kingPiece];
if (king.IsNone)
{
return;
}
if (!king.IsExactlyOneSquare())
{
throw new ChessPlatformException(
$@"There are multiple {kingPiece.GetDescription()} pieces ({king.GetSquareCount()}) on the board.");
}
var kingSquareIndex = king.FindFirstSquareIndex();
var sourceSquare = new Square(kingSquareIndex);
var directTargets = KingAttacksOrMoves[kingSquareIndex] & target;
var emptySquares = PiecePosition[Piece.None];
var nonCaptures = directTargets & emptySquares;
PopulateSimpleMoves(resultMoves, sourceSquare, nonCaptures, GameMoveFlags.None);
var enemies = PiecePosition[side.Invert()];
var captures = directTargets & enemies;
PopulateSimpleMoves(resultMoves, sourceSquare, captures, GameMoveFlags.IsRegularCapture);
var nonEmptySquares = ~emptySquares;
PopulateKingCastlingMoves(
resultMoves,
sourceSquare,
allowedCastlingOptions,
nonEmptySquares,
CastlingSide.KingSide.ToCastlingType(side));
PopulateKingCastlingMoves(
resultMoves,
sourceSquare,
allowedCastlingOptions,
nonEmptySquares,
CastlingSide.QueenSide.ToCastlingType(side));
}
// 死亡カードの枚数を加算する。
public void IncrementDeathCount(GameSide side)
{
if (side == GameSide.Player)
{
playerDeathCount++;
}
else
{
enemyDeathCount++;
}
}
public void IncreaseSkillCount(GameSide side)
{
if (side == GameSide.Player)
{
playerSkillCount++;
}
else
{
enemySkillCount++;
}
}
// ヒーロースキルを発動する。
public void UseSkillCount(GameSide side)
{
if (side == GameSide.Player)
{
playerSkillCount--;
}
else
{
enemySkillCount--;
}
}
private Move ParseMove(string input, GameSide gameSide)
{
if (input.Length != 5)
return null;
var colFrom = input[0] - 'a' + 1;
var rowFrom = input[1] - '1' + 1;
var colTo = input[3] - 'a' + 1;
var rowTo = input[4] - '1' + 1;
return new Move(rowFrom, colFrom, rowTo, colTo, gameSide);
}
public void SetTileSide (Tile tile, GameSide tileSide) {
tile.TileSide = tileSide;
switch (tileSide) {
case GameSide.Neutral:
tile.GetComponent<SpriteRenderer>().sprite = _wallSprite;
break;
case GameSide.White:
tile.GetComponent<SpriteRenderer>().sprite = _whiteSprite;
break;
case GameSide.Black:
tile.GetComponent<SpriteRenderer>().sprite = _blackSprite;
break;
}
}
public Tile GetTile(GameSide tileSide, int horCoordinateX, int verCoordinateY) {
Tile result = null;
switch (tileSide) {
case GameSide.White:
result = Instantiate(_white);
break;
case GameSide.Black:
result = Instantiate(_black);
break;
case GameSide.Neutral:
result = Instantiate(_wall);
break;
}
ConfigurateTile(result, horCoordinateX, verCoordinateY);
return result;
}
private List<Move> GetAllAvailableMove(Game game, GameSide gameSide)
{
var availableMoves = new List<Move>();
foreach (var figure in game.Board.Figures.Where(x => x.Side == gameSide))
{
var allMovesForFigure = figure.GetFieldsICanMoveTo();
foreach (var locationToMoveTo in allMovesForFigure)
{
var move = new Move(figure.Location, locationToMoveTo, gameSide);
if (_moveValidator.MoveIsValid(move,game.Board))
availableMoves.Add(move);
}
}
return availableMoves;
}
public Queen(GameSide side, int col, int row)
: base(side, col, row)
{
}
public Rook(GameSide side, int col, int row)
: base(side, col, row)
{
}
public Move GenerateMove(Game game, GameSide gameSide)
{
var availableMoves = GetAllAvailableMove(game, gameSide);
return _moveSelector.SelectBestMove(game, availableMoves);
}
/// <summary>
/// 获取对立方
/// </summary>
public static GameSide GetOppositeSide(GameSide side)
{
if (side == GameSide.Our)
{
return GameSide.Enemy;
}
else
{
return GameSide.Our;
}
}
public Move(FieldLocation from, FieldLocation to, GameSide gameSide)
{
From = new FieldLocation(from.Row, from.Column);
To = new FieldLocation(to.Row, to.Column);
Side = gameSide;
}
public bool IsCheck(Board board, GameSide side)
{
// check if any of figures is attacking opponents king
return false;
}
public void AddCharacterCard(CharacterCard card, GameSide side)
{
if (side == GameSide.Our)
{
OurCharacterCard.Add(card.GetCardInfo().cardUUID, card);
}
else
{
EnemyCharacterCard.Add(card.GetCardInfo().cardUUID, card);
}
}
public Pawn(GameSide side, int col, int row)
: base(side, col, row)
{
}
public Move FetchMove(GameSide gameSide)
{
var input = Console.ReadLine();
return ParseMove(input, gameSide);
}
public Knight(GameSide side, int col, int row)
: base(side, col, row)
{
}
public Bishop(GameSide side, int col, int row)
: base(side, col, row)
{
}
public King(GameSide side, int col, int row)
: base(side, col, row)
{
}
public Player(GameSide gameSide)
{
GameSide = gameSide;
IsAIPlayer = false;
}
public bool IsMate(Board board, GameSide side)
{
// check if opponent can make any move after which his king won't be attacked
return false;
}
/// <summary>
/// 向服务器请求添加英雄卡到场上
/// </summary>
public void RequestAddCharacterCard(CharacterCard character, GameSide side, string cardUUID)
{
//发送到远程服务器
SummonCharacterData detailData = new SummonCharacterData();
detailData.cardInfo = character.GetCardInfo();//获取卡片信息
detailData.cardUUID = cardUUID;
detailData.operatePlayerPosition = playerRoomData.allocPosition;
detailData.operatePlayerUid = Global.Instance.playerInfo.uid;
detailData.operatePlayerUUID = Global.Instance.playerInfo.UUID;
GameData data = new GameData();
data.operateCode = OperateCode.SummonCharacter;
data.roomID = playerRoomData.roomID;
data.operateData = JsonCoding<SummonCharacterData>.encode(detailData);
GameClient.Instance.SendToServer(data);
}
protected Figure(GameSide side, int row, int col)
{
Side = side;
Location = new FieldLocation(row, col);
}
public CharacterCard GetCharacterCard(string cardUUID, GameSide side)
{
if (side == GameSide.Our)
{
return OurCharacterCard[cardUUID];
}
else
{
return EnemyCharacterCard[cardUUID];
}
}
private MoveResult GetMoveResult(Board board, GameSide side)
{
if (_boardHandler.IsCheck(board, side))
{
if (_boardHandler.IsMate(board, side))
{
return MoveResult.Mate;
}
return MoveResult.Check;
}
return MoveResult.NormalMove;
}
public Player(GameSide gameSide, bool isAI)
{
GameSide = gameSide;
IsAIPlayer = isAI;
}
public Move(int rowFrom, int colFrom, int rowTo, int colTo, GameSide gameSide)
{
Side = gameSide;
From = new FieldLocation(rowFrom, colFrom);
To = new FieldLocation(rowTo, colTo);
}
