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();
}
}
}
}
