private void Game_TurnFinished(object sender, TurnStartedEventArgs e)
{
//var game = sender as IGame;
if (e.CurrentPlayer == this)
{
TurnStarted?.Invoke(sender, e);
}
}
public void Update(GameFightTurnStartMessage message)
{
if (PlayedFighter?.ContextualId == message.Id)
{
IsOurTurn = true;
TurnStarted?.Invoke();
}
}
//<turnHandling>
public void StartTurn()
{
SetState(new StartTurn(this));
if (photonView.IsMine)
{
TurnStarted?.Invoke(this);
}
}
public void StartTurn()
{
_currentActionPoints = MaxActionPoints;
_yourTurn = true;
if (TurnStarted != null)
{
TurnStarted.Invoke();
}
}
/// <summary>
/// Starts turn.
/// </summary>
public void StartTurn()
{
Assert.IsFalse(IsTurnActive, "Attempted to start turn while it was already started.");
TurnStarted?.Invoke(this);
IsTurnActive = true;
_turnStartTime = Time.time;
_turnStartDate = Date;
}
public void Start()
{
m_ObjectQueue.Clear();
foreach (var sel in HexDatabase.Selectables)
{
m_ObjectQueue.AddLast(sel);
}
TurnStarted?.Invoke(CurrentTurnOwner);
}
IEnumerator TurnStart()
{
Units.ForEach(u => { u.OnTurnStart(); });
if (TurnStarted != null)
{
TurnStarted.Invoke(this, new EventArgs());
}
yield return(new WaitForSeconds(turnStartTime));
Players.Find(p => p.playerNumber.Equals(CurrentPlayerNumber)).Play(this);
//角色取出忽略层
Units.ForEach(u => u.gameObject.layer = 0);
}
protected internal override void Turn(int turn, Action <Intent> agent1, Action <Intent> agent2)
{
InvokeOnUIThread(() => TurnStarted?.Invoke(this, new EventArgs()));
List <Task> tasks = new List <Task>();
task1 = null;
task2 = null;
if (NeedIntent1 == null)
{
Console.WriteLine($"{nameof(NeedIntent1)}へのハンドラが登録されていません！！");
agent1(Intent.StayIntent);
}
else
{
task1 = new TaskCompletionSource <Intent>();
tasks.Add(task1.Task);
InvokeOnUIThread(() => NeedIntent1(this, new EventArgs()));
task1.Task.Wait();
}
if (NeedIntent2 == null)
{
Console.WriteLine($"{nameof(NeedIntent2)}へのハンドラが登録されていません！！");
agent2(Intent.StayIntent);
}
else
{
task2 = new TaskCompletionSource <Intent>();
tasks.Add(task2.Task);
InvokeOnUIThread(() => NeedIntent2(this, new EventArgs()));
task2.Task.Wait();
}
if (task1 != null)
{
agent1(task1.Task.Result);
}
if (task2 != null)
{
agent2(task2.Task.Result);
}
InvokeOnUIThread(() => TurnEnded?.Invoke(this, new EventArgs()));
}
public void EndTurn(Selectable sel)
{
if (CurrentTurnOwner != sel)
{
Debug.LogWarning($"{sel} Selectable is not turn over, thus cannot end turn for another object");
return;
}
TurnEnded?.Invoke(CurrentTurnOwner);
var first = CurrentTurnOwner;
m_ObjectQueue.RemoveFirst();
m_ObjectQueue.AddLast(first);
TurnStarted?.Invoke(CurrentTurnOwner);
}
public void Start(GamePlayer gamePlayer)
{
Game.Active.GamePlayer = gamePlayer;
Game.Active.Turn.IsDone = false;
Game.Active.Reset();
UIManager.Instance.UpdateActivePlayerUI();
TurnStarted?.Invoke(gamePlayer);
if (Game.Active.Phase.Number != 0)
{
return;
}
if (Game.Active.GamePlayer.Characters.Any(c => !c.IsOnMap))
{
UIManager.Instance.ForcePlacingChampions = true;
}
}
IEnumerator TurnStart()
{
Units.ForEach(u => { u.OnTurnStart(); });
if (TurnStarted != null)
{
TurnStarted.Invoke(this, new EventArgs());
}
yield return(new WaitForSeconds(turnStartTime));
//角色加入忽略层
Units.ForEach(u => u.gameObject.layer = 2);
//剧情对话
yield return(StartCoroutine(DialogManager.GetInstance().PlayDialog(roundNumber, CurrentPlayerNumber)));
//角色取出忽略层
Units.ForEach(u => u.gameObject.layer = 0);
//这里接一个EndTurn，目的应该是调用里面的Play，来让当前Player行动。
EndTurn();
}
private void HandleGameFightTurnStartPlayingMessage(IAccount account, GameFightTurnStartPlayingMessage message)
{
TurnStarted?.Invoke();
}
public void Start()
{
TurnStarted?.Invoke(this, EventArgs.Empty);
NewPlayerTurn();
}
public void DoTurnStartActions()
{
StructureManager.DoTurnStartActions();
TurnStarted?.Invoke(this);
}
internal void When(TurnStarted @event)
{
ActivePlayer = @event.Deployments.Owner;
ArmyBuffer = @event.Deployments;
Phase = GamePhase.Deploy;
}
private void OnMessageRecieved(MessageType messageType, string message)
{
switch (messageType)
{
case MessageType.StartGame:
{
GameStarted?.Invoke();
break;
}
case MessageType.PlayerType:
{
PlayerType playerType = (PlayerType)Enum.Parse(typeof(PlayerType), message);
PlayerTypeRecieved?.Invoke(playerType);
break;
}
case MessageType.Step:
{
string[] moves = message.Split(',');
BoardIndex from = BoardIndex.Parse(moves[0]);
BoardIndex to = BoardIndex.Parse(moves[1]);
MoveRecieved?.Invoke(from, to);
break;
}
case MessageType.TurnEnd:
{
TurnEnded?.Invoke();
break;
}
case MessageType.StartTurn:
{
PlayerType playerType = (PlayerType)Enum.Parse(typeof(PlayerType), message);
TurnStarted?.Invoke(playerType);
break;
}
case MessageType.QueenAppeared:
{
BoardIndex where = BoardIndex.Parse(message);
QueenAppeared?.Invoke(where);
break;
}
case MessageType.Result:
{
PlayerType winner = (PlayerType)Enum.Parse(typeof(PlayerType), message);
ResultRecieved?.Invoke(winner);
break;
}
case MessageType.Name:
{
OpponentName?.Invoke(message);
break;
}
case MessageType.TextMessage:
{
TextMessageRecieved?.Invoke(message);
break;
}
}
}
private async Task OnTurnStarted(TurnStarted x, CancellationToken ct)
{
System.Diagnostics.Debug.WriteLine("OnTurnStarted " + Thread.CurrentThread.ManagedThreadId);
System.Diagnostics.Debug.WriteLine($"---- ターン{x.Turn} ----");
}
internal void StartTurn()
{
TurnStarted?.Invoke(this);
}
protected virtual void OnTurnStarted() {
TurnStarted?.Invoke(this);
}
private static void GotMessage(object state)
{
NetIncomingMessage incomingMessage;
while ((incomingMessage = Client.ReadMessage()) != null)
{
// handle incoming message
switch (incomingMessage.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
var text = incomingMessage.ReadString();
Console.WriteLine($"{incomingMessage.MessageType}: {text}");
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)incomingMessage.ReadByte();
var reason = incomingMessage.ReadString();
Console.WriteLine($"{status}, Reason: {reason}");
switch (status)
{
case NetConnectionStatus.Connected:
Connected?.Invoke(null, EventArgs.Empty);
break;
case NetConnectionStatus.Disconnected:
Disconnected?.Invoke(null, EventArgs.Empty);
break;
}
break;
case NetIncomingMessageType.Data:
var messageType = (PacketType)incomingMessage.ReadInt16();
switch (messageType)
{
case PacketType.SPacketJoinRoom:
JoinRoomResponse?.Invoke(null, incomingMessage.ReadStruct <SPacketJoinRoom>());
break;
case PacketType.SPacketCreateRoom:
CreateRoomResponse?.Invoke(null, incomingMessage.ReadStruct <SPacketCreateRoom>());
break;
case PacketType.SPacketSyncRoom:
{
var packet = incomingMessage.ReadClass <SPacketSyncRoom>();
if (Room == null || Room.Id != packet.RoomId)
{
Room = new Room(packet.RoomId);
}
Player = packet.Players[packet.YourPlayer];
Room.Players.Clear();
Room.Players.AddRange(packet.Players);
Room.Board.Clear();
Room.Board.AddRange(packet.Board);
if (Room.CurrentPlayer != Player.Id && packet.CurrentPlayer == Player.Id)
{
TurnStarted?.Invoke(null, EventArgs.Empty);
}
Room.CurrentPlayer = packet.CurrentPlayer;
SyncRoom?.Invoke(null, packet);
break;
}
case PacketType.SPacketFloatingPiece:
FloatingPiece?.Invoke(null, incomingMessage.ReadStruct <SPacketFloatingPiece>());
break;
}
break;
default:
Console.WriteLine($"Unhandled type: {incomingMessage.MessageType} {incomingMessage.LengthBytes} bytes");
break;
}
Client.FlushSendQueue();
Client.Recycle(incomingMessage);
}
}
public void StartTurn()
{
if (_gameplayManager.IsGameEnded)
{
return;
}
CurrentTurn++;
_gameplayManager.CurrentTurnPlayer.Turn++;
if (_dataManager.CachedUserLocalData.Tutorial && !_tutorialManager.IsTutorial)
{
Debug.Log("_dataManager.CachedUserLocalData.Tutorial = " + _dataManager.CachedUserLocalData.Tutorial);
Debug.Log("_tutorialManager.IsTutorial = " + _tutorialManager.IsTutorial);
_tutorialManager.StartTutorial();
}
_uiManager.GetPage <GameplayPage>().SetEndTurnButtonStatus(_gameplayManager.IsLocalPlayerTurn());
UpdatePositionOfCardsInOpponentHand();
_playerController.IsActive = _gameplayManager.IsLocalPlayerTurn();
if (_gameplayManager.IsLocalPlayerTurn())
{
List <BoardUnit> creatures = new List <BoardUnit>();
foreach (BoardUnit card in PlayerBoardCards)
{
if (_playerController == null || !card.GameObject)
{
creatures.Add(card);
continue;
}
card.OnStartTurn();
}
foreach (BoardUnit item in creatures)
{
PlayerBoardCards.Remove(item);
}
creatures.Clear();
foreach (BoardUnit card in PlayerBoardCards)
{
card.SetHighlightingEnabled(true);
}
}
else
{
foreach (BoardUnit card in OpponentBoardCards)
{
card.OnStartTurn();
}
foreach (BoardCard card in PlayerHandCards)
{
card.SetHighlightingEnabled(false);
}
foreach (BoardUnit card in PlayerBoardCards)
{
card.SetHighlightingEnabled(false);
}
}
_gameplayManager.CurrentPlayer.InvokeTurnStarted();
_gameplayManager.OpponentPlayer.InvokeTurnStarted();
_playerController.UpdateHandCardsHighlight();
_tutorialManager.ReportAction(Enumerators.TutorialReportAction.START_TURN);
TurnStarted?.Invoke();
}
public void StartTurn()
{
_currentController?.StartTurn(CurrentUnit);
TurnStarted?.Invoke(CurrentUnit);
}
