public void createBoard(GameObject prefab, int x, int y) { colors = new Dictionary<byte, Color>(); colors.Add(0, Color.black); colors.Add(1, Color.red); colors.Add(2, Color.green); colors.Add(3, Color.blue); colors.Add(4, Color.gray); colors.Add(5, Color.cyan); colors.Add(6, Color.magenta); colors.Add(7, Color.yellow); colors.Add(8, Color.white); _cellSprite = prefab; maxX = x; maxY = y; _field = new byte[x * y]; _fieldVisual = new CellRotator[x * y]; for (int i = 0; i < maxX; i++) { for (int j = 0; j < maxY; j++) { var z = Instantiate (_cellSprite); z.transform.position = new Vector2 (j + 0.5f, -i - 0.5f); z.transform.parent = transform; z.name = (i * maxX).ToString() + '_' + j.ToString(); _fieldVisual[i * maxX + j] = z.GetComponent<CellRotator> (); _fieldVisual[i * maxX + j].instantOff(); } } _state = BoardState.INITIALIZED; _mainP = FindObjectOfType<MainProxy>(); seedPrefab = _mainP.seedPrefab; }
private void DebugPrintBoard(BoardState board, int indent = 0) { Debug.WriteLine(""); Debug.Write(new string('\t', indent)); Debug.Write(new string('-', _gameConfiguration.NumberOfPits/2*3)); Debug.WriteLine(""); Debug.Write(new string('\t', indent)); for (var pit = _gameConfiguration.NumberOfPits - 1; pit >= _gameConfiguration.NumberOfPits/2; pit--) { Debug.Write(board[pit].ToString().PadRight(3)); } Debug.WriteLine(""); Debug.Write(new string('\t', indent)); for (var pit = 0; pit < _gameConfiguration.NumberOfPits/2; pit++) { Debug.Write(board[pit].ToString().PadRight(3)); } Debug.WriteLine(""); Debug.Write(new string('\t', indent)); Debug.Write(new string('-', _gameConfiguration.NumberOfPits/2*3)); Debug.WriteLine(""); }
public void When_XGoesCorner_Then_TheBoardIsX00000000() { var board = new BoardState().Set(0, BoardMark.X); AssertBoardPositions(board.FreePositions, 1, 2, 3, 4, 5, 6, 7, 8); AssertBoardPositions(board.GetPositions(BoardMark.X), 0); AssertBoardPositions(board.GetPositions(BoardMark.O)); }
public void When_XGoesCorner_and_OGoesSide_Then_TheBoardIsXO0000000() { var board = new BoardState().Set(0, BoardMark.X).Set(1, BoardMark.O); AssertBoardPositions(board.FreePositions, 2, 3, 4, 5, 6, 7, 8); AssertBoardPositions(board.GetPositions(BoardMark.X), 0); AssertBoardPositions(board.GetPositions(BoardMark.O), 1); }
//Varibles End *************************************************************** // Use this for initialization void Start() { networkManager = GameObject.Find("NetworkManager"); getInput = networkManager.GetComponent<GetInput>(); boardState = networkManager.GetComponent<BoardState>(); animate = networkManager.GetComponent<Animate>(); }
public void When_GameNotStarted_Then_TheBoardIsEmpty() { var board = new BoardState(); AssertBoardPositions(board.FreePositions, 0, 1, 2, 3, 4, 5, 6, 7, 8); AssertBoardPositions(board.GetPositions(BoardMark.X)); AssertBoardPositions(board.GetPositions(BoardMark.O)); }
public string EvadeMonsters(BoardState state, Player player) { state.Field.Cards.Clear(); state.TurnStep = TurnStep.Ending; foreach (var p in state.Players) Longpool.Longpool.Instance.PushMessageToUser(p.UserId, new Longpool.AsyncMessage(Longpool.MessageType.EndOfTheBattle)); return ACTION_DONE; }
private StandardPosition(IList<IPosition> circle, int id, BoardState state, int newCardsCount, ISpecialCommand command, bool canSkip) { this._actualCircle = circle; this._id = id; this._state = state; this._newCardsCount = newCardsCount; this._cards = new List<ICard>(); this._command = command; this._canSkip = canSkip; }
public BoardState Copy() { BoardState newBoardState = new BoardState(); foreach (Player player in Players) newBoardState.Players.Add(player.Copy()); foreach (Card card in Cards) newBoardState.Cards.Add(card.Copy()); newBoardState.ActivePlayer = ActivePlayer; newBoardState.CurrentTurn = CurrentTurn; return newBoardState; }
private IEnumerable<BoardState> GenerateSuccessors(BoardState currentBoard) { for (var pit = 0; pit < _gameConfiguration.NumberOfPits/2; pit++) { if (currentBoard[pit] > 0) { var successor = Play(currentBoard, pit); if (IsLegalPlay(currentBoard, successor, pit)) { yield return successor; } } } }
public BoardStateInfo(BoardState b) { CurrentPlayerId = b.CurrentPlayerId; Players = new List<PlayerInfo>(); foreach (var p in b.Players) { if (p.UserId == CurrentUser.Instance.Current.Id) Me = p; else Players.Add(new PlayerInfo(p)); } TurnStep = b.TurnStep; Battle = b.Battle; FieldCards = b.Field.Cards; }
//Varibles End *********************************************************************************** // Use this for initialization void Start() { //This is so I can access the array and find out what the tile ought to be doing. networkManager = GameObject.Find("NetworkManager"); boardState = networkManager.GetComponent<BoardState>(); getInput = networkManager.GetComponent<GetInput>(); defaultColor = this.renderer.material.color; x = (int)this.transform.position.x / 10; y = (int)this.transform.position.z / 10; //TODO Grab this info from the player / Network colorPlayerOne = Color.red; colorPlayerTwo = Color.blue; }
public void UpdateCardTexture(bool alwaysShow, BoardState board, Card card, CardStates State, string classType) { StringBuilder ImagePath = new StringBuilder(@"Textures/Cards/"); ImagePath.Append(card.GetCardGFX()); StringBuilder CardbackPath = new StringBuilder(@"Textures/"); if (card.PlayerID == 0) CardbackPath.Append("Lannister cardback"); else CardbackPath.Append("Stark cardback"); int attack = board.GetCardAttack(card); string manaString = "<b>" + board.GetCardManaCost(card).ToString() + "</b>"; string attackString = "<b>" + attack.ToString() + "</b>"; string healthString = "<b>" + board.GetCardHealth(card).ToString() + "</b>"; if (board.GetCardMaxHealth(card) > board.GetCardHealth(card)) healthString = "<color=MAROON>" + healthString + "</color>"; UpdateCard(alwaysShow || State == CardStates.InHand && card.PlayerID == 0,@"<b>" + card.GetName() + @"</b>", ImagePath.ToString(), CardbackPath.ToString(), manaString, attackString, attack > 0, healthString, State, classType); }
public void Start() { if (State != State.Lobby && State != State.Created) throw new WrongMatchStateException(); // todo: define somewhere if (Players.Count != 4) { for (int i = Players.Count; i < 4; i++) Players.Add(new Player()); //throw new NotEnoughPlayersException(); } State = State.InGame; BoardState = new BoardState(Players); SetRandomStartPlayer(); SendMessageToPlayers(new AsyncMessage(MessageType.GameStarted)); }
/*private void UpdateBoard() { foreach(Card card in Cards) if (card.State == CardStates.OnBoard && card.Health <= 0) DoDie (card.ID); }*/ public static bool CanDoAction(BoardState InitialState, BoardAction Action) { if (Action.Type == "ACTION_DRAW_CARDS") return true; if (Action.Type == "ACTION_DEAL_DAMAGE") return true; if (Action.Type == "ACTION_START_TURN") return true; if (Action.Type == "ACTION_END_TURN") return true; if (Action.Type == "ACTION_PLAY_CARD") { Card ActorCard = InitialState.GetCard((int)Action.Actor); BoardState.Player Player = InitialState.Players[(int)Action.Player]; return Player.CurrentMana >= InitialState.GetCardManaCost(ActorCard) && Action.Player == InitialState.ActivePlayer && ActorCard.State == CardStates.InHand; } if (Action.Type == "ACTION_ATTACK") { Card ActorCard = InitialState.GetCard((int)Action.Actor); int TargetID = (int)Action.Target; Card TargetCard = InitialState.GetCard(TargetID); if (ActorCard.CanAttack == false) return false; if (Action.Player != InitialState.ActivePlayer) return false; if (ActorCard.PlayerID == TargetCard.PlayerID) return false; if (InitialState.GetCardAttack(ActorCard) > 0 && (ActorCard.State == CardStates.Hero || ActorCard.State == CardStates.OnBoard) && (TargetCard.State == CardStates.Hero || TargetCard.State == CardStates.OnBoard)) return true; return false; } if (Action.Type == "ACTION_DIE") return true; return true; }
public Boolean makeMove(Move move) { if (move == null) return false; if (!isValidSquare(move.To) || !isValidSquare(move.From)) return false; Piece from = this.getPiece(move.From); if (from == null) return false; if (from.PieceColor != CurrentColor) return false; Piece to = this.getPiece(move.To); if (to != null && to.PieceColor == CurrentColor) return false; if (from.isValidMove(move)) { this.board[move.To.x, move.To.y] = from; this.board[move.From.x, move.From.y] = null; PreviousMove lastMove = new PreviousMove(); lastMove.Move = move; lastMove.FromPiece = from; lastMove.ToPiece = to; lastMove.CurrentState = this.State; lastMove.CurrentColor = this.CurrentColor; lastMove.CurrentTurn = this.CurrentTurn; lastMove.CurrentHash = this.Hash; this.lastMoves.Push(lastMove); if (from.PieceType == Piece.Type.p) { if (from.PieceColor == Piece.Color.Black) { if (move.To.x == HEIGHT - 1) { Piece nq = new Piece(Piece.Type.q, from.PieceColor); this.board[move.To.x, move.To.y] = nq; } } else { if (move.To.x == 0) { Piece nq = new Piece(Piece.Type.q, from.PieceColor); this.board[move.To.x, move.To.y] = nq; } } } this.Hash = 0; if (to != null && to.PieceType == Piece.Type.k) this.State = from.PieceColor == Piece.Color.Black ? BoardState.BlackWinner : BoardState.WhiteWinner; else { this.CurrentColor = this.CurrentColor == Piece.Color.Black ? Piece.Color.White : Piece.Color.Black; if (this.CurrentColor == Piece.Color.White) ++this.CurrentTurn; if (CurrentTurn > 40) this.State = BoardState.Draw; } return true; } return false; }
private static Player GetNextMover(this BoardState currentBoardState) { return(currentBoardState.CurrentMover == currentBoardState.TopPlayer.Player ? currentBoardState.BottomPlayer.Player : currentBoardState.TopPlayer.Player); }
public void NextPlayer() { CurrentPlayer = (CurrentPlayer == BoardState.BLACK) ? BoardState.RED : BoardState.BLACK; CurrentOpponent = (CurrentOpponent == BoardState.BLACK) ? BoardState.RED : BoardState.BLACK; }
public static int Evaluate(BoardState board, int openingPhase, int endingPhase, ulong fieldsAttackedByWhite, ulong fieldsAttackedByBlack) { return(Evaluate(board, Color.White, openingPhase, endingPhase, fieldsAttackedByBlack) - Evaluate(board, Color.Black, openingPhase, endingPhase, fieldsAttackedByWhite)); }
public BoardState update() { Vector3 mouse = GetPickedPosition( new Vector2((float)input.MouseHandler.MouseState.X, (float)input.MouseHandler.MouseState.Y)); bool onEdge = collideWithEdge(mouse); lineList[1].Position = mouse; lineList[0].Color = Color.OrangeRed; lineList[1].Color = Color.OrangeRed; if ((state == BoardState.chooseEdge1) && (onEdge)) { if (input.MouseHandler.WasLeftButtonClicked()) state = BoardState.chooseEdge2; else state = BoardState.onEdge1; } else if ((state == BoardState.onEdge1)) { if (onEdge) { if (input.MouseHandler.WasLeftButtonClicked()) { lineList[0].Position = p[0].position; state = BoardState.chooseEdge2; } } else state = BoardState.chooseEdge1; } else if ((state == BoardState.chooseEdge2) && (onEdge)) { lineList[1].Position = mouse; if (input.MouseHandler.WasLeftButtonClicked()) state = BoardState.preFold; else state = BoardState.onEdge2; } else if ((state == BoardState.onEdge2)) { lineList[1].Position = p[1].position; lineList[0].Color = Color.Green; lineList[1].Color = Color.Green; if (onEdge) { if (input.MouseHandler.WasLeftButtonClicked()) state = BoardState.preFold; } else state = BoardState.chooseEdge2; } else if (state == BoardState.preFold) { Divide(p[0], p[1], out one, out two); //Tom -- array of all the old fold lines oldLineindices.Add((short)oldLineindices.Count); oldLineList.Add(new VertexPositionNormalTexture(p[0].position, new Vector3(0,0,0), new Vector2(0f, 0.5f))); oldLineindices.Add((short)oldLineindices.Count); oldLineList.Add(new VertexPositionNormalTexture(p[1].position,new Vector3(0,0,0), new Vector2(1f, 0.5f))); state = BoardState.folding1; } if ((input.MouseHandler.WasRightButtonClicked())) { state = BoardState.chooseEdge1; angle = 0; } return state; }
public override bool isValid(AIState currentState) { if (currentState.CurrentPlayerState.HandsFree()) { return(false); } else { int droppedItemID = currentState.CurrentPlayerState.HoldingItemID; if (currentState.ItemStateList[droppedItemID].MyItemType == ItemType.MEAL || currentState.ItemStateList[droppedItemID].MyItemType == ItemType.TABLE || currentState.ItemStateList[droppedItemID].MyItemType == ItemType.BOARD) { return(false); } if (currentState.ItemStateList[id].MyItemType == ItemType.TABLE) { TableSpace table = currentState.ItemStateList[id] as TableSpace; return(table.IsFree()); } else if (currentState.ItemStateList[id].MyItemType == ItemType.BOARD) { BoardState board = currentState.ItemStateList[id] as BoardState; return((currentState.ItemStateList[droppedItemID].MyItemType == ItemType.INGREDIENT) && board.IsFree()); } else if (currentState.ItemStateList[id].MyItemType == ItemType.POT) { if (currentState.ItemStateList[droppedItemID].MyItemType != ItemType.INGREDIENT) { return(false); } else { if ((currentState.ItemStateList[droppedItemID] as IngredientState).IsPrepared && (currentState.ItemStateList[droppedItemID] as IngredientState).IsSpawned) { PotState pot = currentState.ItemStateList[id] as PotState; MealState meal = currentState.ItemStateList[pot.mealID] as MealState; return(meal.MealSize() + 1 <= PotState.MAX_ITEMS_PER_POT && !meal.IsBurnt()); } else { return(false); } } } else if (currentState.ItemStateList[id].MyItemType == ItemType.PLATE) { if (currentState.ItemStateList[droppedItemID].MyItemType != ItemType.INGREDIENT) { return(false); } else { PlateState plate = currentState.ItemStateList[id] as PlateState; MealState meal = currentState.ItemStateList[plate.mealID] as MealState; return((currentState.ItemStateList[droppedItemID] as IngredientState).IsPrepared && (currentState.ItemStateList[droppedItemID] as IngredientState).IsSpawned && !plate.IsSubmitted && !meal.IsBurnt()); } } else { return(false); } } }
public void GameStartState_SolvedCheck_Correct(BoardState startState, bool expected) { var sut = new Game(startState); Assert.Equal(expected, sut.IsSolved); }
private float EstimateEnvironment(BoardState state, (char row, int col) position, ((char row, int col)p1, (char row, int col)p2) opPositions)
public void CloneFrom(BoardState source) { CloneFrom(source.board); }
protected override void OnUpdateBoardState(BoardState aBoardState) { this.text.text = aBoardState.par.ToString(); this.leftButton.interactable = (aBoardState.par != 1); this.rightButton.interactable = (aBoardState.par != Constants.MAXPAR); }
public GameHistory With(Turn turn, BoardState nextState) => new GameHistory( States.Append(nextState).ToArray(), Turns.Append(turn).ToArray());
private void PrisonerGetBlocked(BoardState board) { boardState = board; MessageBox.Show("Player cant move, switch turn"); }
public void DoMove(BoardState currentState) { NextMoveAvailable?.Invoke(new Capitulation()); }
public Boolean undoLastMove() { if (lastMoves.Count < 1) return false; PreviousMove lastMove = lastMoves.Pop(); if (lastMove.FromPiece == null || lastMove.Move == null) return false; this.setPiece(lastMove.Move.To, lastMove.ToPiece); this.setPiece(lastMove.Move.From, lastMove.FromPiece); this.CurrentTurn = lastMove.CurrentTurn; this.CurrentColor = lastMove.CurrentColor; this.State = lastMove.CurrentState; this.Hash = lastMove.CurrentHash; return true; }
public void NewTurn(BoardState newState) { int turnCount = board.currentGame.GetTurnCount() + board.currentGame.turnHistory.Count % 2; NewTurn(newState, turnCount); }
//public void initLevel(List<IDictionary<string, string>> data) //{ // List<Vector3> vecs = new List<Vector3>(); // List<Vector2> tex = new List<Vector2>(); // foreach (IDictionary<string, string> item in data) // { // Vector3 temp = new Vector3(); // temp.X = Convert.To (item["x"]) ( item["x"]; // } //} public void DrawfoldPart() { if (state == BoardState.folding1) { one.foldShape(angle); one.Draw(); angle -= Game1.closeRate; if (angle < -MathHelper.Pi + 1.8f * Game1.closeRate) state = BoardState.folding2; } else if (state == BoardState.folding2) { one.foldShape(angle); one.Draw(); angle += Game1.openRate; if (angle > 0) state = BoardState.chooseEdge1; } }
public override void Delete(BoardState state) { state.Wires.Remove(this); RemoveConnections(state.Connections); }
public override string Execute(BoardState state, Player invoker, ITarget target) { return SetRace(invoker, target as Card); }
public override async Task Draw(PainterScope scope, BoardState state) { await WirePainter.DrawWireLine(scope, state, this); }
public Task <GameState> Process(BoardState boardState) { return(Task.Run(() => GetActions(boardState))); }
public static string formatBoardMsgFromServer(string rawBoard, Game.PlayerColor color, BoardState state = BoardState.ongoing) { rawBoard = replaceServerFormat(rawBoard, color); JSONObject jMsg = new JSONObject(); jMsg.AddField(Consts.Fields.board, createJGrid(rawBoard)); jMsg.AddField(Consts.Fields.boardState, state.ToString()); return(jMsg.Print()); }
public abstract ReadOnlyCollection <Move> GetCandidateMoves(BoardState board, ChessPiece piece);
public override string Execute(BoardState state, Player invoker, ITarget target) { return RemoveAfterUse(state, target as Card); }
public static double KnightProbability(int N, int K, int r, int c) { if (K == 0) { return(1); } int[][] neighbors = new int[][] { new int[] { -1, -2 }, new int[] { -2, -1 }, new int[] { -2, 1 }, new int[] { -1, 2 }, new int[] { 1, -2 }, new int[] { 2, -1 }, new int[] { 1, 2 }, new int[] { 2, 1 } }; BoardState[,] dp = new BoardState[N, N]; BigInteger[] validMoves = new BigInteger[K]; BigInteger[] possibleMoves = new BigInteger[K]; int maxDepth = 0; BigInteger[,] prevCoordinates = new BigInteger[N, N]; BigInteger[,] currCoordinates = new BigInteger[N, N]; BigInteger a = 2; a += 2 * 5; prevCoordinates[r, c] = 1; int elementCount = 1; for (int i = 0; i < K && elementCount != 0; i++) { elementCount = 0; for (int j = 0; j < N; j++) { for (int k = 0; k < N; k++) { if (prevCoordinates[j, k] != 0) { elementCount++; if (dp[j, k] != null) { foreach (var coord in dp[j, k].Neighbors) { currCoordinates[coord.Item1, coord.Item2] += prevCoordinates[j, k]; } validMoves[i] += dp[j, k].ValidMoves * prevCoordinates[j, k]; possibleMoves[i] += 8 * prevCoordinates[j, k]; } else { List <Tuple <int, int> > nb = new List <Tuple <int, int> >(); int valid = 0; // Look for neighbors for (int m = 0; m < neighbors.Length; m++) { int nx = j + neighbors[m][0]; int ny = k + neighbors[m][1]; if (nx >= 0 && nx < N && ny >= 0 && ny < N) { nb.Add(new Tuple <int, int>(nx, ny)); valid++; } } validMoves[i] += valid * prevCoordinates[j, k]; possibleMoves[i] += 8 * prevCoordinates[j, k]; foreach (var coord in nb) { currCoordinates[coord.Item1, coord.Item2] += prevCoordinates[j, k]; } dp[j, k] = new BoardState(nb, valid); } } } } for (int j = 0; j < N; j++) { for (int k = 0; k < N; k++) { prevCoordinates[j, k] = currCoordinates[j, k]; currCoordinates[j, k] = 0; } } maxDepth = i + 1; } double possibility = 1; maxDepth = elementCount == 0 ? maxDepth - 1 : maxDepth; for (int i = 0; i < maxDepth; i++) { Console.WriteLine(validMoves[i] + " " + possibleMoves[i]); possibility *= ((double)((validMoves[i] * 1000000000000) / possibleMoves[i]) / 1000000000000); } return(Math.Round(possibility, 5)); }
public static string getStateString(BoardState state) { switch (state) { case BoardState.BlackWinner: return "B wins"; case BoardState.WhiteWinner: return "W wins"; case BoardState.Draw: return "Draw"; case BoardState.Playing: return "Playing"; default: case BoardState.Unknown: return "Unknown"; } }
public Road placeFreeRoad(BoardState state) { return(state.availableRoads.ElementAt(_r.Next(0, state.availableRoads.Count()))); }
public static BoardStateDto ToDto(this BoardState boardState) => new()
private void stepMovement() { if (boardState == BoardState.MOVING) { float currentDistance = (targetPosition - position).magnitude; float stepPos = (targetPosition - startPosition).magnitude / totalAnimationTime * Chronos.deltaTime; float stepRot = (targetRotation - startRotation).magnitude / totalAnimationTime * Chronos.deltaTime; if (currentDistance <= stepPos) { position = targetPosition; rotation = targetRotation; boardState = BoardState.NORMAL; } else { position += (targetPosition - position).normalized * stepPos; rotation += (targetRotation - rotation).normalized * stepRot; } } }
public Settlement placeFreeSettlement(BoardState state) { return(state.availableSettlements.ElementAt(_r.Next(0, state.availableSettlements.Count()))); }
public string RemoveAfterUse(BoardState state, Card card) { state.Field.Cards.Remove(card); return ACTION_DONE; }
private void UpdateIcons() { IconBoardAttackPlayer.Visibility = Config.Instance.HidePlayerAttackIcon || _game.IsInMenu ? Collapsed : Visible; IconBoardAttackOpponent.Visibility = Config.Instance.HideOpponentAttackIcon || _game.IsInMenu ? Collapsed : Visible; // do the calculation if at least one of the icons is visible if (_game.SetupDone && (IconBoardAttackPlayer.Visibility == Visible || IconBoardAttackOpponent.Visibility == Visible)) { var board = new BoardState(); TextBlockPlayerAttack.Text = board.Player.Damage.ToString(); TextBlockOpponentAttack.Text = board.Opponent.Damage.ToString(); } var showPlayerCthunCounter = WotogCounterHelper.ShowPlayerCthunCounter; var showPlayerSpellsCounter = WotogCounterHelper.ShowPlayerSpellsCounter; var showPlayerJadeCounter = WotogCounterHelper.ShowPlayerJadeCounter; var showPlayerPogoHopperCounter = WotogCounterHelper.ShowPlayerPogoHopperCounter; if (showPlayerCthunCounter) { var proxy = WotogCounterHelper.PlayerCthunProxy; WotogIconsPlayer.Attack = (proxy?.Attack ?? 6).ToString(); WotogIconsPlayer.Health = (proxy?.Health ?? 6).ToString(); } if (showPlayerSpellsCounter) { WotogIconsPlayer.Spells = _game.Player.SpellsPlayedCount.ToString(); } if (showPlayerJadeCounter) { WotogIconsPlayer.Jade = WotogCounterHelper.PlayerNextJadeGolem.ToString(); } if (showPlayerPogoHopperCounter) { WotogIconsPlayer.PogoHopper = ((_game.Player.PogoHopperPlayedCount + 1) * 2 - 1).ToString(); } WotogIconsPlayer.WotogCounterStyle = showPlayerCthunCounter && showPlayerSpellsCounter ? Full : (showPlayerCthunCounter ? Cthun : (showPlayerSpellsCounter ? Spells : None)); WotogIconsPlayer.JadeCounterStyle = showPlayerJadeCounter ? Full : None; WotogIconsPlayer.PogoHopperCounterStyle = showPlayerPogoHopperCounter ? Full : None; var showOpponentCthunCounter = WotogCounterHelper.ShowOpponentCthunCounter; var showOpponentSpellsCounter = WotogCounterHelper.ShowOpponentSpellsCounter; var showOpponentJadeCounter = WotogCounterHelper.ShowOpponentJadeCounter; var showOpponentPogoHopperCounter = WotogCounterHelper.ShowOpponentPogoHopperCounter; if (showOpponentCthunCounter) { var proxy = WotogCounterHelper.OpponentCthunProxy; WotogIconsOpponent.Attack = (proxy?.Attack ?? 6).ToString(); WotogIconsOpponent.Health = (proxy?.Health ?? 6).ToString(); } if (showOpponentSpellsCounter) { WotogIconsOpponent.Spells = _game.Opponent.SpellsPlayedCount.ToString(); } if (showOpponentJadeCounter) { WotogIconsOpponent.Jade = WotogCounterHelper.OpponentNextJadeGolem.ToString(); } if (showOpponentPogoHopperCounter) { WotogIconsOpponent.PogoHopper = ((_game.Opponent.PogoHopperPlayedCount + 1) * 2 - 1).ToString(); } WotogIconsOpponent.WotogCounterStyle = showOpponentCthunCounter && showOpponentSpellsCounter ? Full : (showOpponentCthunCounter ? Cthun : (showOpponentSpellsCounter ? Spells : None)); WotogIconsOpponent.JadeCounterStyle = showOpponentJadeCounter ? Full : None; WotogIconsOpponent.PogoHopperCounterStyle = showOpponentPogoHopperCounter ? Full : None; }
public List<Move> getMoves(Piece.Color c) { List<Move> list = MoveCache.getValueByHash(this.Hash); if (list == null) { list = new List<Move>(); for (int x = 0; x < HEIGHT; ++x) { for (int y = 0; y < WIDTH; ++y) { Piece p = board[x, y]; if (p != null && p.PieceColor == c) { list.AddRange(getPieceMoves(new Square(x, y))); } } } MoveCache.storeValue(this.Hash, list); } if (list.Count < 1) this.State = CurrentColor == Piece.Color.Black ? BoardState.WhiteWinner : BoardState.BlackWinner; return list; }
public void Run() { IsRunning = true; computerPlayer = new Player(PlayerType.TopPlayer, botName); humanPlayer = new Player(PlayerType.BottomPlayer); bot.Init(computerPlayer.PlayerType, gameConstraints); currentBoardState = BoardStateTransition.CreateInitialBoadState(computerPlayer, humanPlayer); NewBoardStateAvailable?.Invoke(currentBoardState); var moveCounter = 0; if (initialProgress != null) { var moves = ParseProgressText.FromFileText(initialProgress) .Select(MoveParser.GetMove); foreach (var move in moves) { currentBoardState = currentBoardState.ApplyMove(move); NewBoardStateAvailable?.Invoke(currentBoardState); } if (moves.Count() % 2 == 1) { var succeedGame = DoBotMove(); if (!succeedGame) { IsRunning = false; bot.NextMoveAvailable -= OnNextBotMoveAvailable; return; } } moveCounter = (int)Math.Ceiling(moves.Count() / 2.0); } while (!stopRunning) { if (moveCounter >= gameConstraints.MaximalMovesPerPlayer) { WinnerAvailable?.Invoke(computerPlayer, WinningReason.ExceedanceOfMaxMoves, null); } bool succeedGame; succeedGame = DoHumanMove(); if (!succeedGame) { break; } succeedGame = DoBotMove(); if (!succeedGame) { break; } moveCounter++; } IsRunning = false; bot.NextMoveAvailable -= OnNextBotMoveAvailable; }
public void resetBoard() { //Black //First row this.board[0, 0] = new Piece(Piece.Type.k, Piece.Color.Black); this.board[0, 1] = new Piece(Piece.Type.q, Piece.Color.Black); this.board[0, 2] = new Piece(Piece.Type.b, Piece.Color.Black); this.board[0, 3] = new Piece(Piece.Type.n, Piece.Color.Black); this.board[0, 4] = new Piece(Piece.Type.r, Piece.Color.Black); //Second row for (int x = 0; x < WIDTH; ++x) this.board[1, x] = new Piece(Piece.Type.p, Piece.Color.Black); //White //First row this.board[HEIGHT - 1, 0] = new Piece(Piece.Type.r, Piece.Color.White); this.board[HEIGHT - 1, 1] = new Piece(Piece.Type.n, Piece.Color.White); this.board[HEIGHT - 1, 2] = new Piece(Piece.Type.b, Piece.Color.White); this.board[HEIGHT - 1, 3] = new Piece(Piece.Type.q, Piece.Color.White); this.board[HEIGHT - 1, 4] = new Piece(Piece.Type.k, Piece.Color.White); //Second row for (int x = 0; x < WIDTH; ++x) this.board[HEIGHT - 2, x] = new Piece(Piece.Type.p, Piece.Color.White); this.CurrentColor = Piece.Color.White; this.CurrentTurn = 1; this.State = BoardState.Playing; lastMoves = new Stack<PreviousMove>(); this.Hash = 0; }
public override string Execute(BoardState state, Player invoker, ITarget target) { return EvadeMonsters(state, invoker); }
public ActionData(BoardAction Action, BoardState FinalState, List<KeyValuePair<BoardAction, BoardState>> History) { this.Action = Action; this.FinalState = FinalState; this.History = History; }
internal double FaceAttackOnBoard(ICard actionCard, Hero enemyHero, PlayerBoardState playerState, BoardState boardState) { if (actionCard.GetDamage() >= enemyHero.GetHPLeft()) { return(Double.MaxValue); } else { if (playerState.Hero.GetHPLeft() < enemyHero.GetHPLeft()) { return(actionCard.GetDamage() / 4.0); } else { return(actionCard.GetDamage()); } } }
public void Initialize(int vNum, Vector3[] points, Vector2[] texCords) { pointOnEdge = Vector3.Zero; center = Vector3.Zero; foreach (Vector3 vec in points) center += vec; center /= vNum; int iCount = (vNum - 3) * 3 + 3; vertNum = vNum; vertices = new VertexPositionNormalTexture[vNum]; oldLineList = new List<VertexPositionNormalTexture>(); oldLineindices = new List<short>(); lineList = new VertexPositionColor[2]; lineList[0].Color = Color.Orange; lineList[1].Color = Color.Orange; lineIndices = new List<short>(); camera = Game1.camera; device = Game1.device; input = Game1.input; worldMatrix = Matrix.Identity; state = BoardState.chooseEdge1; indices = new short[iCount]; invertIndices = new short[iCount]; for (int i = 0; i < vNum; i++) { vertices[i].Position = points[i]; vertices[i].TextureCoordinate = texCords[i]; vertices[i].Normal = Vector3.Up; } //create the indices. every 2 consecutive points makes an outer edge (x,y,z) -> xy , yz (not xz) short j = 0; for (short i = 0; i < iCount; i += 3) { invertIndices[iCount - (i + 1)] = indices[i] = (short)(j % vNum); invertIndices[iCount - (i + 1) - 1] = indices[i + 1] = (short)((j + 1) % vNum); invertIndices[iCount - (i + 1) - 2] = indices[i + 2] = (short)(((j != 4 ? j : 5) + 2) % vNum); j += 2; } verOnEdge = new VertexPositionColor[6]; verOnEdge[0].Color = Color.Purple; verOnEdge[1].Color = Color.Purple; verOnEdge[2].Color = Color.Purple; verOnEdge[3].Color = Color.Purple; verOnEdge[4].Color = Color.Purple; verOnEdge[5].Color = Color.Purple; p = new DividingVert[2]; }
private List <short> FindBestMove(int player, ref int rating, int initialBestRating, short depth) { List <short> bestMoves = new List <short>(); int currentRating = -1; int bestRating = -initialBestRating; m_currentTurn += depth; BoardState state = EvaluateBoard(); m_currentTurn -= depth; if (state != BoardState.Unfinished) { switch (state) { case BoardState.Win: rating = 1; break; case BoardState.Lose: rating = -1; break; case BoardState.Draw: rating = 0; break; } return(bestMoves); } for (int i = 0; i < m_numbersLeft[player].Count; i++) { short s = m_numbersLeft[player][i]; m_board[player, s - 1] = (short)(m_currentTurn + depth); m_numbersLeft[player].Remove(s); if (player == User) { FindBestMove(Opponent, ref currentRating, -initialBestRating, depth); } else if (player == Opponent) { if (m_currentTurn + depth + 1 == Turn.Done) { FindBestMove(User, ref currentRating, -initialBestRating, (short)(depth + 1)); } else { for (int j = 0; j < m_numbersLeft[Computer].Count; j++) { short t = m_numbersLeft[Computer][j]; m_board[Computer, t - 1] = (short)(m_currentTurn + depth + 1); m_numbersLeft[Computer].Remove(t); FindBestMove(User, ref currentRating, -initialBestRating, (short)(depth + 1)); m_board[Computer, t - 1] = 0; m_numbersLeft[Computer].Insert(j, t); } } } if (player == User) { if (currentRating > bestRating) { bestMoves.Clear(); bestMoves.Add(s); bestRating = currentRating; } else if (currentRating == bestRating) { bestMoves.Add(s); } } else if (player == Opponent) { if (currentRating < bestRating) { bestMoves.Clear(); bestMoves.Add(s); bestRating = currentRating; } else if (currentRating == bestRating) { bestMoves.Add(s); } } m_board[player, s - 1] = 0; m_numbersLeft[player].Insert(i, s); } rating = bestRating; return(bestMoves); }
//Varibles End--------------------------------------------------------- //NOTE: Looks like this will run before the board is fully filled causing null refrences. This does not crash the game. //NOTE: Currently I am leaving it as is. This should be fixed later. // Use this for initialization void Start() { networkManager = GameObject.Find("NetworkManager"); boardState = networkManager.GetComponent<BoardState>(); getInput = networkManager.GetComponent<GetInput>(); threatCheckReady = true; // This is just so it will call on startup (threatened tiles) //Here I will go ahead and draw up the game board. //Each tile will be drawn seprately to allow modification and skins. for (int i = 0; i < 8; i++) for (int j = 0; j < 8; j++) { if (i % 2 == 0) { if (j % 2 == 0) { Instantiate(darkTile, new Vector3(i * 10, 0, j * 10), Quaternion.identity); } else { Instantiate(lightTile, new Vector3(i * 10, 0, j * 10), Quaternion.identity); } } else { if (j % 2 == 0) { Instantiate(lightTile, new Vector3(i * 10, 0, j * 10), Quaternion.identity); } else { Instantiate(darkTile, new Vector3(i * 10, 0, j * 10), Quaternion.identity); } }//Draw the tile }//Draw Loop }
Task <Turn> IPlayer.NextTurn(BoardState state) => ((IPlayer)TurnCmdHandler).NextTurn(state);
public void Run() { IsRunning = true; NewBoardStateAvailable?.Invoke(currentBoardState); var moveCounter = 0; while (!stopRunning) { if (moveCounter >= gameConstraints.MaximalMovesPerPlayer) { WinnerAvailable?.Invoke(currentBoardState.TopPlayer.Player, WinningReason.ExceedanceOfMaxMoves); } var nextBottomPlayerBotMove = GetBottomPlayerBotMove(); if (nextBottomPlayerBotMove == null) { break; } if (!GameAnalysis.IsMoveLegal(currentBoardState, nextBottomPlayerBotMove)) { WinnerAvailable?.Invoke(currentBoardState.TopPlayer.Player, WinningReason.InvalidMove); break; } currentBoardState = currentBoardState.ApplyMove(nextBottomPlayerBotMove); NewBoardStateAvailable?.Invoke(currentBoardState); if (nextBottomPlayerBotMove is Capitulation) { WinnerAvailable?.Invoke(currentBoardState.TopPlayer.Player, WinningReason.Capitulation); } var winner = GameAnalysis.CheckWinningCondition(currentBoardState); if (winner != null) { WinnerAvailable?.Invoke(winner, WinningReason.RegularQuoridorWin); break; } var nextTopPlayerBotMove = GetTopPlayerBotMove(); if (nextTopPlayerBotMove == null) { break; } if (!GameAnalysis.IsMoveLegal(currentBoardState, nextTopPlayerBotMove)) { WinnerAvailable?.Invoke(currentBoardState.BottomPlayer.Player, WinningReason.InvalidMove); break; } currentBoardState = currentBoardState.ApplyMove(nextTopPlayerBotMove); NewBoardStateAvailable?.Invoke(currentBoardState); if (nextTopPlayerBotMove is Capitulation) { WinnerAvailable?.Invoke(currentBoardState.BottomPlayer.Player, WinningReason.Capitulation); } var winner2 = GameAnalysis.CheckWinningCondition(currentBoardState); if (winner2 != null) { WinnerAvailable?.Invoke(winner2, WinningReason.RegularQuoridorWin); break; } moveCounter++; } IsRunning = false; bottomPlayerBot.NextMoveAvailable -= OnNextBottomPlayerBotMoveAvailable; topPlayerBot.NextMoveAvailable -= OnNextTopPlayerBotMoveAvailable; }
private BoardState CreateBoardStateFromJson(JSONNode json) { BoardState boardState = new BoardState(); boardState.wordBoardId = json["wordBoardId"].Value; boardState.wordBoardSize = json["wordBoardSize"].AsInt; boardState.nextHintIndex = json["nextHintIndex"].AsInt; // Parse the words JSONArray wordsJson = json["words"].AsArray; boardState.words = new string[wordsJson.Count]; for (int i = 0; i < wordsJson.Count; i++) { boardState.words[i] = wordsJson[i].Value; } // Parse the found words JSONArray foundWordsJson = json["foundWords"].AsArray; boardState.foundWords = new bool[foundWordsJson.Count]; for (int i = 0; i < foundWordsJson.Count; i++) { boardState.foundWords[i] = foundWordsJson[i].AsBool; } // Parse the tile states JSONArray tileStatesJson = json["tileStates"].AsArray; boardState.tileStates = new BoardState.TileState[tileStatesJson.Count]; for (int i = 0; i < tileStatesJson.Count; i++) { boardState.tileStates[i] = (BoardState.TileState)tileStatesJson[i].AsInt; } // Parse the tile lettes JSONArray tileLettersJson = json["tileLetters"].AsArray; boardState.tileLetters = new char[tileLettersJson.Count]; for (int i = 0; i < tileLettersJson.Count; i++) { boardState.tileLetters[i] = System.Convert.ToChar(tileLettersJson[i].Value); } // Parse the hint letters JSONArray hintLettersJson = json["hintLetters"].AsArray; boardState.hintLettersShown = new List <int[]>(hintLettersJson.Count); for (int i = 0; i < hintLettersJson.Count; i++) { string[] hintLetter = hintLettersJson[i].Value.Split(','); boardState.hintLettersShown.Add(new int[2] { System.Convert.ToInt32(hintLetter[0]), System.Convert.ToInt32(hintLetter[1]) }); } return(boardState); }
private void FirstThrowHistory(List <string> validOpponentNames) { short[] firstThrows = new short[N]; IDictionaryEnumerator e = m_history.GetEnumerator(); while (e.MoveNext()) { string opp = (string)e.Key; List <short[]> games = (List <short[]>)e.Value; if (validOpponentNames.Contains(opp)) { foreach (short[] game in games) { foreach (int y in m_numbersLeft[Opponent]) { if (game[N * Opponent + y - 1] == 1) { firstThrows[y - 1]++; break; } } } } } if (validOpponentNames.Count == 1 && validOpponentNames[0] == m_opponentName) { Console.WriteLine("First Throw History[" + m_opponentName + "]:"); } else { Console.WriteLine("First Throw History[" + m_joinDate.ToShortDateString() + "]:"); } for (int i = 0; i < N; i++) { Console.WriteLine((i + 1) + ": " + firstThrows[i]); } Console.WriteLine(); if (validOpponentNames.Count == 1) { foreach (string person in validOpponentNames) { if (m_history.ContainsKey(person)) { int wins = 0; int losses = 0; int ties = 0; foreach (short[] game in m_history[person]) { BoardState status = Status(game); if (status == BoardState.Win) { wins++; } if (status == BoardState.Lose) { losses++; } if (status == BoardState.Draw) { ties++; } } Console.WriteLine(validOpponentNames[0] + " win rate = " + (100 * losses / (wins + losses + ties)) + "%\n"); } } } }
private void Go() { if (m_currentTurn == Turn.Start) { Console.Write("\nOpponent's Name: "); m_opponentName = Console.ReadLine(); Console.WriteLine(); if (!GuaranteeLookup()) { Console.Write("Is " + m_opponentName + " definitely a person (y/n)? "); string guarantee = Console.ReadLine(); if (guarantee.ToLower() == "y") { m_isGuaranteedPerson = true; } Console.WriteLine(); } else { Console.WriteLine("This player is definitely a person."); Console.WriteLine(); } JoinDate: if (DateLookup() == DateTime.MinValue) { Console.Write("When did this player join (mmddyy)? "); string startdate = Console.ReadLine(); foreach (char c in startdate) { if (!char.IsDigit(c)) { goto JoinDate; } } string month = startdate.Substring(0, 2); string day = startdate.Substring(2, 2); string year = startdate.Substring(4, 2); try { int intMonth = Convert.ToInt16(month); int intDay = Convert.ToInt16(day); int intYear = Convert.ToInt16(year) + 2000; m_joinDate = new DateTime(intYear, intMonth, intDay); } catch { goto JoinDate; } } else { m_joinDate = DateLookup(); Console.WriteLine("This player started on " + m_joinDate.ToShortDateString() + "."); Console.WriteLine(); } List <string> opponents = new List <string>(); opponents.Add(m_opponentName); FirstThrowHistory(opponents); if (m_dateToPlayers.ContainsKey(m_joinDate)) { if (m_dateToPlayers[m_joinDate].Count == 1 && m_dateToPlayers[m_joinDate][0] == m_opponentName) { // no op } else { FirstThrowHistory(m_dateToPlayers[m_joinDate]); } } } Display(); m_currentTurn++; if (m_currentTurn == Turn.Done || EvaluateBoard() != BoardState.Unfinished) { BoardState state = EvaluateBoard(); Console.WriteLine("Game Complete: " + state.ToString()); switch (state) { case BoardState.Win: m_wins++; break; case BoardState.Lose: m_losses++; break; case BoardState.Draw: m_draws++; break; } Console.WriteLine("(" + m_wins + "/" + m_losses + "/" + m_draws + ")"); Console.WriteLine("Win% = " + (m_wins * 100.0 / (m_wins + m_losses + m_draws)) + "%"); Save(); return; } string input; Computer: Console.Write("Computer displays: "); input = Console.ReadLine(); if (input.ToLower() == "q") { m_currentTurn = Turn.Done; return; } if (ValidShort(input, Computer)) { m_board[Computer, ToShort(input) - 1] = (short)m_currentTurn; m_numbersLeft[Computer].Remove(ToShort(input)); } else { goto Computer; } List <string> opponents2 = new List <string>(); opponents2.Add(m_opponentName); Histogram(ToShort(input), opponents2); if (m_dateToPlayers.ContainsKey(m_joinDate)) { if (m_dateToPlayers[m_joinDate].Count == 1 && m_dateToPlayers[m_joinDate][0] == m_opponentName) { // no op } else { Histogram(ToShort(input), m_dateToPlayers[m_joinDate]); } } if (m_currentTurn > Turn.Second) { int rating = 0; List <short> bestMoves = FindBestMove(User, ref rating, int.MaxValue, 0); string moves = "{"; for (int i = 0; i < bestMoves.Count; i++) { moves += bestMoves[i].ToString(); if (i != bestMoves.Count - 1) { moves += ", "; } else { moves += "}"; } } Console.WriteLine("Best Move: " + moves); Console.WriteLine("Rating: " + rating); User = 2; Opponent = 0; rating = 0; bestMoves = FindBestMove(User, ref rating, int.MaxValue, 0); moves = "{"; for (int i = 0; i < bestMoves.Count; i++) { moves += bestMoves[i].ToString(); if (i != bestMoves.Count - 1) { moves += ", "; } else { moves += "}"; } } Console.WriteLine("Opponent's Best Move: " + moves); Console.WriteLine("Opponent's Rating: " + rating + "\n"); User = 0; Opponent = 2; } User: Console.Write("User chooses: "); input = Console.ReadLine(); if (input.ToLower() == "q") { m_currentTurn = Turn.Done; return; } if (ValidShort(input, User)) { m_board[User, ToShort(input) - 1] = (short)m_currentTurn; m_numbersLeft[User].Remove(ToShort(input)); } else { goto User; } Opponent: Console.Write("Opponent displays: "); input = Console.ReadLine(); if (input.ToLower() == "q") { m_currentTurn = Turn.Done; return; } if (ValidShort(input, Opponent)) { m_board[Opponent, ToShort(input) - 1] = (short)m_currentTurn; m_numbersLeft[Opponent].Remove(ToShort(input)); } else { goto Opponent; } Console.WriteLine(); Go(); }