public void StartGame() { networkJobHandle.Complete(); StartGameMessage startMessage = new StartGameMessage { StartHP = 10 }; SendMessageToAll(startMessage); //enviroment data is setup serverDataHolder.GameSetup(); //everyone gets a rooms info message. for (int i = 0; i < connections.Length; i++) { RoomInfoMessage startRoomMessage = serverDataHolder.GetRoomMessage(i); SendMessage(startRoomMessage, connections[i]); } //turn event is called PlayerTurnMessage turnMessage = new PlayerTurnMessage { PlayerID = serverDataHolder.turnID }; SendMessageToAll(turnMessage); }
public void StartGame() { //first player StartGameMessage startGameMessage = new StartGameMessage() { playerData = NetworkUtilities.GetNetPlayerData(players[0]), opponentData = NetworkUtilities.GetNetPlayerData(players[1]) }; SendNetMessage(ref m_Driver, players[0].m_connenction, startGameMessage); //second player startGameMessage = new StartGameMessage() { playerData = NetworkUtilities.GetNetPlayerData(players[1]), opponentData = NetworkUtilities.GetNetPlayerData(players[0]) }; SendNetMessage(ref m_Driver, players[1].m_connenction, startGameMessage); currentPlayer = players.IndexOf(players.Find(x => x.guid == 0)); gameStarted = true; }
public void OnStartGameMessage(int deviceId, StartGameMessage startGameMessage) { var playerIndex = IndexOfPlayerWithDeviceId(deviceId); if (playerIndex < 0) { return; } if (_currentGameState == GameState.OnLobby) { for (var i = 0; i < _globalPlayers.Count; i++) { var globalPlayer = _globalPlayers[i]; if (!globalPlayer.LobbyPlayerData.IsReady) { return; } } StartGameWithCurrentPlayers(); } else if (_currentGameState == GameState.OnWrapUpScreen) { AirConsoleBridge.Instance.RequestToShowAds(() => { AirConsoleBridge.Instance.BroadcastLoadingScreen("LOADING"); HeadToTheLobby(); }); } }
public void UserApp_StartGameConversation_Test() { //--------------SET UP VARIABLES-------------------// RegistryData registryData = new RegistryData(); RegistryData.GameInfo gameInfo = new RegistryData.GameInfo(); TestAppWorker testAppWorker = new TestAppWorker(registryData); testAppWorker.StartTest(); var gameManager = new UdpCommunicator() { MinPort = 10000, MaxPort = 10999, Timeout = 1000, EnvelopeHandler = ProcessEnvelope1 }; gameManager.Start(); IPEndPoint registryEp = new IPEndPoint(IPAddress.Loopback, testAppWorker.commFacility.udpCommunicator.Port); IPEndPoint gameManagerEp = new IPEndPoint(IPAddress.Loopback, gameManager.Port); gameInfo.RemoteEndPoint = gameManagerEp; gameInfo.GameActive = false; Assert.IsTrue(registryData.AddGame(gameInfo)); StartGameMessage msg1 = new StartGameMessage(1); Envelope env1 = new Envelope(msg1, registryEp); //--------------TEST INITIAL SET UP AND SEND INITIAL MESSAGE-------------------// Assert.IsNull(testAppWorker.commFacility.convDictionary.GetConv(msg1.convId)); Assert.IsFalse(gameInfo.GameActive); gameManager.Send(env1); Thread.Sleep(1000); //--------------TEST OUTCOME-------------------// Assert.AreNotSame(msg1, _lastIncomingEnvelope1); // Make sure received message isn't null Assert.IsNotNull(_lastIncomingEnvelope1); Assert.IsNotNull(_lastIncomingEnvelope1.message); // Make sure received message is AckMessage Assert.AreEqual(msg1.convId, _lastIncomingEnvelope1.message.convId); AckMessage msg2 = _lastIncomingEnvelope1.message as AckMessage; Assert.IsNotNull(msg2); Assert.IsTrue(gameInfo.GameActive); Assert.IsNull(testAppWorker.commFacility.convDictionary.GetConv(msg1.convId)); //--------------CLOSE EVERYTHING-------------------// testAppWorker.StopTest(); gameManager.Stop(); }
/// <summary> /// Called when the countdown for starting the game finished. /// </summary> private void OnCountDownFinished() { List <Player> players = PlayersDict.Instance.Players; for (int i = 0; i < players.Count; i++) { players[i].StateCommunicator.lobbyReady = false; } instance = null; GlobalsDict.Instance.GameStateManagerObject.AddComponent <GameManager>(); int seed = selectedGameMode.randomSeed ? Random.Range(int.MinValue, int.MaxValue) : selectedGameMode.seed; if (RAGMatchmaker.Instance.IsReady && RAGMatchmaker.Instance.GetCurrentMatch() != null) { RAGMatchmaker.Instance.DestroyMatch(); } GameManager.OnStartNewGame(selectedGameMode, seed); StartGameMessage sgm = new StartGameMessage { levelSeed = seed, gameMode = selectedGameMode }; NetworkServer.SendToAll(sgm); GameManager.OnLoadNewLevel(); Destroy(this); }
private void HandleCharacterSelectionMessage(String address, AbstractMessage message) { CharacterSelectionMessage characterSelectionMessage = (CharacterSelectionMessage)message; Player currentPlayer = controller.GetPlayer(IPAddress.Parse(address)); currentPlayer.ClearCharacters(); foreach (String rootName in characterSelectionMessage.SelectedCharacters) { currentPlayer.AddCharacter(Bundle.Characters[rootName]); } foreach (Player player in controller.GetPlayers()) { if (player.GetCharacters().Count == 0) { controller.Server.SendData(currentPlayer.IPAddress, new WaitingOponentMessage()); return; } } BattleEngine.Initialize(controller.GetLocalPlayer(), controller.GetRemotePlayer()); StartGameMessage startGameMessage = new StartGameMessage(); serverStatus = ServerStatus.WaitingCharacterPosition; controller.Server.SendToAll(startGameMessage); }
// remote case public override void OnStartRemoteClient(StartGameMessage initialMessages) { base.OnStartRemoteClient(initialMessages); instance = this; clientPlayers = new CacheClientPlayers <TBPlayer>(); }
private void StartGame(ref DataStreamReader reader) { var startGameMessage = new StartGameMessage(); startGameMessage.DeserializeObject(ref reader); dataHolder.myData.hp = startGameMessage.StartHP; dataHolder.StartGame(); }
public void StartGame() { Debug.Log("PlayButton pressed, requesting game start"); StartGameMessage startGameMessage = new StartGameMessage(); PubSubServerInstance.Publish(startGameMessage); }
public void HandleStartGame(Message message) { StartGameMessage startGameMessage = (StartGameMessage)message; Debug.Log("Game Started"); Menu.Singleton.SetMenu(Menu.Menus.clientGame); Menu.Singleton.gameWindow.UpdateHP(startGameMessage.startHealth); Menu.Singleton.gameWindow.UpdateGold(0); }
public void UdpCommunicator_Multicast() { var commSender = new UdpCommunicator() { MinPort = 10000, MaxPort = 10999, Timeout = 1000, EnvelopeHandler = NoOp }; commSender.Start(); var commReciever = new UdpCommunicator() { MinPort = 5000, MaxPort = 5000, Timeout = 1000, EnvelopeHandler = ProcessEnvelope5 }; commReciever.Start(); Random rand = new Random(); short gameId = (short)rand.Next(1, 1000); // Note, we can't test multiple receivers on the same host (localhost), because the // port number has to be the same for all receivers // Have the receivers join a Group Multicast address var multiCastAddress = new IPAddress(new byte[] { 224, 1, 1, 2 }); commReciever.JoinMulticastGroup(multiCastAddress); // Send message to Group Multicast address var msg = new StartGameMessage(gameId); var targetEndPoint = new IPEndPoint(IPAddress.Loopback, 5000); var env = new Envelope(msg, targetEndPoint); commSender.Send(env); Thread.Sleep(100); Assert.AreNotSame(msg, _lastIncomingEnvelope5); Assert.IsNotNull(_lastIncomingEnvelope5); Assert.IsNotNull(_lastIncomingEnvelope5.message); Assert.AreEqual(msg.msgId, _lastIncomingEnvelope5.message.msgId); Assert.AreEqual(msg.convId, _lastIncomingEnvelope5.message.convId); StartGameMessage msg2 = _lastIncomingEnvelope5.message as StartGameMessage; Assert.IsNotNull(msg2); Assert.AreEqual(msg.GameId, msg2.GameId); commReciever.DropMulticastGroup(multiCastAddress); commReciever.Stop(); commSender.Stop(); }
// remote case public override void OnStartRemoteClient(StartGameMessage initialMessages) { base.OnStartRemoteClient(initialMessages); instance = this; var initialState = initialMessages.ReadInitialMessage <GameState>(); remoteMatch = new TurtleMatch(); remoteMatch.CreateFromInitialState(numRoles, onlineTurtlePrefab, initialState); }
public void TestStartGameMessage() { StartGameMessage origMessage = new StartGameMessage(1); byte[] bytes = origMessage.Encode(); StartGameMessage decodedMessage = StartGameMessage.Decode(bytes); Assert.AreEqual(origMessage.MessageType, 3, "Incorrect MessageType"); Assert.AreEqual(origMessage.MessageType, decodedMessage.MessageType, "MessageType did not match"); Assert.AreEqual(origMessage.GameId, decodedMessage.GameId, "GameId did not match"); }
private void SendStartGameMessageToAllUsers() { var avatars = _gameManager.GetAvatarList(); for (var i = 0; i < _gameManager.Users.Length; i++) { var user = _gameManager.Users[i]; var message = new StartGameMessage(i, avatars); user?.ClientSocket.SendMessage(message); } }
private Task RevealPlayers(StartGameMessage message) { MainCharacter.TrySendBounds(); return(Scene.QueueAction(() => { MainCharacter.ResizeTo(1, 1); foreach (var opponent in opponents) { opponent.ResizeTo(1, 1); } }).AsAwaitable()); }
public override void OnStartGame(StartGameMessage msg) { //register for callbacks playerData.handZone.OnCardAdded += OnPlayerCardAdded_Hand; playerData.boardZone.OnCardAdded += OnPlayerCardAdded_Board; playerData.boardZone.OnCardRemoved += OnPlayerCardRemoved_Board; opponentData.handZone.OnCardAdded += OnOpponentCardAdded_Hand; opponentData.boardZone.OnCardAdded += OnOpponentCardAdded_Board; base.OnStartGame(msg); }
public void SendStartGame() { int startHP = Random.Range(minPlayerHP, maxPlayerHP); var startGameMessage = new StartGameMessage { StartHP = (ushort)startHP }; foreach (Client c in server.ClientList) { server.SendMessage(startGameMessage, c.Connection); c.StartHP = startHP; } }
public virtual void OnStartGame(StartGameMessage msg) { if (Logger.LogPlayerStartGameMessages) { Debug.Log($"CLIENT:: Got start game message"); } //LOAD THE PLAYER STATS //payer LoadPlayerState(ref playerData, msg.playerData); //opponent LoadPlayerState(ref opponentData, msg.opponentData); }
private void OnStartGameMessage(MessageBase _msg, NetworkConnection _connection) { StartGameMessage startGameMessage = _msg as StartGameMessage; Player[] localPlayers = GameObject.FindObjectsOfType <Player>(); for (int i = 0; i < localPlayers.Length; i++) { if (localPlayers[i].playerData.guid == startGameMessage.playerData.playerGuid) { localPlayers[i].OnStartGame(startGameMessage); } } }
private void OnStartGameMessage(StartGameMessage startGameMessage) { LobbyLevel.Instance.Hide(); MusicManager.Instance.ChangeState(MusicManager.State.None); if (!Player.LocalPlayer || Player.LocalPlayer.isServer) { GameManager.gameMode.Init(startGameMessage.levelSeed); } else { startGameMessage.gameMode.Init(startGameMessage.levelSeed); GameManager.gameMode = startGameMessage.gameMode; } }
public INetworkMessage ReadJoingingAreaMessage(DataStreamReader reader, Message message) { switch (message.messageType) { // Read a NewPlayer message. case MessageType.NewPlayer: var newPlayerMessage = new NewPlayerMessage(message.id); newPlayerMessage.Deserialize(ref reader); return(newPlayerMessage); // Set your playedID and playerInfo. case MessageType.Welcome: var welcomeMessage = new WelcomeMessage(message.id); welcomeMessage.Deserialize(ref reader); playerID = welcomeMessage.playerID; playerInfo.color = welcomeMessage.color; Send(new SetNameMessage(MessageID.nextID, playerInfo.name)); return(welcomeMessage); // Read a PlayerLeft message. case MessageType.PlayerLeft: var playerLeftMessage = new PlayerMessage(message.id, message.messageType); playerLeftMessage.Deserialize(ref reader); return(playerLeftMessage); // Load Cave Quest and initialize the players stats. case MessageType.StartGame: var startGameMessage = new StartGameMessage(message.id); startGameMessage.Deserialize(ref reader); var caveQuestPlayer = gameObject.AddComponent <CaveQuestPlayer>(); SceneManager.LoadSceneAsync("Cave Quest").completed += (asyncOperation) => { caveQuestPlayer.Initialize(startGameMessage.startHP); }; return(startGameMessage); default: return(null); } }
// Server - tell the clients the game has started public void StartGame() { // Turn on level this.levelParent.SetActive(true); // Spawn flag this.SpawnFlag(); this.canvasManager.CloseMenu(); this.serverCam.SetActive(true); this.menuCameras[0].SetActive(false); this.menuCameras[1].SetActive(false); StartGameMessage msg = new StartGameMessage(); NetworkServer.SendToAll(CustomMsgType.StartGame, msg); }
private void HandleStartGameMessage(string address, AbstractMessage message) { StartGameMessage startGameMessage = (StartGameMessage)message; MapEngine.Initialize(IO.LoadMap("amude")); Camera.Initialize(MapEngine.GetInstance().Map); DefaultDirection charactersDirection; Point charactersPosition; AnimationType charactersAnimation; if (controller.IsServer) { Camera.GetInstance().FocusOn(new Point(0, MapEngine.GetInstance().Map.Height / 2)); charactersDirection = DefaultDirection.Right; charactersPosition = new Point(0, (MapEngine.GetInstance().Map.Height / 2) - 3); charactersAnimation = AnimationType.StaticRight; } else { Camera.GetInstance().FocusOn(new Point(MapEngine.GetInstance().Map.Width, MapEngine.GetInstance().Map.Height / 2)); charactersDirection = DefaultDirection.Left; charactersPosition = new Point(MapEngine.GetInstance().Map.Width - 1, (MapEngine.GetInstance().Map.Height / 2) - 3); charactersAnimation = AnimationType.StaticLeft; } controller.SupressUpdate(); foreach (Character character in controller.GetLocalPlayer().GetCharacters()) { character.ClearAnimatedMovements(); character.DefaultDirection = charactersDirection; character.MapLocation = charactersPosition; character.AddAnimatedMovement(charactersAnimation, charactersPosition); MapEngine.GetInstance().SetObject(character); charactersPosition.Y += 1; } ScreenManager.GetInstance().RemoveLastScreen(); ScreenManager.GetInstance().AddScreen(GameScreen.GetInstance()); controller.ReleaseUpdate(); }
public bool TrySendStartMessage() { #if !UNITY_EDITOR if (!validConnections) { return(false); } #endif // Send messages to each connection that the game is starting. var startGameMessage = new StartGameMessage(MessageID.nextID, CaveQuestPlayer.maxHealth); for (int i = 0; i < connections.Length; i++) { var connection = connections[i]; Send(connection, startGameMessage); } return(true); }
public StartGameResult StartGame( [SignalRTrigger] InvocationContext context, [SignalRParameter] StartGameMessage message, [CosmosDB("campaigns", "campaigns", ConnectionStringSetting = "CosmosDBConnection", Id = "{message.CampaignId}")] RemoteCampaign campaign, ILogger logger) { if (campaign == null) { return(StartGameResult.CampaignNotFound); } logger.LogInformation($"{context.ConnectionId}:{context.UserId} attempting to start game {message.CampaignId}"); if (message.CampaignSecret != campaign?.Secret.ToString()) { return(StartGameResult.Unauthorized); } logger.LogInformation($"{context.ConnectionId}:{context.UserId} authorized to start game {message.CampaignId}"); context.Claims.Add(OwnerClaim, "true"); return(StartGameResult.Success); }
private void JoinReconnect(NetworkConnection connection, Player oldPlayer) { NetworkServer.AddPlayerForConnection(connection, oldPlayer.gameObject); oldPlayer.playerId = connection.connectionId; StartGameMessage sgm = new StartGameMessage() { gameMode = GameManager.gameMode, levelSeed = GameManager.gameMode.seed }; connection.Send(sgm); GenerateLevelMessage glm = new GenerateLevelMessage() { levelNumber = GameManager.currentLevel, reconnecting = true, region = RegionDict.Instance.Region }; connection.Send(glm); }
void CheckEveryoneReady() { foreach (KeyValuePair <int, BasePlayer> entry in players) { if (entry.Value.ready == false) { return; } } // if all are ready, including the server (me), start the game. if (ready) { // notify all clients to start game. var startGameMessage = new StartGameMessage(); startGameMessage.level = level; NetworkServer.SendToAll(CustomNetMsg.StartGame, startGameMessage); GameStateManager.instance.setGlobalStateIndex(GameStateManager.STATE_PLAYING); SceneManager.LoadScene(1); SceneManager.sceneLoaded += OnSceneLoaded; } }
public void StartGame() { networkJobHandle.Complete(); StartGameMessage startGameMessage = new StartGameMessage() { StartHP = 10 }; GameHasStarted = true; GameObject go = new GameObject(); Grid grid = go.AddComponent <Grid>(); grid.gameObject.name = "Grid"; grid.GenerateGrid(); GameManager.Instance.CurrentGrid = grid; for (int i = 0; i < connections.Length; i++) { NetworkManager.SendMessage(networkDriver, startGameMessage, connections[i]); } PlayerManager.Instance.SortingPlayerList(); PlayerTurnMessage playerTurnMessage = new PlayerTurnMessage() { playerID = 0 }; for (int i = 0; i < PlayerManager.Instance.Players.Count; i++) { PlayerManager.Instance.Players[i].Health = 10; } for (int i = 0; i < connections.Length; i++) { NetworkManager.SendMessage(networkDriver, playerTurnMessage, connections[i]); } UIManager.Instance.DeleteLabels(); }
public void SetBeginHealth(MessageHeader arg0) { StartGameMessage startGame = arg0 as StartGameMessage; CurrentPlayer.Health = 10; }
/// <summary> /// Called when the game starts. /// </summary> /// <param name="msg">Start game message.</param> public override void OnStartGame(StartGameMessage msg) { base.OnStartGame(msg); humanPlayer = NetworkingUtils.GetHumanLocalPlayer(); }
private void StartGame(StartGameMessage obj) { UnitViewModelCollection.Clear(); UnitIdViewModelDictionary.Clear(); if (_backgroundWorker.IsBusy) throw new NotImplementedException("About to start background worker while it is still running"); _backgroundWorker.RunWorkerAsync(); }
public static void HandleStartGame(StartGameMessage message) { ObserverData.GameActive = true; }