/// <summary> /// Helper for updating a locally controlled gamer. /// </summary> void UpdateLocalGamer(LocalNetworkGamer gamer, GameTime gameTime, bool sendPacketThisFrame) { // Look up what tank is associated with this local player. Tank tank = gamer.Tag as Tank; // Read the inputs controlling this tank. PlayerIndex playerIndex = gamer.SignedInGamer.PlayerIndex; Vector2 tankInput; Vector2 turretInput; ReadTankInputs(playerIndex, out tankInput, out turretInput); // Update the tank. tank.UpdateLocal(tankInput, turretInput); // Periodically send our state to everyone in the session. if (sendPacketThisFrame) { tank.WriteNetworkPacket(packetWriter, gameTime); gamer.SendData(packetWriter, SendDataOptions.InOrder); } }
/// <summary> /// This method only runs on the server. It reads tank inputs that /// have been sent over the network by a client machine, storing /// them for later use by the UpdateServer method. /// </summary> void ServerReadPlayerFromClients(LocalNetworkGamer gamer) { // Keep reading as long as incoming packets are available. while (gamer.IsDataAvailable) { NetworkGamer sender; sender = networkHelper.ReadServerData(gamer); // Read a single packet from the network. //gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { // Look up the tank associated with whoever sent this packet. Player remotePlayer = sender.Tag as Player; while (networkHelper.ServerPacketReader.PeekChar() != -1) { char header = networkHelper.ServerPacketReader.ReadChar(); switch (header) { case 'P': // Read the latest inputs controlling this tank. remotePlayer.Position = networkHelper.ServerPacketReader.ReadVector3(); remotePlayer.Rotation = networkHelper.ServerPacketReader.ReadSingle(); break; default: break; } } } } }
/// <summary> /// Helper for reading incoming network packets. /// </summary> void ReadIncomingPackets(LocalNetworkGamer gamer, GameTime gameTime) { // Keep reading as long as incoming packets are available. while (gamer.IsDataAvailable) { NetworkGamer sender; // Read a single packet from the network. gamer.ReceiveData(packetReader, out sender); // Discard packets sent by local gamers: we already know their state! if (sender.IsLocal) { continue; } // Look up the tank associated with whoever sent this packet. Tank tank = sender.Tag as Tank; // Estimate how long this packet took to arrive. TimeSpan latency = networkSession.SimulatedLatency + TimeSpan.FromTicks(sender.RoundtripTime.Ticks / 2); // Read the state of this tank from the network packet. tank.ReadNetworkPacket(packetReader, gameTime, latency, enablePrediction, enableSmoothing); } }
public void ServerReadInputFromClients(LocalNetworkGamer gamer) { while (gamer.IsDataAvailable) { NetworkGamer sender; // Read a single packet from the network. gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { // Look up the tank associated with whoever sent this packet. BasicOrb orb = sender.Tag as BasicOrb; Vector2 OrbPos = packetReader.ReadVector2(); orb.Position = new Vector3(OrbPos.X, orb.Position.Y, OrbPos.Y); orb.Rotation = new Vector3(0, packetReader.ReadSingle(), 0); orb.PrimaryWeaponQue = packetReader.ReadInt32(); orb.SecondaryWeaponQue = packetReader.ReadInt32(); orb.AbilityQue = packetReader.ReadInt32(); orb.GunCurrent = packetReader.ReadInt32(); orb.Abilty[0] = packetReader.ReadInt32(); orb.Team = packetReader.ReadInt32(); orb.Alpha = packetReader.ReadSingle(); orb.IsPhasing = packetReader.ReadBoolean(); orb.PhaseTimer = packetReader.ReadInt32(); orb.PhaseVelocity = packetReader.ReadVector3(); orb.MyController.MoveStickTrack = packetReader.ReadVector2(); } } }
/// <summary> /// Helper for reading incoming network packets. /// </summary> void ReadIncomingPackets(LocalNetworkGamer gamer) { // Keep reading as long as incoming packets are available. while (gamer.IsDataAvailable) { NetworkGamer sender; // Read a single packet from the network. gamer.ReceiveData(packetReader, out sender); // Discard packets sent by local gamers: we already know their state! if (sender.IsLocal) { continue; } // Look up the ship associated with whoever sent this packet. Racer racer = sender.Tag as Racer; // Read the state of this ship from the network packet. try { racer.shipPhysics.ShipPosition = packetReader.ReadVector3(); //tempShip.ShipYaw = packetReader.ReadSingle(); //tempShip.shipSpeed = packetReader.ReadSingle();//EndOfStreamException was unhandled. //roll?? } catch (EndOfStreamException e) { //Do something here returnToMenu(); } } }
void UpdateLocalGamer(LocalNetworkGamer gamer) { // Look up what tank is associated with this local player, // and read the latest user inputs for it. The server will // later use these values to control the tank movement. // Tank localTank = gamer.Tag as Tank; Ship localShip = gamer.Tag as Ship; // ReadTankInputs(localTank, gamer.SignedInGamer.PlayerIndex); // checkInput(); // Only send if we are not the server. There is no point sending packets // to ourselves, because we already know what they will contain! if (!networkSession.IsHost) { // Write our latest input state into a network packet. // packetWriter.Write(localTank.TankInput); // packetWriter.Write(localTank.TurretInput); // send messages across? // packetWriter.Write( // Send our input data to the server. // gamer.SendData(packetWriter, // SendDataOptions.InOrder, networkSession.Host); } }
private static void ReadPackets(LocalNetworkGamer gamer) { #if XBOX while (gamer.IsDataAvailable) { if (GameManager.GetLevel() == null) { NetworkGamer sender; gamer.ReceiveData(packetReader, out sender); Level NewLevel = new Level(false); BinaryReader b = new BinaryReader(packetReader.BaseStream); NewLevel.Read(b); b.Close(); GameManager.SetLevel(NewLevel); break; } } #endif #if WINDOWS while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(packetReader, out sender); ShouldSendLevel = true; } #endif }
public static void Disconnect() { if (session != null) { if (Main.netMode != 1) { if (session.SessionState == NetworkSessionState.Playing) { session.EndGame(); session.Update(); } clients.Clear(); for (int num = 7; num >= 0; num--) { playerSlots[num] = false; } } DisposeSession(); gamer = null; gamersWaitingForPlayerId.Clear(); gamersWaitingToSendSpawn.Clear(); gamersWaitingToSpawn.Clear(); for (int i = 0; i < 4; i++) { Main.ui[i].LeaveSession(); } } disconnect = false; hookEvents = false; stopSession = false; Main.netMode = 0; }
private void setupSinglePlayer() { if (Global.input.isAnyFirstPress(Buttons.A) && !Guide.IsVisible) { Guide.ShowSignIn(1, true); } else if (SignedInGamer.SignedInGamers.Count > 0 && Global.input.isAnyFirstPress(Buttons.Start)) { Global.numLocalGamers = (byte)SignedInGamer.SignedInGamers.Count; Global.networkManager.sessionType = NetworkSessionType.Local; if (Global.networkManager.createSession()) { timeInSinglePlayer = 0; Global.levelManager.currentLevel = 1; Global.levelManager.setupLevel(); LocalNetworkGamer gamer = Global.networkManager.networkSession.LocalGamers[0]; gamer.Tag = new LocalPlayer(Vector3.Zero, PlayerIndex.One, 1, gamer); Global.localPlayers.Add((LocalPlayer)gamer.Tag); Global.localPlayers[0].setAsJuggernaut(); Global.menusong.Stop(); Global.actionsong.Play(); Global.gameState = Global.GameState.SinglePlayerPlaying; } } else if (Global.input.isFirstPress(Buttons.B)) { Global.gameState = Global.GameState.Menu; } }
/// <summary> /// Helper for reading incoming network packets. /// </summary> void ReadIncomingPackets(LocalNetworkGamer gamer) { // Keep reading as long as incoming packets are available. while (gamer.IsDataAvailable) { NetworkGamer sender; // Read a single packet from the network. gamer.ReceiveData(packetReader, out sender); // Discard packets sent by local gamers: we already know their state! if (sender.IsLocal) { continue; } // Look up the tank associated with whoever sent this packet. Tank remoteTank = sender.Tag as Tank; // Read the state of this tank from the network packet. remoteTank.Position = packetReader.ReadVector2(); remoteTank.TankRotation = packetReader.ReadSingle(); remoteTank.TurretRotation = packetReader.ReadSingle(); } }
/// <summary> /// This method only runs on client machines. It reads /// tank position data that has been computed by the server. /// </summary> void ClientReadGameStateFromServer(LocalNetworkGamer gamer) { // Keep reading as long as incoming packets are available. while (gamer.IsDataAvailable) { NetworkGamer sender; // Read a single packet from the network. gamer.ReceiveData(packetReader, out sender); // If a player has recently joined or left, it is possible the server // might have sent information about a different number of players // than the client currently knows about. If so, we will be unable // to match up which data refers to which player. The solution is // just to ignore the packet for now: this situation will resolve // itself as soon as the client gets the join/leave notification. if (networkSession.AllGamers.Count != packetReader.ReadInt32()) { continue; } // This packet contains data about all the players in the session. foreach (NetworkGamer remoteGamer in networkSession.AllGamers) { NetworkPlayer ship = remoteGamer.Tag as NetworkPlayer; // Read the state of this tank from the network packet. ship.Position = packetReader.ReadVector2(); } } }
public LocalPlayer(Vector3 pos, PlayerIndex index, int localIndex, LocalNetworkGamer associatedGamer) : base(Global.game, pos, Vector3.Zero, Global.Constants.PLAYER_RADIUS) { localPlayerIndex = localIndex; timeSinceLastPacketSent = (localIndex - 1) * 2; score = 0; health = Global.Constants.MAX_HEALTH; isJuggernaut = false; jetpackDisabled = false; lastFiringTime = 0; jetFuel = Global.Constants.MAX_JET_FUEL; gunCoolDownModeNoShootingPermitted = false; sphere = new Sphere(Global.game, Global.Constants.DEFAULT_PLAYER_COLOR, pos); sphere.localScale = Matrix.CreateScale(Global.Constants.PLAYER_RADIUS); sphere.SetWireframe(1); Texture2D blankTexture = Global.game.Content.Load <Texture2D>(@"Textures\blankTexture"); cube = new Cube(blankTexture, Color.Black); cubeTransformation = Matrix.CreateScale(1, 1, gunLength) * Matrix.CreateTranslation(new Vector3(radius, 0, gunLength)); cube.wireFrame = false; cube.textured = false; gamer = associatedGamer; playerIndex = gamer.SignedInGamer.PlayerIndex; setupViewport(); }
public NetworkGamer ReadClientData(LocalNetworkGamer gamer) { NetworkGamer sender; // Read a single packet from the network gamer.ReceiveData(networkHelper.ClientPacketReader, out sender); return(sender); }
/// <summary> /// Read server data /// </summary> public NetworkGamer ReadServerData(LocalNetworkGamer gamer) { NetworkGamer sender; // Read a single packet from the network. gamer.ReceiveData(ServerPacketReader, out sender); return(sender); }
/// <summary> /// Creates a new instance /// </summary> /// <param name="playerInput"></param> internal LiveIdentifiedPlayer(PlayerInput playerInput, LocalNetworkGamer localNetworkGamer) : base(playerInput) { LiveGamer = localNetworkGamer; UniqueId = localNetworkGamer.Gamertag; DisplayName = localNetworkGamer.Gamertag; IsHost = localNetworkGamer.IsHost; }
/// <summary> /// Constructs a new lobby screen. /// </summary> public LobbyScreen(NetworkSession networkSession) { this.networkSession = networkSession; localGamer = networkSession.LocalGamers[0]; localGamer.SetLocalPlayerCount(0); TransitionOnTime = TimeSpan.FromSeconds(0.5); TransitionOffTime = TimeSpan.FromSeconds(0.5); }
private void UpdateLocalGamer(LocalNetworkGamer gamer) { // Only send if we are not the server. There is no point sending packets // to ourselves, because we already know what they will contain! if (!_networkSession.IsHost) { _packetWriter.Write((byte)NetworkMessageType.PlayerMove); } }
/// <summary> /// Send all server data /// </summary> public void SendServerData() { if (networkHelper.serverPacketWriter.Length > 0) { // Send the combined data to everyone in the session LocalNetworkGamer server = (LocalNetworkGamer)networkHelper.session.Host; server.SendData(networkHelper.serverPacketWriter, SendDataOptions.InOrder); } }
/// <summary> /// Send the local gamer's local player count to network. /// </summary> public static void SendToNetwork(this LocalNetworkGamer localGamer) { PacketWriter writer = new PacketWriter(); writer.Write(PacketHeader.LOBBY_DATA); writer.Write(localGamer.GetLocalPlayerCount()); // send in order, since old data must not overwrite the new data. localGamer.SendData(writer, SendDataOptions.InOrder); }
/// <summary> /// Handle MenuCancel inputs by clearing our ready status, or if it is /// already clear, prompting if the user wants to leave the session. /// </summary> void HandleMenuCancel(LocalNetworkGamer gamer) { if (gamer.IsReady) { gamer.IsReady = false; } else { NetworkSessionComponent.LeaveSessionFromGame(ScreenManager, audioManager); //audioHelper); } }
/// <summary> /// Handle MenuCancel inputs by clearing our ready status, or if it is /// already clear, prompting if the user wants to leave the session. /// </summary> void HandleMenuCancel(LocalNetworkGamer gamer) { if (gamer.IsReady) { gamer.IsReady = false; } else { NetworkSessionComponent.LeaveSession(ScreenManager); } }
/// <summary> /// Handle MenuCancel inputs by clearing our ready status, or if it is /// already clear, prompting if the user wants to leave the session. /// </summary> void HandleMenuCancel(LocalNetworkGamer gamer) { if (gamer.IsReady) { gamer.IsReady = false; } else { PlayerIndex playerIndex = gamer.SignedInGamer.PlayerIndex; NetworkSessionComponent.LeaveSession(ScreenManager, playerIndex); } }
/// <summary> /// This method only runs on client machines. It reads /// tank position data that has been computed by the server. /// </summary> void ClientReadGameStateFromServer(LocalNetworkGamer gamer) { // Keep reading as long as incoming packets are available. while (gamer.IsDataAvailable) { NetworkGamer sender; sender = networkHelper.ReadClientData(gamer); // Read a single packet from the network. //gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { while (networkHelper.ServerPacketReader.PeekChar() != -1) { char header = networkHelper.ServerPacketReader.ReadChar(); switch (header) { case 'P': // This packet contains data about all the players in the session. foreach (NetworkGamer remoteGamer in networkSession.AllGamers) { Player player = remoteGamer.Tag as Player; // Read the state of this tank from the network packet. player.Position = networkHelper.ClientPacketReader.ReadVector3(); player.Rotation = networkHelper.ClientPacketReader.ReadSingle(); } break; case 'N': // If a player has recently joined or left, it is possible the server // might have sent information about a different number of players // than the client currently knows about. If so, we will be unable // to match up which data refers to which player. The solution is // just to ignore the packet for now: this situation will resolve // itself as soon as the client gets the join/leave notification. if (networkSession.AllGamers.Count != networkHelper.ClientPacketReader.ReadInt32()) { continue; } break; default: break; } } } } }
public NetworkBehavior(Entity parent, string type, float timeBetween, int id) : base(parent) { this.Id = id; this.Type = type; _player = GameMain.CurrentSession.LocalGamers[0]; _timeBetween = _timeElapsed = timeBetween; GameMain.Connection.AddBehavior(this); _isUnique = false; }
protected virtual void UpdateLocalGamer(LocalNetworkGamer gamer, GameTime gameTime, bool sendPacketThisFrame) { Player p = gamer.Tag as Player; if (p != null) { //p.UpdateLocalPlayer(gameTime); // Periodically send our state to everyone in the session. if (sendPacketThisFrame) { p.WriteNetworkPacket(packetWriter, gameTime); gamer.SendData(packetWriter, SendDataOptions.InOrder); } } }
private List <PickupItem> ReadRemoteItems(LocalNetworkGamer gamer) { List <PickupItem> itemList = new List <PickupItem>(); int itemID; int ammoCount; int spawnID; int team; Vector2 itemPos; PickupItem item; while (gamer.IsDataAvailable) { if (_sender.IsHost) { itemID = _packetReader.ReadInt32(); itemPos = _packetReader.ReadVector2(); spawnID = _packetReader.ReadInt32(); item = getItem(itemID); if (item != null) { item.Position = itemPos; if (itemID > 10) { ammoCount = _packetReader.ReadInt32(); ((Weapon)item).AmmoCount = ammoCount; } else if (itemID == 1) { team = _packetReader.ReadInt32(); ((Flag)item).Team = team; } item.SpawnID = spawnID; itemList.Add(item); } else { break; } } else { break; } } return(itemList); }
protected void ProcessIncomingData(GameTime gameTime) { LocalNetworkGamer localGamer = networkSession.LocalGamers[0]; while (localGamer.IsDataAvailable) { NetworkGamer sender; localGamer.ReceiveData(reader, out sender); if (!sender.IsLocal) { MessageType type = (MessageType)reader.ReadInt32(); switch (type) { case MessageType.StartGame: StartGame(); break; case MessageType.EndGame: EndGame(); break; case MessageType.RejoinLobby: RejoinLobby(); break; case MessageType.UpdatePlayerPos: UpdateOtherPlayer(gameTime); break; case MessageType.RestartGame: RestartGame(); break; case MessageType.AddBomb: //packet reader will, after reading message type, receive a vector2 of position of bomb AddBomb(reader.ReadVector2()); break; case MessageType.HitBomb: //packet reader will, after reading message type, receive a int of index of bomb in bombList HitBomb(reader.ReadInt32()); break; } } } }
protected virtual void ReadIncomingPackets(LocalNetworkGamer gamer, GameTime gameTime) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal && sender.Tag != null) { Player p = sender.Tag as Player; TimeSpan latency = NetworkManager.Session.SimulatedLatency + TimeSpan.FromTicks(sender.RoundtripTime.Ticks / 2); // Read the state of this tank from the network packet. p.ReadNetworkPacket(packetReader, gameTime, latency); } } }
public void UpdateServer() { Int32 GameMode = -1; Int32 Map = -1; packetWriter.Write(game.GameOver); packetWriter.Write((Int32)(game.Winner != null ? game.Winner.ID : 0)); if (game.menus.IsInGame) { packetWriter.Write((Int32)game.gamemode); packetWriter.Write((Int32)game.map); } else { packetWriter.Write((Int32)(-1)); packetWriter.Write((Int32)(-1)); } packetWriter.Write(GameMode); packetWriter.Write(Map); foreach (BasicOrb orb in game.Orbs) { packetWriter.Write((bool)orb.relevent); } foreach (BasicOrb orb in game.Orbs) { if (orb.relevent) { orb.Write(packetWriter); } } if (game.gamemode == Game1.GameMode.KeepAway) { packetWriter.Write(game.flag.IsCarried); packetWriter.Write(game.flag.Position); packetWriter.Write(game.flag.carrier.ID); } LocalNetworkGamer server = (LocalNetworkGamer)networkSession.Host; server.SendData(packetWriter, SendDataOptions.InOrder); }
protected void Update_Start(GameTime gameTime) { //local gamers is a list of gamers LocalNetworkGamer localGamer = networkSession.LocalGamers[0]; if (networkSession.AllGamers.Count == 2) { if (Keyboard.GetState().IsKeyDown(Keys.Space)) { writer.Write((int)MessageType.StartGame); localGamer.SendData(writer, SendDataOptions.Reliable); StartGame(); } } ProcessIncomingData(gameTime); }