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); }