/// <summary>
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnGameStarted(object sender, GameStartedEventArgs e)
{
OnlineManager.CurrentGame.PlayersReady.Clear();
OnlineManager.CurrentGame.CountdownStartTime = -1;
var view = (MultiplayerScreenView)View;
// view.PlayerList.Pool.ForEach(x => x.UpdateContent(x.Item, x.Index));
if (OnlineManager.CurrentGame.PlayersWithoutMap.Contains(OnlineManager.Self.OnlineUser.Id))
{
NotificationManager.Show(NotificationLevel.Warning, "Match started, but we don't have the map!");
return;
}
if (OnlineManager.CurrentGame.RefereeUserId == OnlineManager.Self.OnlineUser.Id)
{
NotificationManager.Show(NotificationLevel.Info, "Match started. Click to watch the match live on the web as a referee. ",
(o, args) => BrowserHelper.OpenURL($"https://quavergame.com/multiplayer/game/{OnlineManager.CurrentGame.GameId}"));
return;
}
MapManager.Selected.Value.Scores.Value = GetScoresFromMultiplayerUsers();
Exit(() =>
{
// Make sure map is absolutely correct before going to map loading screen.
view.Map.UpdateContent();
return(new MapLoadingScreen(MapManager.Selected.Value.Scores.Value));
});
}
void session_GameStarted(object sender, GameStartedEventArgs e)
{
foreach (Screen s in allScreens)
{
s.Visible = s.Name == "chatScreen";
}
}
private void _screen_GameStarted(object sender, GameStartedEventArgs e)
{
Components.Add(_gameplayPanel);
_engine.MusicPlayer.Play("game");
GhostlyGame.Instance.Configuration = _configuration;
GhostlyGame.Instance.OnGameStarted(e);
}
void Session_GameStarted(object sender, GameStartedEventArgs e)
{
if (!Guide.IsVisible)
{
Guide.BeginShowMessageBox("Multiplayer!", "You joined a network session that just started! Our sample ends here. Go wherever you want with your code now!", new string[] { "Great!" }, 0, MessageBoxIcon.None, toMPScreen, null);
}
}
public void OnGameStarted(object sender, GameStartedEventArgs e)
{
Console.WriteLine("Welcome to BATTLESHIP!");
Console.WriteLine("Are you ready to begin? Press any key to start.");
Console.ReadKey();
Console.Clear();
e.Board.Print(printer);
while (true)
{
Console.WriteLine("\nEnter position of a shot, eg. B3.");
WritePrompt();
var positionString = Console.ReadLine();
if (!UiPosition.TryParse(positionString, out var uiPosition))
{
HandleInvalidInput(e.Board);
continue;
}
e.Board.Shot(uiPosition.Position);
}
}
internal void dataService_GameStarted(object sender, GameStartedEventArgs e)
{
var handler = StartNewGameHandler;
if (handler != null)
{
handler(e.NewGameInfo);
}
}
/// <summary>
/// Handle the start of the game session.
/// </summary>
void networkSession_GameStarted(object sender, GameStartedEventArgs e)
{
// if we're the host, generate the data
if ((networkSession != null) && networkSession.IsHost && (world != null))
{
world.GenerateWorld();
}
}
internal void OnGameStarted(GameStartedEventArgs args)
{
ConfigurationLoader.LoadConfigurationFromString(Configuration, this);
Console.WriteLine("Game Started ");
if (GameStarted != null)
{
GameStarted(this, args);
}
}
private void OnGameStarted(object sender, Player player, GameStartedEventArgs eventargs)
{
var session = _activeSessions.FirstOrDefault(x => x.Key.Identity.Name == player.Name);
if (!session.Equals(default(KeyValuePair <ClaimsPrincipal, IWebSocketConnection>)))
{
var msg = Message.GameStarted(eventargs);
session.Value.Send(msg.ToJson());
}
}
public void OnGameStarted(object sender, GameStartedEventArgs args)
{
//_dispatcher.Invoke(
//new Action(() =>
//{
if (GameStarted != null)
{
GameStarted(sender, args);
}
//}), System.Windows.Threading.DispatcherPriority.Normal);
}
void GameStartedEventHandler(object sender, GameStartedEventArgs e)
{
log.Add("Game started!");
if (networkSession.IsHost)
{
command = "[You're the host; press Y to end the game and return to the lobby]";
}
else
{
command = "";
}
}
/// <summary>
/// Starts the game.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="GameStartedEventArgs"/> instance containing the event data.</param>
public void StartGame(object sender, GameStartedEventArgs args)
{
var game = new Game();
game.Init(args.GameId, args.Map, args.Opponent, args.StartGame, this.isGameOwner, this.gameType);
var gameStateViewModel = new GameStateViewModel(game);
GameManager.Current.StartGame(game, gameStateViewModel);
// Remove the current method from the GameStarted event
GameConsoleContext.Current.GameConsoleCallback.GameStarted -= this.StartGame;
this.SwitchWindowContent(gameStateViewModel);
Application.Current.MainWindow.Closing -= this.OnWindowClosing;
}
void SessionGameStartedHandler(object sender, GameStartedEventArgs e)
{
if (Session.IsHost)
{
GlobalState = new GameState();
GlobalState.Initialize(null);
}
else
{
GlobalState = new ClientState();
GlobalState.Initialize(null);
}
GlobalState.LoadContent(Content);
HookGameStateEvents();
}
private void ActiveGame_GameStarted(object sender, GameStartedEventArgs e)
{
string sznumformat = "digitstats.digit{0}{1}";
for (int i = 0; i < ActiveGame.ActiveNumber.Length; i++)
{
GamerProfile.Statistics[string.Format(sznumformat, ActiveGame.ActiveNumber[i], ".digitasked"), true].ValueInt++;
}
GamerProfile.Statistics["last.guess", true].Value = "";
if (!GamerProfile.FirstPlayed)
{
GamerProfile.Statistics.SetStatByName("first.playedtime", DateTime.Now);
GamerProfile.Statistics.SetStatByName("first.askedguess", ActiveGame.ActiveNumber);
GamerProfile.Statistics["first.difficult", true].ValueInt = ActiveGame.DifficultLevel;
}
GamerProfile.Statistics.SetStatByName("last.playedtime", DateTime.Now);
GamerProfile.Statistics.SetStatByName("last.askedguess", ActiveGame.ActiveNumber);
GamerProfile.Statistics["total.totalplayed", true].ValueInt++;
GamerProfile.Statistics["total.totalplayed.level" + ActiveGame.DifficultLevel, true].ValueInt++;
GamerProfile.Statistics["last.difficult", true].ValueInt = ActiveGame.DifficultLevel;
}
void GameStartedEventHandler(object sender, GameStartedEventArgs e)
{
if (hostSessionType == HostSessionType.Host)
{
int firstJugIndex = Global.rand.Next(0, Global.networkManager.networkSession.AllGamers.Count);
NetworkGamer firstJug = networkSession.AllGamers[firstJugIndex];
newJuggernaut(firstJug);
if (firstJug.IsLocal)
{
LocalPlayer player = firstJug.Tag as LocalPlayer;
player.setAsJuggernaut();
}
else
{
RemotePlayer player = firstJug.Tag as RemotePlayer;
player.setAsJuggernaut();
}
}
Global.gameState = Global.GameState.Playing;
Global.menusong.Stop();
Global.actionsong.Play();
}
void session_GameStarted(object sender, GameStartedEventArgs e)
{
}
/// <summary>
/// Játék indításának eseménykezelése.
/// </summary>
private void Model_GameStarted(object sender, GameStartedEventArgs e)
{
Refresh();
}
/// <summary>
/// Raised when the Session started
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnLiveSessionStarted(object sender, GameStartedEventArgs e)
{
_sessionState = SessionState.Starting;
OnStarting();
}
void StartGame(object sender, GameStartedEventArgs e)
{
NetworkManager netManager = new NetworkManager(netSession);
ScreenManager.AddScreen(new NetworkGameScreen(netSession.IsHost, netManager));
}
private static void OnGameStarted(object sender, GameStartedEventArgs e)
{
//if (Settings.Default.AutoSwitchTheme && ThemeManager.Instance.TryGetThemeByMod(e as IMod, out var theme))
// ThemeManager.Instance.Theme = theme;
}
public static void Session_GameStarted(object sender, GameStartedEventArgs args)
{
Console.WriteLine("The game has started.");
}
void session_GameStarted(object sender, GameStartedEventArgs p)
{
Console.Write("Game Started");
}
private void Controller_Started(object sender, GameStartedEventArgs e)
{
Started?.Invoke(this, e);
}
public void GameStartedEventHandler(object sender, GameStartedEventArgs e)
{
OnGameStarted();
}
/// <summary>
/// Handle the start of the game session.
/// </summary>
void networkSession_GameStarted(object sender, GameStartedEventArgs e)
{
// if we're the host, generate the data
if ((networkSession != null) && networkSession.IsHost && (world != null))
{
world.GenerateWorld();
}
}
public static Message GameStarted(GameStartedEventArgs e) => new Message(Server.MessageType.GameStarted, e);
private void GameStarted(object sender, GameStartedEventArgs e)
{
Console.WriteLine("start game!");
Game.TransitionState(Game.GameMap.Name == "tutorial" ? States.Tutorial : States.Play);
}
/// <summary>
/// Raises the <see cref="E:GameStarted" /> event.
/// </summary>
/// <param name="args">The <see cref="GameStartedEventArgs"/> instance containing the event data.</param>
private void OnGameStarted(GameStartedEventArgs args)
{
this.GameStarted(this, args);
}
/// <summary>
/// Starts the game with a specific id.
/// </summary>
/// <param name="gameId">The game identifier.</param>
/// <param name="map">The map.</param>
/// <param name="opponentName">Name of the opponent.</param>
/// <param name="visibleWindows">The visible windows.</param>
/// <param name="startGame">if set to <c>true</c> the player who receives this callback should start the game.</param>
public void StartGame(Guid gameId, Map map, string opponentName, IEnumerable <long> visibleWindows, bool startGame)
{
var args = new GameStartedEventArgs(gameId, map.ToEntity(visibleWindows), opponentName, startGame);
ThreadContext.InvokeOnUiThread(() => this.OnGameStarted(args));
}
void SessionGameStartedHandler(object sender, GameStartedEventArgs e)
{
if (Session.IsHost)
{
GlobalState = new GameState();
GlobalState.Initialize(null);
}
else
{
GlobalState = new ClientState();
GlobalState.Initialize(null);
}
GlobalState.LoadContent(Content);
HookGameStateEvents();
}
/// <summary>
/// Raised when the Session started
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnLiveSessionStarted(object sender, GameStartedEventArgs e)
{
_sessionState = SessionState.Starting;
OnStarting();
}
/// <summary>
/// Handles a game start event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void GameStartedEventHandler(object sender, GameStartedEventArgs e)
{
}
void session_GameStarted(object sender, GameStartedEventArgs e)
{
message = "Game Started";
}
private void Instance_GameStarted(object sender, GameStartedEventArgs e)
{
Dispatcher.Invoke(() => { board = new SudokuBoard(e.Board); sudokuBlock.Child = board; });
}
private void GameStarted(object sender, GameStartedEventArgs args)
{
}
void session_GameStarted(object sender, GameStartedEventArgs e)
{
message = "Game Started";
}
static void StartGame(object sender, GameStartedEventArgs e)
{
System.Windows.Forms.MessageBox.Show("Game Started");
}
private void OnGameStarted(object sender, GameStartedEventArgs e) => Close(false);
/// <summary>
/// Called when a game has started
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void session_GameStarted(object sender, GameStartedEventArgs e)
{
Console.WriteLine("Game has started...");
if (playerIndex == 0)
opponentIndex = 1;
else
opponentIndex = 0;
CreateLights();
CreateGameObjects();
CreateHUD();
//AddCollisionCallbackShips(ActiveGameObjects[0], ActiveGameObjects[1]);
HideMainMenu();
menuMusic.Stop(AudioStopOptions.Immediate);
countDownTimer = 300;
gameState = GameState.Count_Down;
string color;
if (playerIndex == 0)
{
color = "Red";
}
else
{
color = "Green";
}
gwinner = new FadingMessage("You are " + color, 1000);
gwinner.Bounds = new Rectangle(0, 0, 130, 30);
gwinner.Name = "gwinner";
gwinner.TextFont = hudFont;
if (playerIndex == 0)
{
color = "Red";
gwinner.TextColor = Color.Red;
}
else
{
color = "Green";
gwinner.TextColor = Color.Green;
}
winners.Enabled = true;
winners.Visible = true;
gwinner.Enabled = true;
gwinner.Visible = true;
winners.AddChild(gwinner);
gwinner.Transparency = 1.0f;
}
/// <summary>
/// Called on the computer of ALL PLAYERS when the game is started by the host.
/// </summary>
void CurrentSession_GameStarted(object sender, GameStartedEventArgs e)
{
//Non-host code
if (!StateManager.NetworkData.CurrentSession.LocalGamers[0].IsHost)
{
LoadingScreen lScr = StateManager.AllScreens[ScreenType.LoadingScreen.ToString()] as LoadingScreen;
lScr.Reset();
lScr.UserCallbackStartsTask = true;
lScr.ScreenFinished += new EventHandler(lScr_ScreenFinished);
lScr.LoadingText = "Waiting for\ninformation\nfrom host...";
StateManager.ScreenState = CoreTypes.ScreenType.LoadingScreen;
lScr.Callback(null);
StateManager.NetworkData.Component.NetworkInformationReceived += new EventHandler<Glib.XNA.NetworkLib.NetworkInformationReceivedEventArgs>(Component_NetworkInformationReceived);
//StateManager.ScreenState = CoreTypes.ScreenType.Game;
}
//All player code
StateManager.NetworkData.CurrentSession.GamerLeft += new EventHandler<GamerLeftEventArgs>(gameLeave);
foreach (NetworkGamer g in StateManager.NetworkData.CurrentSession.RemoteGamers)
{
StateManager.NetworkData.CurrentSession.LocalGamers[0].EnableSendVoice(g, false);
}
}
private void GameInstancerGameHasStarted(object sender, GameStartedEventArgs e)
{
Logger.WriteLog($"GameInstancer - Game has started. Time started: {e.time} under mode {MainConfig.CardModeMode}");
}
/// <summary>
/// Handles a game start event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void GameStartedEventHandler(object sender, GameStartedEventArgs e)
{
}
public void GameStartedEventHandler(object sender, GameStartedEventArgs e)
{
OnGameStarted();
}
void session_GameStarted(object sender, GameStartedEventArgs e)
{
sayMessage("Game Started");
}
void session_GameStarted(object sender, GameStartedEventArgs e)
{
foreach (Screen s in allScreens)
{
s.Visible = s.Name == "chatScreen";
}
}
