// When the game state changes, update the status text to show
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (_gameInfo.State)
{
default:
Visible = false;
_text = null;
return;
case GameState.Paused:
_text = StringResources.GameStatusText_Paused;
break;
case GameState.Ended:
_text = StringResources.GameStatusText_Ended;
break;
}
Vector2 textSize = _textFont.MeasureString(_text);
_textLocation = _gameInfo.Bounds.Center - textSize / 2F;
_textArea = new Rectangle((int)_textLocation.X, (int)_textLocation.Y, (int)textSize.X, (int)textSize.Y);
Visible = true;
}
private void ProcessGameStateChanged(object sender, GameStateChangedEventArgs gameStateChangedEventArgs)
{
for (var i = 0; i < gameStateChangedEventArgs.CurrentState.Height; ++i)
{
for (var j = 0; j < gameStateChangedEventArgs.CurrentState.Width; ++j)
{
_fieldState[i, j] = gameStateChangedEventArgs.CurrentState.Field[i, j];
}
}
var lastMove = gameStateChangedEventArgs.CurrentState.LastMove;
var currentSign = gameStateChangedEventArgs.CurrentState.PlayerSign;
App.RunOnUiThread(async() => await _cellControls[lastMove.X, lastMove.Y].LoadPictureAsync(currentSign));
SwitchPlayer();
if (IsHumansTurn())
{
lock (_stateLock)
{
_waitingForTurn = true;
}
}
Thread.Sleep(50);
if (_botTesting)
{
_turnEvent.WaitOne();
_turnEvent.Reset();
}
_game.ReportStepProcessed();
}
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
// If a new game started, create new actors
case GameState.InProgress:
if (e.PreviousState < GameState.InProgress)
{
CreateActors();
}
Enabled = true;
Visible = true;
break;
case GameState.InMenu:
Enabled = false;
Visible = false;
break;
default:
Enabled = false;
Visible = true;
break;
}
}
void OnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (State)
{
case GameState.PAUSEMENU:
Time.timeScale = 0;
break;
case GameState.MENU:
if (e.PreviousState == GameState.PAUSEMENU ||
e.PreviousState == GameState.OVER ||
e.PreviousState == GameState.INTRO)
{
Application.LoadLevel("MenuScene");
}
break;
case GameState.PLAYING:
if (e.PreviousState != GameState.PAUSEMENU)
{
Application.LoadLevel("GameScene");
}
break;
}
if (State == GameState.PLAYING || State == GameState.MENU)
{
Time.timeScale = 1;
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
switch (sender.Id)
{
case PipesGame.GameId:
Statistics.pipesTime = sender.ElapsedTime;
break;
case CratesGame.GameId:
Statistics.craneTime = sender.ElapsedTime;
break;
case DynamiteGame.GameId:
Statistics.dynamiteTime = sender.ElapsedTime;
break;
case TriggersGame.GameId:
Statistics.triggerTime = sender.ElapsedTime;
break;
default:
throw new NotImplementedException("Game not handled: " + sender.Id);
}
if (sender is CratesGame && e.NewState == GameState.Initialized)
{
Statistics.craneCrateCount = ((CratesGame)sender).CrateCount;
}
}
private void GameStateChangedHandler(object sender, GameStateChangedEventArgs e)
{
setCurrentState(e.NewState.ToString());
AmongUsCapture.Settings.conInterface.WriteModuleTextColored("GameMemReader", Color.Lime,
$"State changed to {Color.Cyan.ToTextColor()}{e.NewState}");
//Program.conInterface.WriteModuleTextColored("GameMemReader", Color.Green, "State changed to " + e.NewState);
}
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
case GameState.InProgress:
if (e.PreviousState < GameState.InProgress)
{
// New game has started, reset scores
_gameInfo.ResetScores();
UpdateScores(0, 0);
}
// Only enable updating when a score limit has been set
Enabled = _settingsManager.Settings.Gameplay.HasScoreLimit &&
_gameInfo.LeftScore < _settingsManager.Settings.Gameplay.ScoreLimit &&
_gameInfo.RightScore < _settingsManager.Settings.Gameplay.ScoreLimit;
Visible = true;
break;
// Don't update or draw the score when in the main menu
case GameState.InMenu:
Enabled = false;
Visible = false;
break;
// In any other case, always draw the score
default:
Enabled = false;
Visible = true;
break;
}
}
public void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
//Debug.Log("TriggerView.OnGameStateChanged: " + state);
if (e.NewState == GameState.Initialized)
{
for (int i = 0; i < game.SequenceLength; i++)
{
UpdateLabel(game, lblCurrent, i, neutralPosition);
lblCurrent[i].gameObject.SetActive(true);
lblPrevious[i].gameObject.SetActive(true);
lblPrevious[i].text = "";
}
for (int i = game.SequenceLength; i < lblCurrent.Length; i++)
{
lblCurrent[i].gameObject.SetActive(false);
lblPrevious[i].gameObject.SetActive(false);
}
}
if (e.NewState == GameState.Running)
{
UpdateLabel(game, lblCurrent, game.CurrentSequenceIndex, currentPosition);
}
if (e.NewState == GameState.Aborted)
{
UpdateLabel(game, lblCurrent, game.CurrentSequenceIndex, neutralPosition);
}
}
private void ProcessGameStateChanged(object sender, GameStateChangedEventArgs gameStateChangedEventArgs)
{
LogMessage(LogLevel.Debug, $"Game state changed, step {gameStateChangedEventArgs.CurrentState.Step}");
for (var i = 0; i < gameStateChangedEventArgs.CurrentState.Height; ++i)
{
for (var j = 0; j < gameStateChangedEventArgs.CurrentState.Width; ++j)
{
_fieldState[i, j] = gameStateChangedEventArgs.CurrentState.Field[i, j];
}
}
var lastMove = gameStateChangedEventArgs.CurrentState.LastMove;
var currentSign = gameStateChangedEventArgs.CurrentState.PlayerSign;
App.RunOnUiThread(() => _cellControls[lastMove.X, lastMove.Y].LoadPicture(currentSign));
SwitchPlayer();
if (IsHumansTurn())
{
lock (_stateLock)
{
_waitingForTurn = true;
}
}
Thread.Sleep(50);
_game.ReportStepProcessed();
LogMessage(LogLevel.Debug, $"Step {gameStateChangedEventArgs.CurrentState.Step} processed");
}
private void GameStateChangedHandler(object sender, GameStateChangedEventArgs e)
{
if (e.NewState == GameState.DISCUSSION)
{
var alivePlayers = AmongUsReader.getInstance().GetAlivePlayers();
foreach (var player in alivePlayers)
{
//TODO: will act odd if a lot of people have the same name
var member = dataStore.members.First(member => member.amongUsName.Equals(player.Key, StringComparison.OrdinalIgnoreCase));
if (member != null)
{
muteUser(voiceChannel.Users.Where(x => x.Id == member.discordId).First(), false);
}
else
{
IEnumerable <SocketGuildUser> user = voiceChannel.Users.Where((x) =>
{
return(x.Username.Equals(player.Key, StringComparison.OrdinalIgnoreCase));
});
if (user.Count() == 1)
{
muteUser(user.First(), false);
}
}
}
}
else if (e.NewState == GameState.TASKS)
{
muteUsers(voiceChannel.Users, true);
}
else if (e.NewState == GameState.LOBBY)
{
muteUsers(voiceChannel.Users, false);
}
}
internal void OnGameStateChanged(GameStateChangedEventArgs args)
{
if (args.Modifier is TagChange t && (t.Tag == GameTag.STATE && t.Value == (int)State.COMPLETE))
{
InvokeGameEnd(args.State);
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (sender is PipesGame && e.NewState == GameState.Initialized)
{
if (!gameMasterActive)
{
SwitchToLights(Light.PipesLeft, Light.PipesRight);
}
}
if (sender is CratesGame && e.NewState == GameState.Initialized)
{
if (!gameMasterActive)
{
SwitchToLights(Light.CraneLeft, Light.CraneRight);
}
}
if (sender is DynamiteGame && e.NewState == GameState.Initialized)
{
if (!gameMasterActive)
{
SwitchToLights(Light.Dynamite);
}
}
if (sender is DynamiteGame && e.NewState == GameState.Completed)
{
// activate trigger LEDs to visually signal completion
Color[] colors = new Color[TriggersGame.LedCount];
for (int i = 0; i < TriggersGame.LedCount; i++)
{
colors[i] = LedColorNeutral;
}
Physical.SetLEDColors(colors);
}
if (sender is TriggersGame && e.NewState == GameState.Initialized)
{
if (!gameMasterActive)
{
SwitchToLights(Light.Trigger);
}
if (e.NewState == GameState.Initialized)
{
// activate LEDs
Color[] colors = new Color[TriggersGame.LedCount];
for (int i = 0; i < TriggersGame.LedCount; i++)
{
colors[i] = LedColorNeutral;
}
Physical.SetLEDColors(colors);
}
}
}
private void OnGameChanged(Player observerId, GameStateChangedEventArgs args)
{
if (args.CurrentState.GameState == GameState.Finished)
{
_activeGames.Remove(args.CurrentState.GameId);
}
GameStateChanged?.Invoke(this, observerId, args);
}
public void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (e.NewState == GameState.Initialized)
{
foreach (Camera cam in craneCameras)
{
cam.enabled = true;
}
}
}
public void OnGameStateChanged(object sender, Player player, GameStateChangedEventArgs eventArgs)
{
var session = _activeSessions.FirstOrDefault(x => x.Key.Identity.Name == player.Name);
if (!session.Equals(default(KeyValuePair <ClaimsPrincipal, IWebSocketConnection>)))
{
var msg = Message.GameStateChangedMessage(eventArgs);
session.Value.Send(msg.ToJson());
}
}
private void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
//Debug.Log("GCP.OnGameStateChanged: " + state + " / room active: " + roomRunning);
if (!roomRunning)
{
return;
}
UpdateUI(e.NewState);
}
private void GameStateChangedHandler(object sender, GameStateChangedEventArgs e)
{
setCurrentState(e.NewState.ToString());
while (DeadMessages.Count > 0)
{
AmongUsCapture.Settings.conInterface.WriteModuleTextColored("PlayerChange", Color.DarkKhaki, DeadMessages.Dequeue());
}
AmongUsCapture.Settings.conInterface.WriteModuleTextColored("GameMemReader", Color.Lime,
$"State changed to {Color.Cyan.ToTextColor()}{e.NewState}");
//Program.conInterface.WriteModuleTextColored("GameMemReader", Color.Green, "State changed to " + e.NewState);
}
// Only enable collision checking when a game is active
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
case GameState.InProgress:
Enabled = true;
break;
default:
Enabled = false;
break;
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (e.NewState == GameState.Completed)
{
Scores.SetScore(sender, CalculateScore(sender, true));
OnScoresUpdated?.Invoke(this, new ScoresUpdatedEventArgs(Scores));
}
else if (e.NewState == GameState.Aborted)
{
Scores.SetScore(sender, CalculateScore(sender, false));
OnScoresUpdated?.Invoke(this, new ScoresUpdatedEventArgs(Scores));
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
// this method is registered with the pipes game's OnGameStateChanged event.
if (sender != game)
{
return;
}
// stop all coroutines to prevent timing errors and stop sound playback to avoid overlapping audio
StopAllCoroutines();
audio.StopAllVoice();
audio.StopAllSounds();
switch (e.NewState)
{
case GameState.Initialized:
// if the game has been initialized, reset what we know about the subsystems from the last playthrough
solvedSubsystems = new Dictionary <int, bool>();
foreach (PipeSystem ps in game.PipeSystems())
{
solvedSubsystems[ps.Index] = false;
}
StartCoroutine(GameInitialized()); // then explain the rules
break;
case GameState.Running:
// if the game has been started, start the coroutine that keeps track of the player's progress
StartCoroutine(GameRunning(game));
break;
case GameState.Completed:
// if the game has been completed, handle the players' success
StartCoroutine(GameCompleted());
break;
case GameState.Aborted:
// if the game has been aborted (due to timeout), handle the player's failure or partial success
StartCoroutine(GameAborted());
break;
case GameState.Uninitialized:
case GameState.Error:
break;
default:
throw new NotImplementedException("GameState not handled: " + e.NewState);
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (e.NewState == GameState.Error)
{
audio.StopAllSounds();
audio.StopAllVoice();
audio.PlaySound(ErrorSound);
}
if (sender is DynamiteGame && e.NewState == GameState.Completed)
{
audio.PlaySound(33);
}
if (sender is PipesGame)
{
switch (e.NewState)
{
case GameState.Initialized:
int pipeSystemCount = 0;
foreach (PipeSystem ps in pipes.PipeSystems())
{
pipeSystemCount++;
}
solvedPipeSystems = new bool[pipeSystemCount];
drillVolume = 0f;
break;
case GameState.Running:
drillVolume = DrillVolumeStep;
audio.PlaySound(02, true, drillVolume);
break;
case GameState.Completed:
case GameState.Aborted:
audio.StopSound(11);
audio.StopSound(02);
break;
case GameState.Uninitialized:
case GameState.Error:
break;
default:
throw new NotImplementedException("Unhandled game state: " + e.NewState);
}
}
}
// Show or hide the main menu based on it's new state
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
case GameState.InMenu:
if (e.PreviousState != GameState.InMenu)
{
ShowMenu();
}
break;
default:
HideMenu();
break;
}
}
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
case GameState.InProgress:
if (e.PreviousState < GameState.InProgress)
{
_totalElapsedTime = TimeSpan.Zero;
}
Enabled = _settingsManager.Settings.Gameplay.HasTimeLimit && _totalElapsedTime < _settingsManager.Settings.Gameplay.TimeLimit;
break;
default:
Enabled = false;
break;
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (sender != game)
{
return;
}
StopAllCoroutines();
audio.StopAllVoice();
audio.StopAllSounds();
switch (e.NewState)
{
case GameState.Initialized:
firstButtonFound = false;
laterButtonWrong = false;
StartCoroutine(GameInitialized(game));
break;
case GameState.Running:
StartCoroutine(GameRunning(game));
break;
case GameState.Completed:
if (Room.State.CanTransition(RoomState.Completed)) // room needs to be manually completed
{
Ets.Room.Complete();
}
break;
case GameState.Aborted:
Ets.Room.Abort(); // room needs to be manually aborted
break;
case GameState.Uninitialized:
case GameState.Error:
break;
default:
throw new NotImplementedException("GameState not handled: " + e.NewState);
}
}
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (sender != game)
{
return;
}
StopAllCoroutines();
audio.StopAllVoice();
audio.StopAllSounds();
switch (e.NewState)
{
case GameState.Initialized:
lighting.SwitchAllLights(LightSetting.Off);
firstCratePickedUp = false;
firstCrateInDropzone = false;
StartCoroutine(GameInitialized());
break;
case GameState.Running:
StartCoroutine(GameRunning(game));
break;
case GameState.Completed:
StartCoroutine(GameCompleted());
break;
case GameState.Aborted:
StartCoroutine(GameAborted(game));
break;
case GameState.Uninitialized:
case GameState.Error:
break;
default:
throw new NotImplementedException("GameState not handled: " + e.NewState);
}
}
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
case GameState.InProgress:
if (e.PreviousState < GameState.InProgress)
{
// New game, reset speed
_gameInfo.Speed = _settingsManager.Settings.Gameplay.GameSpeed;
_totalElapsedTime = TimeSpan.Zero;
}
// Enable updating when the speed should auto increase
Enabled = _settingsManager.Settings.Gameplay.AutoIncreaseSpeed &&
_gameInfo.Speed >= SettingsConstants.GameSpeedMaxValue;
break;
default:
Enabled = false;
break;
}
}
/*
* public override void OnRoomStateChanged(EscapeRoom<IEtsInterface> sender, RoomStateChangedEventArgs e) {
* if (writer == null) {
* Debug.Assert(e.NewState == RoomState.Initialized || e.NewState == RoomState.Error, "writer null, but room not in expected state");
*
* startRecord();
* }
*
* record(new RoomStateTransition(e.OldState, e.NewState));
*
* switch (e.NewState) {
* case RoomState.Uninitialized:
* case RoomState.Running:
* break;
*
* case RoomState.Initialized:
* if (e.DiagnosticsReport.FailuresDetected)
* record(new TechnicalFailuresNotification(e.DiagnosticsReport));
* break;
*
* case RoomState.Completed:
* case RoomState.Aborted:
* endRecord();
* break;
*
* case RoomState.Error:
* record(new TechnicalFailuresNotification(e.DiagnosticsReport));
* endRecord();
* break;
*
* default:
* throw new NotImplementedException("Unhandled room state: " + e.NewState);
* }
* }
*/
public override void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
Record(new GameStateTransition(sender.Id, e.OldState, e.NewState));
switch (e.NewState)
{
case GameState.Initialized:
Record(new GameInitialization(sender.Id, sender.Difficulty));
break;
case GameState.Uninitialized:
case GameState.Running:
case GameState.Completed:
case GameState.Aborted:
case GameState.Error:
break;
default:
throw new NotImplementedException("Unhandled game state: " + e.NewState);
}
}
private void GameStateChangedHandler(object sender, GameStateChangedEventArgs e)
{
setCurrentState(e.NewState);
while (DeadMessages.Count > 0)
{
var playerToKill = DeadMessages.Dequeue();
if (context.Players.Contains(playerToKill))
{
playerToKill.Alive = false;
}
}
AmongUsCapture.Settings.conInterface.WriteModuleTextColored("GameMemReader", Color.Lime,
$"State changed to {Color.Cyan.ToTextColor()}{e.NewState}");
if (e.NewState == GameState.MENU)
{
setGameCode("");
Dispatcher.Invoke((Action)(() =>
{
context.GameState = e.NewState;
foreach (var player in context.Players)
{
player.Alive = true;
}
}));
}
else if (e.NewState == GameState.LOBBY)
{
Dispatcher.Invoke((Action)(() =>
{
context.GameState = e.NewState;
foreach (var player in context.Players)
{
player.Alive = true;
}
}));
}
//Program.conInterface.WriteModuleTextColored("GameMemReader", Color.Green, "State changed to " + e.NewState);
}
// When a new game is started, recalculate the positions of the blocks to draw on the screen and allow the background to be drawn
private void GameInfoOnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (e.NewState)
{
case GameState.InProgress:
if (e.PreviousState < GameState.InProgress)
{
CalculateVerticalBlocks();
CalculateHorizontalBlocks();
}
Visible = true;
break;
case GameState.InMenu:
Visible = false;
break;
default:
Visible = true;
break;
}
}
public void OnGameStateChanged(Game <IEtsInterface> sender, GameStateChangedEventArgs e)
{
if (e.NewState == GameState.Initialized)
{
for (int i = 0; i < lblHoles.Length; i++)
{
UpdateHoleLabel(i, -1);
}
for (int i = 0; i < lblInstructions.Length; i++)
{
Destroy(lblInstructions[i].gameObject);
}
lblInstructions = new Text[game.InstructionCount];
for (int i = 0; i < lblInstructions.Length; i++)
{
GameObject textGO = Instantiate(prefabInstructionText, pnlInstructions);
lblInstructions[i] = textGO.GetComponent <Text>();
lblInstructions[i].text = string.Format("({0}) {1}", i, game.GetInstructionText(i));
lblInstructions[i].color = ColorUnsolvedInstruction;
}
}
}
void OnStateChanged(object sender, GameStateChangedEventArgs e)
{
switch (State)
{
case GameState.PAUSEMENU:
Time.timeScale = 0;
break;
case GameState.MENU:
if (e.PreviousState == GameState.PAUSEMENU ||
e.PreviousState == GameState.OVER ||
e.PreviousState == GameState.INTRO)
{
Application.LoadLevel("MenuScene");
}
break;
case GameState.PLAYING:
if (e.PreviousState != GameState.PAUSEMENU)
Application.LoadLevel("GameScene");
break;
}
if (State == GameState.PLAYING || State == GameState.MENU)
Time.timeScale = 1;
}
private void ChangeState(object sender, GameStateChangedEventArgs e)
{
this.Refresh();
}
private void OnGameStateChangedEvent(object sender, GameStateChangedEventArgs e)
{
switch (e.newGameState)
{
case GameState.FirstPhase:
spawnEnabled = true;
break;
case GameState.Ended:
spawnEnabled = false;
KillAllEnemies();
break;
default:
spawnEnabled = false;
break;
}
}
private void OnGameStateChanged(object sender, GameStateChangedEventArgs e)
{
RaisePropertyChanged("SticksCount");
}
