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; }
private static void HandleData(LocalNetworkGamer aGamer, GameTime gameTime) { while (aGamer.IsDataAvailable) { NetworkGamer sender; aGamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { Console.WriteLine("Button: " + packetReader.ReadChar() + " pressed by player: " + aGamer.Gamertag); } } }
private void ServerRead(LocalNetworkGamer gamer) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { QueueHdr hdr; hdr.pHdr = null; int type = packetReader.ReadInt32(); HeaderType enumType = (HeaderType)type; hdr.type = enumType; switch (enumType) { default: case HeaderType.Location: LocationHdr lHdr; lHdr.goIndex = packetReader.ReadInt32(); lHdr.position = packetReader.ReadVector2(); lHdr.rotation = packetReader.ReadSingle(); lHdr.networked = true; hdr.pHdr = lHdr; break; case HeaderType.Input: InputHdr iHdr; iHdr.networked = false; int iType = packetReader.ReadInt32(); int pID = packetReader.ReadInt32(); iHdr.input = (InputType)iType; iHdr.player = (PlayerID)pID; if (iHdr.input == InputType.Collision) { ColHdr cHdr; cHdr.goID1 = packetReader.ReadInt32(); cHdr.goID2 = packetReader.ReadInt32(); cHdr.pos = packetReader.ReadVector2(); iHdr.colInfo = cHdr; } else { iHdr.colInfo = null; } hdr.pHdr = iHdr; break; } Debug.Assert(hdr.pHdr != null); this.inQueue.Enqueue(hdr); } } }
//recieve data from network void RecieveRemoteData(LocalNetworkGamer gamer, GameTime gameTime) { //System.Diagnostics.Debug.WriteLine("gamer: " + gamer.IsDataAvailable); while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { if (TheBattlefield.BossMode) { TheBattlefield.Zihao.acceleration = packetReader.ReadVector2(); TheBattlefield.Zihao.Position = packetReader.ReadVector2(); TheBattlefield.Zihao.Rotation = (float)packetReader.ReadDouble(); bool firing = false; firing = packetReader.ReadBoolean(); if (firing) { RNSEB.Input.input["PlayerFire1"] = true; } firing = packetReader.ReadBoolean(); if (firing) { RNSEB.Input.input["PlayerFire2"] = true; } } else { TheBattlefield.Notus.acceleration = packetReader.ReadVector2(); TheBattlefield.Notus.Position = packetReader.ReadVector2(); bool firing = false; firing = packetReader.ReadBoolean(); if (firing) { RNSEB.Input.input["BossFire1"] = true; } firing = packetReader.ReadBoolean(); if (firing) { RNSEB.Input.input["BossFire2"] = true; } } } /*if (!sender.IsLocal && ((string)gamer.Tag =="Player")) { HenryBoss remoteboss = gamer.Tag as HenryBoss; remoteboss.acceleration = packetReader.ReadVector2(); remoteboss.Position = packetReader.ReadVector2(); remoteboss.Update(gameTime); } else if (!sender.IsLocal) { HenryPlayer remoteplayer = gamer.Tag as HenryPlayer; remoteplayer.acceleration = packetReader.ReadVector2(); remoteplayer.Position = packetReader.ReadVector2(); remoteplayer.Update(gameTime); }*/ } }
/// <summary> /// This method only runs on client machines. It reads /// tank position data that has been computed by the server. /// </summary> private void RemotesReadPacketsFromServer(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); CurrentMapSelection = packetReader.ReadInt16(); foreach (Being guy in Enemies) { guy.camera.Position = packetReader.ReadVector3(); guy.camera.HeadingDegrees = (float)packetReader.ReadDouble(); guy.camera.PitchDegrees = (float)packetReader.ReadDouble(); guy.CurrentGun = packetReader.ReadInt16(); guy.CurrentHealth = packetReader.ReadInt16(); } int numberOfStars = packetReader.ReadInt16(); for (int i = 0; i < numberOfStars; i++) { Stars[0].Pos = packetReader.ReadVector3(); Stars[0].Rotation = (float)packetReader.ReadDouble(); } HappyBarPower = packetReader.ReadInt16(); int numberOfParticles = packetReader.ReadInt16(); ParticleList.list.Clear(); for (int i = 0; i < numberOfParticles; i++) { Vector3 pos = packetReader.ReadVector3(); ParticleList.AddParticle(pos, Vector3.Zero, Crosshair); } RemotePlayers[0].camera.Position = packetReader.ReadVector3(); RemotePlayers[0].camera.HeadingDegrees = (float)packetReader.ReadDouble(); RemotePlayers[0].camera.PitchDegrees = (float)packetReader.ReadDouble(); RemotePlayers[0].CurrentGun = packetReader.ReadInt16(); RemotePlayers[0].CurrentHealth = packetReader.ReadInt16(); //} } }
private static void UpdateServerStateFromClients(LocalNetworkGamer gamer) { while(gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(Storage.PacketReader, out sender); if(sender.IsLocal) { continue; } while(Storage.PacketReader.Position < Storage.PacketReader.Length) { if(!FindNextValidPacket()) { continue; } var type = (MessageType)Storage.PacketReader.ReadInt32(); byte gamerId = Storage.PacketReader.ReadByte(); var player = sender.Tag as Player; Particle particle; LocalNetworkGamer server; switch(type) { case MessageType.UpdatePlayerState: ProcessUpdatePlayerStateMessage(player); break; case MessageType.UpdatePlayerMenuState: ProcessUpdatePlayerMenuStateMessage(player); break; case MessageType.UpdatePlayerClass: ProcessUpdatePlayerClassMessage(player); SendUpdatePlayerClassMessage(gamer.Tag as Player, gamerId, false); server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.Reliable); break; case MessageType.UpdatePlayerTeam: ProcessUpdatePlayerTeamMessage(player); SendUpdatePlayerTeamMessage(gamer.Tag as Player, gamerId, false); server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.Reliable); break; case MessageType.PlaySound: var soundName = ProcessPlaySoundMessage(player); SendPlaySoundMessage(gamer.Tag as Player, soundName, gamerId, false); server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.Reliable); break; case MessageType.Stun: var stunInfo = ProcessStunMessage(player); if(stunInfo == null) { break; } var stunId = stunInfo.Item1; var stunEnergy = stunInfo.Item2; foreach(var clientGamer in Storage.NetworkSession.AllGamers) { var clientPlayer = clientGamer.Tag as Player; if(clientGamer.Id == stunId) { SendStunMessage(gamer.Tag as Player, clientPlayer, stunEnergy, gamerId, false); } } server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.Reliable); break; case MessageType.ActivateTool: var aInfo = ProcessActivateToolMessage(player); SendActivateToolMessage(gamer.Tag as Player, aInfo.Slot, aInfo.Type, aInfo.State, aInfo.PropertyName, aInfo.PropertyValue, gamerId, false); server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.Reliable); break; case MessageType.CreateSand: particle = ProcessCreateSandMessage(player); SendCreateSandMessage(gamer.Tag as Player, particle, gamerId, false); server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.Reliable); break; case MessageType.UpdateSand: particle = ProcessUpdateSandMessage(player); SendUpdateSandMessage(gamer.Tag as Player, particle, gamerId, false); server = (LocalNetworkGamer)Storage.NetworkSession.Host; server.SendData(Storage.PacketWriter, SendDataOptions.None); break; case MessageType.ChangeWinState: Console.WriteLine("server got a changewinstate message, seems wrong."); break; case MessageType.UpdateScore: Console.WriteLine("server got a updatescore message, seems wrong."); break; case MessageType.ChangeTutorialLevel: Console.WriteLine("server got a changetutoriallevel message, seems wrong."); break; default: throw new ArgumentOutOfRangeException(); } } } }
/// <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); } }
/// <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); // This packet contains data about all the players in the session. // We keep reading from it until we have processed all the data. while (packetReader.Position < packetReader.Length) { // Read the state of one tank from the network packet. byte gamerId = packetReader.ReadByte(); Vector2 position = packetReader.ReadVector2(); float tankRotation = packetReader.ReadSingle(); float turretRotation = packetReader.ReadSingle(); // Look up which gamer this state refers to. NetworkGamer remoteGamer = networkSession.FindGamerById(gamerId); // This might come back null if the gamer left the session after // the host sent the packet but before we received it. If that // happens, we just ignore the data for this gamer. if (remoteGamer != null) { // Update our local state with data from the network packet. Tank tank = remoteGamer.Tag as Tank; tank.Position = position; tank.TankRotation = tankRotation; tank.TurretRotation = turretRotation; } } } }
private void ReadIncomingPackets(LocalNetworkGamer gamer) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(_packetReader, out sender); if (sender.IsLocal) continue; int newTeam = _packetReader.ReadByte(); sender.Tag = newTeam; } }
void ReceiveNetworkData(LocalNetworkGamer gamer, GameTime gameTime) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(packetReader, out sender); if (!sender.IsLocal) { Player player = sender.Tag as Player; int money = packetReader.ReadInt32(); int lives = packetReader.ReadInt32(); player.Money = money; player.Lives = lives; int towers = packetReader.ReadInt32(); if (player.Towers.Count != towers) { Vector2 position = packetReader.ReadVector2(); player.NewTowerType = "ArrowTower"; player.AddMultiplayerTower(position); } int enemies = packetReader.ReadInt32(); if (player.waveManager.CurrentWave.Enemies.Count == enemies) { foreach (Enemy e in player.waveManager.CurrentWave.Enemies) { Vector2 position = packetReader.ReadVector2(); e.Position = position; } } player.Update(gameTime, false); } } }
/// <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 ServerReadInputFromClients(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 (!sender.IsLocal) { // Look up the tank associated with whoever sent this packet. NetworkPlayer remotePlayer = sender.Tag as NetworkPlayer; // Read the latest inputs controlling this tank. remotePlayer.Position = packetReader.ReadVector2(); } } }
/// <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(); } } }
/// <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 ServerReadInputFromClients(LocalNetworkGamer gamer, GameTime gameTime) { //keep reading as long as incoming packets are available while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(_packetReader, out sender); if (!sender.IsLocal) { //Look up the player associated with whoever sent this packet. Player remotePlayer = sender.Tag as Player; remotePlayer.ReadInputFromClient(_packetReader, gameTime); } } }
void ClientReadGameStateFromServer(LocalNetworkGamer gamer, GameTime gameTime) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(_packetReader, out sender); TimeSpan latency = _networkSession.SimulatedLatency + TimeSpan.FromTicks(sender.RoundtripTime.Ticks / 2); float packetSendTime = _packetReader.ReadSingle(); //Vector3 diskPosition = _packetReader.ReadVector3(); //_disk.setPosition(diskPosition); _disk.ReadNetworkPacket(_packetReader, gameTime, latency, _enablePrediction, _enableSmoothing, packetSendTime); _disk.UpdateRemote(_framesBetweenPackets, _enablePrediction, gameTime); while (_packetReader.Position < _packetReader.Length) { //Read the state of one Player from the network packet byte gamerId = _packetReader.ReadByte(); NetworkGamer remoteGamer = _networkSession.FindGamerById(gamerId); if (remoteGamer != null) { Player player = remoteGamer.Tag as Player; player.ReadNetworkPacket(_packetReader, gameTime, latency, _enablePrediction, _enableSmoothing, packetSendTime); player.UpdateRemote(_framesBetweenPackets, _enablePrediction, gameTime); if (remoteGamer.IsLocal) { player.updateCameraPosition(); player.setArrowPlayer(); } } } } }
/// <summary> /// Helper for reading incoming network packets. /// </summary> protected 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; GamePacketType type = (GamePacketType)packetReader.ReadInt32(); switch (type) { case GamePacketType.PlayerShip: ReadPlayerShipData(gamer); break; default: //Do nothing, unknown GamePacketType break; } } }
void ClientReadGameStateFromServer(LocalNetworkGamer gamer) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(network.PacketReader, out sender); foreach (NetworkGamer remoteGamer in network.Session.AllGamers) { Tank t = remoteGamer.Tag as Tank; t.Position = network.PacketReader.ReadVector2(); t.Rotation = network.PacketReader.ReadDouble(); bool a = network.PacketReader.ReadBoolean(); if (a) { Bullet b = new Bullet(); b.Position = network.PacketReader.ReadVector2(); b.Velocity = network.PacketReader.ReadVector2(); t.bullets.Add(b); } Bullet c = new Bullet(); } } }
/// <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; MessageType msgType = (MessageType)packetReader.ReadInt32 (); switch (msgType) { case MessageType.NewGame: //ReceiveNewNetworkedGame(); break; case MessageType.CatapultAiming: if (isFirstPlayerTurn && !NetworkSession.IsHost) { playerOne.Catapult.CurrentState = CatapultState.Aiming; playerOne.isDragging = true; catapultInfoVector = packetReader.ReadVector3(); playerOne.Catapult.ShotStrength = catapultInfoVector.X; playerOne.Catapult.ShotVelocity = catapultInfoVector.Y; playerOne.ArrowScale = catapultInfoVector.Z; } if (!isFirstPlayerTurn && NetworkSession.IsHost) { playerTwo.Catapult.CurrentState = CatapultState.Aiming; playerTwo.isDragging = true; catapultInfoVector = packetReader.ReadVector3(); playerTwo.Catapult.ShotStrength = catapultInfoVector.X; playerTwo.Catapult.ShotVelocity = catapultInfoVector.Y; playerTwo.ArrowScale = catapultInfoVector.Z; } break; case MessageType.CatapultFiring: if (isFirstPlayerTurn && !NetworkSession.IsHost) { catapultInfoVector = packetReader.ReadVector3(); playerOne.Catapult.Fire (catapultInfoVector.Y); playerOne.Catapult.CurrentState = CatapultState.Firing; playerOne.ResetDragState(); } if (!isFirstPlayerTurn && NetworkSession.IsHost) { catapultInfoVector = packetReader.ReadVector3(); playerTwo.Catapult.Fire (catapultInfoVector.Y); playerTwo.Catapult.CurrentState = CatapultState.Firing; playerTwo.ResetDragState(); } break; case MessageType.UpdateEnvironment: wind = packetReader.ReadVector2(); cloud1Position = packetReader.ReadVector2(); cloud2Position = packetReader.ReadVector2(); // Set new wind value to the players and playerOne.Catapult.Wind = playerTwo.Catapult.Wind = wind.X > 0 ? wind.Y : -wind.Y; break; } } }
/// <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. Player remotePlayer = sender.Tag as Player; // Read the state of this tank from the network packet. Vector2 pos = packetReader.ReadVector2(); remotePlayer.X = pos.X; remotePlayer.Y = pos.Y; } }
static void SetupSession() { session.GameStarted += new EventHandler<GameStartedEventArgs>(StartGame); session.GamerJoined += new EventHandler<GamerJoinedEventArgs>(GamerJoined); localGamer = session.LocalGamers[0]; while (!localGamer.IsDataAvailable) ; NetworkGamer sender; localGamer.ReceiveData(reader, out sender); //foreach (NetworkGamer gamer in session.AllGamers) // if (!gamer.IsLocal) // while ((gamer.Tag as LinkedList<string>).Count != 0) // { // playerList.AddLast((gamer.Tag as LinkedList<string>).First.Value); // (gamer.Tag as LinkedList<string>).RemoveFirst(); // } //LinkedList<string> tag = new LinkedList<string>(); //int i = playerList.Count; //for (int j = 0; j < Settings.names.Length; j++) // if (Settings.enabled[j]) // { // tag.AddLast((i < 10 ? "0" : "") + i + "- " + Settings.names[j]); // i++; // } //localGamer.Tag = tag; //while (tag.Count != 0) //{ // playerList.AddLast(tag.First.Value); // tag.RemoveFirst(); //} }
void ServerReadInputFromClients(LocalNetworkGamer gamer) { while (gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(network.PacketReader, out sender); if (!sender.IsLocal) { Tank t = sender.Tag as Tank; bool shotFired = network.PacketReader.ReadBoolean(); if (shotFired) { Bullet b = new Bullet(); b.Position = network.PacketReader.ReadVector2(); b.Velocity = network.PacketReader.ReadVector2(); t.bullets.Add(b); } t.Position = network.PacketReader.ReadVector2(); t.Rotation = network.PacketReader.ReadDouble(); t.Score = network.PacketReader.ReadInt32(); t.MapScreenX = network.PacketReader.ReadInt32(); t.MapScreenY = network.PacketReader.ReadInt32(); } } }
/// <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> private void HostReadInputFromClients(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 (!sender.IsLocal) { RemotePlayers[0].camera.Position = packetReader.ReadVector3(); RemotePlayers[0].camera.HeadingDegrees = (float)packetReader.ReadDouble(); RemotePlayers[0].camera.PitchDegrees = (float)packetReader.ReadDouble(); RemotePlayers[0].CurrentGun = packetReader.ReadInt16(); //RemotePlayers[0].CurrentHealth = packetReader.ReadInt16(); int numberOfShots = packetReader.ReadInt16(); RemoteShots.Shots.Clear(); for (int i = 0; i < numberOfShots; i++) { Shot newShot = new Shot(new Ray(), 0.0f, RemotePlayers[0]); newShot.Caliber = packetReader.ReadInt16(); newShot.TimeToDie = packetReader.ReadInt16(); Vector3 dir = packetReader.ReadVector3(); Vector3 pos = packetReader.ReadVector3(); Ray tracer = new Ray(pos, dir); newShot.Tracer = tracer; RemoteShots.Shots.Add(newShot); } RemoteHappyBarMode = packetReader.ReadInt16(); RemotePlayers[0].Dead = packetReader.ReadBoolean(); previousDeathState = currentDeathState; currentDeathState = RemotePlayers[0].Dead; if (previousDeathState == true && currentDeathState == false) { RemotePlayers[0].CurrentHealth = 100; } } } }
/// <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; if (remoteTank != null) { // Read the state of this tank from the network packet. remoteTank.Position = packetReader.ReadVector2(); remoteTank.TankRotation = packetReader.ReadSingle(); remoteTank.TurretRotation = packetReader.ReadSingle(); } } }
private void RemotesReadIDPacketsFromServer(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); PACKET_ID id = (PACKET_ID)packetReader.ReadInt16(); switch(id) { case PACKET_ID.INITIAL_DATA: CurrentMapSelection = packetReader.ReadInt16(); break; case PACKET_ID.ENEMY_DATA: int numberOfEnemies = packetReader.ReadInt16(); foreach (Being guy in Enemies) { guy.camera.Position = packetReader.ReadVector3(); guy.camera.HeadingDegrees = (float)packetReader.ReadDouble(); guy.camera.PitchDegrees = (float)packetReader.ReadDouble(); guy.CurrentGun = packetReader.ReadInt16(); guy.CurrentHealth = packetReader.ReadInt16(); } break; case PACKET_ID.STAR_DATA: int numberOfStars = packetReader.ReadInt16(); foreach(GameObject star in Stars) { star.Pos = packetReader.ReadVector3(); star.Rotation = (float)packetReader.ReadDouble(); } break; case PACKET_ID.PARTICLE_DATA: int numberOfParticles = packetReader.ReadInt16(); ParticleList.list.Clear(); for (int i = 0; i < numberOfParticles; i++) { Vector3 pos = packetReader.ReadVector3(); ParticleList.AddParticle(pos, Vector3.Zero, Crosshair); } break; case PACKET_ID.PLAYER_DATA: RemotePlayers[0].camera.Position = packetReader.ReadVector3(); RemotePlayers[0].camera.HeadingDegrees = (float)packetReader.ReadDouble(); RemotePlayers[0].camera.PitchDegrees = (float)packetReader.ReadDouble(); RemotePlayers[0].CurrentGun = packetReader.ReadInt16(); //RemotePlayers[0].CurrentHealth = packetReader.ReadInt16(); break; case PACKET_ID.REMOTE_DATA: HappyBarPower = packetReader.ReadInt16(); if (HappyBarMode == 1 && HappyBarPower <= 0) { HappyBarMode = 0; } bool getAmmo = packetReader.ReadBoolean(); if (getAmmo) { foreach (Gun gun in Player.GunList) { switch (gun.GunCode) { case (int)Guns.Deagle: gun.TotalRounds += 14; break; case (int)Guns.AK47: gun.TotalRounds += 30; break; case (int)Guns.Panzerschreck: gun.TotalRounds += 12; break; default: gun.TotalRounds += 12; break; } try { cockGun.Play(); } catch (Exception e) { e.ToString(); } } } bool doYouThinkImDead = packetReader.ReadBoolean(); if (doYouThinkImDead == false) { Player.CurrentHealth = packetReader.ReadInt16(); } else { int i = packetReader.ReadInt16(); } bool playHeadshot = packetReader.ReadBoolean(); if (playHeadshot) { try { Headshot.Play(); } catch (Exception e) { e.ToString(); } } break; case PACKET_ID.CRATE_DATA: int numberOfCrates = packetReader.ReadInt16(); foreach (GameObject ammo in AmmoCrates) { ammo.Pos = packetReader.ReadVector3(); ammo.Rotation = (float)packetReader.ReadDouble(); } 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); } } }
private static void UpdateClientStateFromServer(LocalNetworkGamer gamer) { while(gamer.IsDataAvailable) { NetworkGamer sender; gamer.ReceiveData(Storage.PacketReader, out sender); while(Storage.PacketReader.Position < Storage.PacketReader.Length) { if(!FindNextValidPacket()) { continue; } var type = (MessageType)Storage.PacketReader.ReadInt32(); var gamerId = Storage.PacketReader.ReadByte(); var remoteGamer = Storage.NetworkSession.FindGamerById(gamerId); if(remoteGamer == null || remoteGamer.IsLocal) { switch(type) { case MessageType.UpdatePlayerState: DiscardUpdatePlayerStateMessage(); break; case MessageType.UpdatePlayerMenuState: DiscardUpdatePlayerMenuStateMessage(); break; case MessageType.UpdatePlayerClass: DiscardUpdatePlayerClassMessage(); break; case MessageType.UpdatePlayerTeam: DiscardUpdatePlayerTeamMessage(); break; case MessageType.PlaySound: DiscardPlaySoundMessage(); break; case MessageType.Stun: DiscardStunMessage(); break; case MessageType.ActivateTool: DiscardActivateToolMessage(); break; case MessageType.CreateSand: DiscardCreateSandMessage(); break; case MessageType.UpdateSand: DiscardUpdateSandMessage(); break; case MessageType.ChangeWinState: DiscardChangeWinStateMessage(); break; case MessageType.UpdateScore: DiscardUpdateScoreMessage(); break; case MessageType.ChangeTutorialLevel: DiscardChangeTutorialLevelMessage(); break; default: throw new ArgumentOutOfRangeException(); } continue; } var player = remoteGamer.Tag as Player; switch(type) { case MessageType.UpdatePlayerState: ProcessUpdatePlayerStateMessage(player); break; case MessageType.UpdatePlayerMenuState: ProcessUpdatePlayerMenuStateMessage(player); break; case MessageType.UpdatePlayerClass: ProcessUpdatePlayerClassMessage(player); break; case MessageType.UpdatePlayerTeam: ProcessUpdatePlayerTeamMessage(player); break; case MessageType.PlaySound: ProcessPlaySoundMessage(player); break; case MessageType.Stun: ProcessStunMessage(player); break; case MessageType.ActivateTool: ProcessActivateToolMessage(player); break; case MessageType.CreateSand: ProcessCreateSandMessage(player); break; case MessageType.UpdateSand: ProcessUpdateSandMessage(player); break; case MessageType.ChangeWinState: ProcessChangeWinStateMessage(player); break; case MessageType.UpdateScore: ProcessUpdateScoreMessage(player); break; case MessageType.ChangeTutorialLevel: ProcessChangeTutorialLevelMessage(player); break; default: throw new ArgumentOutOfRangeException(); } } } }