public BoardState(BoardState bs)
{
WhiteCantMove = false;
BlackCantMove = false;
turn = bs.turn;
Size = bs.Size;
Count = bs.Count;
pieces = new Piece[Size][];
for (int i = 0; i < Size; i++)
{
pieces[i] = new Piece[Size];
for (int j = 0; j < Size; j++)
{
pieces[i][j] = bs.pieces[i][j];
}
}
pieceCount = bs.pieceCount;
BlackCount = bs.BlackCount;
WhiteCount = bs.WhiteCount;
// Dictionary that holds <Move, Points To Convert>
availableMoves = new Dictionary <Point, List <Point> >();
GameOver = false;
GameTied = false;
PossibleToMove = bs.PossibleToMove;
GenerateAvailableMoves();
}
private void startGame()
{
//重绘背景
string path = System.Environment.CurrentDirectory;
path = path.Substring(0, path.Length - 9);
ChessBoard.Image = Image.FromFile(path + @"source\background.jpg");
game = new Game();
forbidden = new Forbidden();
game.isEnd = false;
启用禁手ToolStripMenuItem.Enabled = false;
设置步时ToolStripMenuItem.Enabled = false;
timer1.Start();
black_time_all.Text = "局时: 0秒";
black_time_this.Text = "步时: 0秒";
white_time_all.Text = "局时: 0秒";
white_time_this.Text = "步时: 0秒";
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 15; j++)
{
board[i, j] = 0;
gameTurn = GameTurn.Black;
}
}
}
public static GameTurn CreateCompositeJump(IReadOnlyCollection <GameTurn> turns)
{
if (!turns.Any() || turns.First() == null)
{
return(null);
}
var result = new List <int>();
GameTurn lastTurn = null;
foreach (var newTurn in turns)
{
if (newTurn == null || lastTurn != null &&
(lastTurn == newTurn ||
lastTurn.Steps.Last() != newTurn.Steps.First() ||
lastTurn.IsLevelUp))
{
return(null);
}
lastTurn = newTurn;
result.AddRange(newTurn.Steps.SkipLast(1));
}
result.Add(turns.Last().Steps.Last());
return(new GameTurn(turns.First().Side, turns.Last().IsLevelUp, result));
}
public GamePlaceResult PlaceObjectAt(int x, int y)
{
GamePlaceResult result;
if (Grid[x, y] == GridObjectType.Empty)
{
Grid[x, y] = GetTurnObject(Turn);
if ((Turn == Winner) || IsFull)
{
Turn = GameTurn.None;
result = GamePlaceResult.End;
}
else
{
Turn = GetNextTurn(Turn);
result = GamePlaceResult.Success;
}
}
else
{
result = GamePlaceResult.Fail;
}
return(result);
}
public GameTurn GetNextTurn(GameTurn current)
{
GameTurn next;
switch (current)
{
case GameTurn.Player1:
if (Mode == GameMode.PlayerVsPlayer)
{
next = GameTurn.Player2;
}
else
{
next = GameTurn.Ai;
}
break;
case GameTurn.Player2:
case GameTurn.Ai:
next = GameTurn.Player1;
break;
default:
throw new NotImplementedException();
}
return(next);
}
public GameState ResolveMoves(GameState oldState, GameTurn gameTurn)
{
foreach (GameMove move in gameTurn.moves)
{
oldState.cells [move.targetRow * 3 + move.targetCol] = oldState.whoseTurn;
}
// Check winner
string[] roles = { "0", "1" };
List <string> players = new List <string> (roles);
string winner = TicTacToeLogic.GetWinner(players, oldState.cells);
if (winner != null)
{
oldState.stage = 1;
oldState.winner = winner;
}
else
{
if (oldState.whoseTurn == "0")
{
oldState.whoseTurn = "1";
}
else
{
oldState.whoseTurn = "0";
}
}
return(oldState);
}
public static void RemovePendingAction(this GameTurn turn, GameAction action)
{
var temp = turn.PendingActions;
temp.Remove(action);
turn.PendingActions = temp;
}
public void SetTurn(GameTurn turn, GridObjectType turnObjectType)
{
switch (turn)
{
case GameTurn.None:
_turnText.text = string.Empty;
break;
case GameTurn.Player1:
_turnText.text = "Player 1's turn";
break;
case GameTurn.Player2:
_turnText.text = "Player 2's turn";
break;
case GameTurn.Ai:
_turnText.text = "AI's turn";
break;
default:
throw new NotImplementedException();
}
_turnText.color = GetColor(turnObjectType);
}
public void SetWinner(GameTurn winner, GridObjectType winnerObjectType)
{
switch (winner)
{
case GameTurn.None:
_turnText.text = "Draw";
break;
case GameTurn.Player1:
_turnText.text = "Player 1 won!";
break;
case GameTurn.Player2:
_turnText.text = "Player 2 won!";
break;
case GameTurn.Ai:
_turnText.text = "AI won!";
break;
default:
throw new NotImplementedException();
}
_turnText.color = GetColor(winnerObjectType);
}
public static void AddPendingAction(this GameTurn turn, GameAction action)
{
var temp = turn.PendingActions;
temp.Add(action);
turn.PendingActions = temp;
}
private void SaveSettingsButton_Click(object sender, EventArgs e)
{
SettingsModel settingsToSave = new SettingsModel();
settingsToSave.Difficulty = Convert.ToInt32(DifficultyBox.Text);
settingsToSave.Theme = ThemeBox.Text;
settingsToSave.UserWord = PSymbolBox.Text;
settingsToSave.ComputerWord = CSymbolBox.Text;
GameTurn turn = GameTurn.Random;
if (TPlayer.Checked)
{
turn = GameTurn.Player;
}
if (TRandom.Checked)
{
turn = GameTurn.Random;
}
if (TComputer.Checked)
{
turn = GameTurn.Computer;
}
settingsToSave.GameTurn = turn;
File.WriteAllText("settings.json", JsonConvert.SerializeObject(settingsToSave));
this.Close();
MainMenuView.Show();
}
public GameTurn ReadTurn()
{
var gameTurn = new GameTurn(_myTeamId, _bustersPerPlayer, _ghostCount);
gameTurn.ReadEntities(_console);
return(gameTurn);
}
internal void RunBattleScreen(Player rcvdMePlayer, GameRound gameRound)
{
if (gameRound.player1.sessionId == rcvdMePlayer.sessionId)
{
_enemy = gameRound.player2;
_me = gameRound.player1;
}
else if (gameRound.player2.sessionId == rcvdMePlayer.sessionId)
{
_enemy = gameRound.player1;
_me = gameRound.player2;
}
for (int i = 0; i < 5; i++)
{
turns[i] = new GameTurn
{
damageDealt = CalcDamage(_me.actions[i], _enemy.actions[i]),
damageReceived = CalcDamage(_enemy.actions[i], _me.actions[i]),
action = _me.actions[i],
actionRecieved = _enemy.actions[i]
};
}
enemyImage.sprite = avatars[(int)_enemy.avatar];
meImage.sprite = avatars[(int)_me.avatar];
_turn = 0;
DisplayTurn();
}
/// <summary>
/// Triggers the Game Over State
/// </summary>
private void TriggerLevelComplete()
{
//Set it to be nobody's turn
CurrentTurn = GameTurn.TURN_NONE;
//Send Level Failed Event
LevelCompleted?.Invoke();
}
public virtual void Initialize()
{
GameEntry.Event.Subscribe(ShowEntitySuccessEventArgs.EventId, OnShowEntitySuccess);
GameEntry.Event.Subscribe(ShowEntityFailureEventArgs.EventId, OnShowEntityFailure);
GameEntry.Event.Subscribe(OpenUIFormSuccessEventArgs.EventId, OnOpenUIFormSuccess);
gameTurn = GameTurn.None;
GameEntry.Event.Subscribe(EventTest.EventId, Test);
GameEntry.UI.OpenUIForm(UIFormId.GameForm, this);
GameEntry.Entity.ShowPlayer(new PlayerData(GameEntry.Entity.GenerateSerialId(), 1)
{
Position = new Vector3(-5f, -1f, 0),
LocalScale = Vector3.one * 0.4f,
});
GameEntry.Entity.ShowEnemy(new EnemyData(GameEntry.Entity.GenerateSerialId(), 10)
{
Position = new Vector3(1f, -1f, 0),
LocalScale = Vector3.one * 0.35f,
});
GameEntry.Entity.ShowEnemy(new EnemyData(GameEntry.Entity.GenerateSerialId(), 11)
{
Position = new Vector3(4f, -1f, 0),
LocalScale = Vector3.one * 0.35f,
});
GameEntry.Entity.ShowEnemy(new EnemyData(GameEntry.Entity.GenerateSerialId(), 11)
{
Position = new Vector3(7f, -1f, 0),
LocalScale = Vector3.one * 0.35f,
});
_cardSelectionSystem = new CardSelectionSystem();
_deckDrawingSystem = new DeckDrawingSystem();
_handPresentationSystem = new HandPresentationSystem();
_effectResolutionSystem = new EffectResolutionSystem();
_system.Add(_effectResolutionSystem);
_system.Add(_cardSelectionSystem);
_system.Add(_deckDrawingSystem);
_system.Add(_handPresentationSystem);
foreach (var sys in _system)
{
sys.Init();
}
// GameEntry.Event.Fire(this,EventTest.Create0(12));
// GameEntry.Event.Fire(this,EventTest.Create1(45));
_prepareCharacter = 0;
_prepareUI = false;
GameOver = false;
_mPlayerLogic = null;
_enemyLogics = new List <EnemyLogic>();
}
public static void RestartGame()
{
//Fire event to load game
//(i.e reset level offset)
LevelStarted?.Invoke();
LevelUnPaused?.Invoke();
CurrentTurn = GameTurn.TURN_PLAYER;
}
private GameTurn ResolveTurnOfHandsPlayFromPlayersUsing(HandsPlay handsPlayExecuted)
{
var gameTurn = new GameTurn
{
HandsPlayOfTheTurn = handsPlayExecuted,
ResultOfTheHandsPlay = _handsPlayResolverService.ResolveHandsPlayWithStrategies(handsPlayExecuted)
};
return(gameTurn);
}
public static void SetupTurn(this Game game, GameTurn oldTurn)
{
game.SetNextPlayer();
var newTurn = new GameTurn {
Game = game, TurnNumber = oldTurn.TurnNumber + 1, CurrentPlayer = game.CurrentPlayer
};
game.Turns.Add(newTurn);
newTurn.StartTurn();
}
public static void SetCurrentAction(this GameTurn turn, GameActionState state, string location)
{
if (turn.CurrentAction != null)
{
turn.AddCompletedAction(turn.CurrentAction);
}
turn.CurrentAction = new GameAction {
State = state, Location = location, IsExecutable = true
};
}
/// <summary>
/// Resets round, recoloring everything to previous color, writing
/// original numbers of armies.
/// </summary>
/// <param name="gameRound">Round to reset</param>
internal void ResetRound(GameTurn gameRound)
{
Attacking attackingPhase = gameRound.Attacking;
ResetAttackingPhase(attackingPhase, gameRound.Deploying);
Deploying deployingPhase = gameRound.Deploying;
ResetDeployingPhase(deployingPhase);
}
public static void AddCompletedAction(this GameTurn turn, GameAction action)
{
if (action.IsComplete == false)
{
action.IsComplete = true;
var temp = turn.CompletedActions;
temp.Add(action);
turn.CompletedActions = temp;
}
}
public static void AreTurnsEqual(GameTurn first, GameTurn second)
{
Assert.NotNull(first);
Assert.NotNull(second);
Assert.AreEqual(first.Side, second.Side);
Assert.AreEqual(first.IsSimple, second.IsSimple);
Assert.AreEqual(first.IsLevelUp, second.IsLevelUp);
Assert.AreEqual(first.Steps, second.Steps);
}
public void GameTurnTest()
{
var turn = new GameTurn(GameConfig.BeginnerGamePieceCount);
for (int i = 0; i < turn.CodeBreakerGuesses.Length; i++)
{
Assert.AreEqual(turn.CodeBreakerGuesses[i], GamePieces.Empty);
Assert.AreEqual(turn.GuessResults[i], GuessResult.Empty);
}
}
public void turnOver()
{
if (currentTurn == GameTurn.PLAYER)
{
for (int i = 0; i < enemies.Length; ++i)
{
if (enemies[i].gameObject.activeSelf)
{
if (enemies[i].getStatusEffect() == StatusEffect.Corrosion)
{
enemies[i].GetDamaged((int)(enemies[i].getMaxHP() * 0.05f));
enemies[i].mobDead();
}
if (enemies[i].getStatusEffect() == StatusEffect.Frostbite)
{
enemies[i].setMoveable(!enemies[i].isMoveable());
}
if (enemies[i].getStatusEffect() != StatusEffect.None)
{
enemies[i].setStatusRemainTurn(enemies[i].getStatusRemainTurn() - 1);
if (enemies[i].getStatusRemainTurn() <= 0)
{
enemies[i].setStatusEffect(StatusEffect.None);
enemies[i].setMoveable(true);
}
}
}
}
currentTurn = GameTurn.ENEMY;
cost = ++maxCost;
if (maxCost > 10)
{
cost = maxCost = 10;
}
InGameUIManager.Inst().costTextUpdate();
}
else
{
if (PlayerManager.Inst().getPlayer().getStatusEffect() == StatusEffect.Frostbite)
{
PlayerManager.Inst().getPlayer().setMoveable(!PlayerManager.Inst().getPlayer().isMoveable());
}
if (PlayerManager.Inst().getPlayer().getStatusEffect() != StatusEffect.None)
{
PlayerManager.Inst().getPlayer().setStatusRemainTurn(PlayerManager.Inst().getPlayer().getStatusRemainTurn() - 1);
if (PlayerManager.Inst().getPlayer().getStatusRemainTurn() <= 0)
{
PlayerManager.Inst().getPlayer().setStatusEffect(StatusEffect.None);
PlayerManager.Inst().getPlayer().setMoveable(true);
}
}
currentTurn = GameTurn.PLAYER;
}
InGameUIManager.Inst().HPbarUpdate();
}
public static void RemovePendingAction(this GameTurn turn, GameActionState state)
{
var temp = turn.PendingActions;
var action = temp.FirstOrDefault(a => a.State == state);
if (action != null)
{
temp.Remove(action);
}
turn.PendingActions = temp;
}
public static void StartTurn(this GameTurn turn)
{
var startAction = new GameAction {
State = GameActionState.ChooseLocation
};
turn.CurrentAction = startAction;
var invoker = new ActionContextInvoker(turn.Game);
invoker.DoActionSingle(startAction);
}
private void switchTurn()
{
if (gameTurn == GameTurn.Player1)
{
gameTurn = GameTurn.Player2;
}
else
{
gameTurn = GameTurn.Player1;
}
}
public void Reset(int seed)
{
for (var x = 0; x < Grid.GetLength(0); ++x)
{
for (var y = 0; y < Grid.GetLength(1); ++y)
{
Grid[x, y] = GridObjectType.Empty;
}
}
Turn = GetFirstTurn(seed);
}
private bool TryUpdateField(GameTurn newTurn)
{
if (newTurn == null ||
!GameFieldUtils.TryCreateField(_modelController.Field, newTurn, out GameField newGameField))
{
return(false);
}
_modelController.UpdateField(newGameField);
return(true);
}
public static void SetupKickedOutTurn(this Game game, GameTurn oldTurn)
{
//todo add turnstart action state, then add completed turn start action
//todo add chooselocation to pending actions
var newTurn = new GameTurn {
Game = game, TurnNumber = oldTurn.TurnNumber + 1, CurrentPlayer = oldTurn.KickedOutPlayer
};
game.CurrentPlayerId = oldTurn.KickedOutPlayer.Id;
game.Turns.Add(newTurn);
newTurn.StartTurn();
}
void Awake()
{
aiManager = GameObject.Find("Managers").GetComponent<AIManager>();
uiManager = Camera.main.GetComponent<UIManager>();
playerSettings = Camera.main.GetComponent<PlayerSettings>();
cameraManager = Camera.main.GetComponent<CameraManager>();
board = GameObject.Find("Board").GetComponent<Board>();
black = (GameObject)Resources.Load("Black");
white = (GameObject)Resources.Load("White");
turn = GameTurn.Player;
Count = 0;
WhiteCount = 0;
BlackCount = 0;
WhiteCantMove = false;
BlackCantMove = false;
playerMove = null;
}
void GameStart(GameStartEvent e)
{
curStage = GameStage.GameLoop;
Events.instance.Raise(new IssueOrdersEvent());
curTurn = GameTurn.IssueOrders;
}
public static void SetupKickedOutTurn(this Game game, GameTurn oldTurn)
{
//todo add turnstart action state, then add completed turn start action
//todo add chooselocation to pending actions
var newTurn = new GameTurn { Game = game, TurnNumber = oldTurn.TurnNumber + 1, CurrentPlayer = oldTurn.KickedOutPlayer };
game.CurrentPlayerId = oldTurn.KickedOutPlayer.Id;
game.Turns.Add(newTurn);
newTurn.StartTurn();
}
public void ChangeTurn()
{
if (this.turn == GameTurn.Black)
this.turn = GameTurn.White;
else
this.turn = GameTurn.Black;
if (selectedObject != null) {
this.DeselectPiece (selectedPiece);
}
foreach (string name in whitePieceNames) {
GameObject piece = pieceObjects[name].gameObject;
BoxCollider collider = piece.GetComponent<BoxCollider>();
if(pieceObjects[name].isDead) {
collider.enabled = false;
}
else {
collider.enabled = (GameTurn.Black != this.turn);
}
}
foreach (string name in blackPieceNames) {
GameObject piece = pieceObjects[name].gameObject;
BoxCollider collider = piece.GetComponent<BoxCollider>();
if(pieceObjects[name].isDead) {
collider.enabled = false;
}
else {
collider.enabled = (GameTurn.Black == this.turn);
}
}
}
public static void SetupFirstTurn(this Game newGame)
{
var firstTurn = new GameTurn { TurnNumber = 0, Type = GameTurnType.Setup, CurrentAction = new GameAction { State = GameActionState.GameStart } };
newGame.Turns.Add(firstTurn);
var next = new GameAction { State = GameActionState.Pass };
(new ActionContextInvoker(newGame)).DoActionSingle(next);
}
// Main game loop handling turns
private IEnumerator GameLoop()
{
// Run game loop while the game isn't over (won/lost) or tied
while (!aiManager.GameOver && !aiManager.GameTied)
{
turn = GameTurn.Player;
List<Point> PiecesToConvert_Player = new List<Point>();
aiManager.GenerateAvailableMoves();
//
if (aiManager.PossibleToMove)
{
WhiteCantMove = false;
while (playerMove == null)
{
yield return null;
}
// Clears the debug log
// ClearLog();
Debug.Log("Player's turn.");
if (aiManager.AvailableMove(playerMove, ref PiecesToConvert_Player))
{
Debug.Log("Converting pieces from " + playerMove.X + "," + playerMove.Y);
yield return StartCoroutine(ConvertPieces(PiecesToConvert_Player));
}
else
{
StartCoroutine(uiManager.ShowMessage("Invalid move.", 1));
playerMove = null;
continue;
}
}
else
{
Debug.Log("No possible player moves.");
StartCoroutine(uiManager.ShowMessage("Player is unable to move.", 1));
WhiteCantMove = true;
}
// Wait 0.5 seconds before computer moves for a more natural feel
yield return new WaitForSeconds(0.5f);
// Check whether game over before computer turn
aiManager.CheckGameOver();
if (!aiManager.GameOver)
{
Debug.Log("Computer's turn.");
List<Point> PiecesToConvert_Computer = new List<Point>();
turn = GameTurn.Computer;
aiManager.GenerateAvailableMoves();
// If the computer can move, make the best possible move
if (aiManager.PossibleToMove)
{
BlackCantMove = false;
PiecesToConvert_Computer = aiManager.ComputerMove();
Debug.Log("Converting pieces from " + PiecesToConvert_Computer[0].X + "," + PiecesToConvert_Computer[0].Y);
yield return StartCoroutine(ConvertPieces(PiecesToConvert_Computer));
}
else
{
Debug.Log("No possible computer moves.");
StartCoroutine(uiManager.ShowMessage("Computer is unable to move.", 1));
BlackCantMove = true;
}
}
// Check whether game over before player turn
aiManager.CheckGameOver();
playerMove = null;
}
}
// once all units are placed for a specific player
void UnitsPlaced(UnitsPlacedEvent e)
{
// if it was the last player, move on to the game loop
if(curPlayer == activeSides.Length - 1){
curPlayer = 0;
curTurn = GameTurn.IssueOrders;
Events.instance.Raise(new GameStartEvent());
}else{
curPlayer++;
Events.instance.Raise(new PlaceUnitsEvent(players[curPlayer], activeSides[curPlayer]));
}
}
public static void SetupTurn(this Game game, GameTurn oldTurn)
{
game.SetNextPlayer();
var newTurn = new GameTurn { Game = game, TurnNumber = oldTurn.TurnNumber + 1, CurrentPlayer = game.CurrentPlayer };
game.Turns.Add(newTurn);
newTurn.StartTurn();
}
