/// <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);
}
}
protected void UpdateLocalPlayer(GameTime gameTime)
{
//you know this will def be the local gamer as there is only 1 allowed
LocalNetworkGamer localGamer = networkSession.LocalGamers[0];
//gotta get the sprite to modify it
UserControlledSprite localSprite = (UserControlledSprite)localGamer.Tag;
//now actually update sprite regualrly
//moving is true because this is just you controlling it
localSprite.Update(gameTime, Window.ClientBounds, true);
if (!localSprite.isChasing)
{
localSprite.score += gameTime.ElapsedGameTime.Milliseconds;
}
writer.Write((int)MessageType.UpdatePlayerPos);
writer.Write(localSprite.Position);
if (!localSprite.isChasing)
{
writer.Write(localSprite.score);
}
//simple sprites may not send data, you must use the localnetworkgamer object
//the options is InOrder because its ok if the packets dont get there, but they at least must be in order
localGamer.SendData(writer, SendDataOptions.ReliableInOrder);
//if your local sprite is a chaser
if (localSprite.isChasing)
{
//if you're able to drop a bomb
if (bombCoolDown <= 0)
{
//and if you press space
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
AddBomb(localSprite.Position);
writer.Write((int)MessageType.AddBomb);
writer.Write(localSprite.Position);
localGamer.SendData(writer, SendDataOptions.ReliableInOrder);
}
}
}
}
/// <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);
}
private static void SendPackets(LocalNetworkGamer gamer)
{
#if WINDOWS
if (ShouldSendLevel)
{
BinaryWriter b = new BinaryWriter(packetWriter.BaseStream);
GameManager.GetLevel().Write(b, true);
Console.WriteLine("Packetwriter Line:" + packetWriter.Position);
gamer.SendData(packetWriter, SendDataOptions.ReliableInOrder);
ShouldSendLevel = false;
}
#endif
#if XBOX
if (RequestTime > TimeSpan.FromSeconds(2))
{
RequestTime -= TimeSpan.FromSeconds(2);
packetWriter.Write(true);
gamer.SendData(packetWriter, SendDataOptions.ReliableInOrder);
}
#endif
}
protected override void SendToNetwork(GameTime gameTime)
{
// write input to all players :
// Packets are sent inorder to make sure the world state never goes backwards in time
// Packets can still get lost, however.
PacketWriter writer = new PacketWriter();
writer.Write(PacketHeader.INGAME_DATA);
foreach (CarActor carActor in idTocarActorMap_[localGamer_.Id])
{
carActor.sendToNetwork(writer);
}
localGamer_.SendData(writer, SendDataOptions.InOrder);
}
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);
}
}
}
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);
}
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);
}
/// <summary>
/// Helper for updating a locally controlled gamer.
/// </summary>
void UpdateLocalGamer(LocalNetworkGamer gamer)
{
// Look up what tank is associated with this local player.
Tank localTank = gamer.Tag as Tank;
// Update the tank.
ReadTankInputs(localTank, gamer.SignedInGamer.PlayerIndex);
localTank.Update();
// Write the tank state into a network packet.
packetWriter.Write(localTank.Position);
packetWriter.Write(localTank.TankRotation);
packetWriter.Write(localTank.TurretRotation);
// Send the data to everyone in the session.
gamer.SendData(packetWriter, SendDataOptions.InOrder);
}
/// <summary>
/// Helper for updating a locally controlled gamer.
/// </summary>
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.
NetworkPlayer localPlayer = gamer.Tag as NetworkPlayer;
localPlayer.Update();
// 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(localPlayer.Position);
// Send our input data to the server.
gamer.SendData(packetWriter,
SendDataOptions.InOrder, networkSession.Host);
}
}
public void UpdateHost(GameTime gameTime, World WorldRef, NetworkSession networkSession)
{
for (int i = 0; i < ButtonCount; i++)
{
if (Buttons[i].ButtonSpellRef != null)
{
if (Buttons[i].ButtonPress())
{
if (WorldRef.ApplySpell(NetPlayerInterfaceRef.PlayerRef, Buttons[i].ButtonSpellRef,
NetPlayerInterfaceRef.PlayerRef.Character.Target, false, false))
{
LocalNetworkGamer server = (LocalNetworkGamer)networkSession.Host;
foreach (NetworkGamer negamer in networkSession.RemoteGamers)
{
PacketWriter packetWriter = new PacketWriter();
NetworkPlayer everyPlayer = negamer.Tag as NetworkPlayer;
packetWriter.Write('S');
packetWriter.Write(NetPlayerInterfaceRef.PlayerRef.ID);
packetWriter.Write(Buttons[i].ButtonSpellRef.SpellDataId);
if (NetPlayerInterfaceRef.PlayerRef.Character.Target == null)
{
packetWriter.Write(0);
}
else
{
packetWriter.Write(NetPlayerInterfaceRef.PlayerRef.Character.Target.ID);
}
server.SendData(packetWriter, SendDataOptions.InOrder);
packetWriter.Flush();
}
}
}
}
}
}
/// <summary>
/// This method only runs on the server. It calls Update on all the
/// tank instances, both local and remote, using inputs that have
/// been received over the network. It then sends the resulting
/// tank position data to everyone in the session.
/// </summary>
void UpdateServer()
{
// Loop over all the players in the session, not just the local ones!
foreach (NetworkGamer gamer in networkSession.AllGamers)
{
// Look up what tank is associated with this player.
Tank tank = gamer.Tag as Tank;
// Update the tank.
tank.Update();
// Write the tank state into the output network packet.
packetWriter.Write(gamer.Id);
packetWriter.Write(tank.Position);
packetWriter.Write(tank.TankRotation);
packetWriter.Write(tank.TurretRotation);
}
// Send the combined data for all tanks to everyone in the session.
LocalNetworkGamer server = (LocalNetworkGamer)networkSession.Host;
server.SendData(packetWriter, SendDataOptions.InOrder);
}
/// <summary>
/// This method only runs on the server. It calls Update on all the
/// tank instances, both local and remote, using inputs that have
/// been received over the network. It then sends the resulting
/// tank position data to everyone in the session.
/// </summary>
void UpdateServer(GameTime gameTime)
{
// First off, our packet will indicate how many tanks it has data for.
packetWriter.Write(networkSession.AllGamers.Count);
// Loop over all the players in the session, not just the local ones!
foreach (NetworkGamer gamer in networkSession.AllGamers)
{
// Look up what tank is associated with this player.
NetworkPlayer player = gamer.Tag as NetworkPlayer;
// Update the tank.
player.Update();
// Write the tank state into the output network packet.
packetWriter.Write(player.Position);
}
// Send the combined data for all tanks to everyone in the session.
LocalNetworkGamer server = (LocalNetworkGamer)networkSession.Host;
server.SendData(packetWriter, SendDataOptions.InOrder);
}
public override void Update(GameTime gameTime)
{
if (!GameMain.CurrentSession.IsHost &&
Id != GameMain.CurrentSession.LocalGamers[0].Id)
{
// Not my object!
return;
}
if (GameMain.CurrentSession.IsHost && _isUnique &&
Id != GameMain.CurrentSession.LocalGamers[0].Id)
{
// Not my object!
return;
}
_timeElapsed += gameTime.ElapsedGameTime.Milliseconds;
if (_timeElapsed >= _timeBetween)
{
/* Protocol will always be:
* Type (string)
* Id (int)
* Data (varies)
*/
PacketWriter writer = new PacketWriter();
writer.Write(Type);
writer.Write(Id);
SendData(writer);
_player.SendData(writer, SendDataOptions.ReliableInOrder);
_timeElapsed -= _timeBetween;
}
}
public void UpdateLocalGamer(LocalNetworkGamer gamer)
{
PlayerIndex index = gamer.SignedInGamer.PlayerIndex;
BasicOrb orb = gamer.Tag as BasicOrb;
packetWriter.Write(new Vector2(orb.Position.X, orb.Position.Z));
packetWriter.Write(orb.Rotation.Y);
packetWriter.Write(orb.PrimaryWeaponQue);
packetWriter.Write(orb.SecondaryWeaponQue);
packetWriter.Write(orb.AbilityQue);
packetWriter.Write(orb.GunCurrent);
packetWriter.Write(orb.Abilty[0]);
packetWriter.Write(orb.Team);
packetWriter.Write(orb.Alpha);
packetWriter.Write(orb.IsPhasing);
packetWriter.Write(orb.PhaseTimer);
packetWriter.Write(orb.PhaseVelocity);
packetWriter.Write(orb.MyController.MoveStickTrack);
gamer.SendData(packetWriter, SendDataOptions.InOrder, networkSession.Host);
return;
}
public void Send(LocalNetworkGamer local, qHeader pHeader)
{
PacketWriter pWrite = new PacketWriter();
pWrite.Write((int)pHeader.type);
pWrite.Write((int)pHeader.packetOwner);
pWrite.Write(pHeader.inseq);
pWrite.Write(pHeader.outseq);
switch (pHeader.type)
{
case QueueType.ship_rot_clock:
Ship_rot_message p1 = (Ship_rot_message)pHeader.obj;
pWrite.Write((int)p1.rot);
pWrite.Write((int)p1.x);
pWrite.Write((int)p1.y);
pWrite.Write((int)p1.serverRotvalue);
break;
case QueueType.ship_rot_anti:
Ship_rot_message p4 = (Ship_rot_message)pHeader.obj;
pWrite.Write((int)p4.rot);
pWrite.Write((int)p4.x);
pWrite.Write((int)p4.y);
pWrite.Write((int)p4.serverRotvalue);
break;
case QueueType.ship_missile:
Ship_Create_Missile_Message missile = (Ship_Create_Missile_Message)pHeader.obj;
pWrite.Write((int)missile.x);
pWrite.Write((int)missile.y);
pWrite.Write((int)missile.rot);
break;
case QueueType.ship_impulse:
ship_impulse p = (ship_impulse)pHeader.obj;
pWrite.Write((int)p.impulse.X);
pWrite.Write((int)p.impulse.Y);
pWrite.Write((int)p.x);
pWrite.Write((int)p.y);
pWrite.Write((int)p.rot);
break;
case QueueType.ship_bomb:
Ship_Create_Bomb_Message bomb = (Ship_Create_Bomb_Message)pHeader.obj;
pWrite.Write((int)bomb.x);
pWrite.Write((int)bomb.y);
pWrite.Write((int)bomb.rot);
break;
case QueueType.EventMessage:
EvenMessage e = new EvenMessage((EvenMessage)pHeader.obj);
pWrite.Write(e.gameIdA);
pWrite.Write(e.gameIdB);
pWrite.Write(e.CollisionPt);
break;
}
local.SendData(pWrite, SendDataOptions.InOrder);
}
public void Update(Character[] c, ParticleManager pMan)
{
LocalNetworkGamer gamer = GetGamer();
if (gamer == null)
{
return;
}
frame -= FrameTime;
if (frame < 0f)
{
frame = .05f;
if (netPlay.Hosting)
{
if (c[0] != null)
{
writer.Write(MSG_SERVER_DATA);
c[0].WriteToNet(writer);
for (int i = 2; i < c.Length; i++)
{
if (c[i] != null)
{
c[i].WriteToNet(writer);
}
}
pMan.NetWriteParticles(writer);
writer.Write(MSG_END);
gamer.SendData(writer, SendDataOptions.None);
}
}
if (netPlay.Joined)
{
if (c[1] != null)
{
writer.Write(MSG_CLIENT_DATA);
c[1].WriteToNet(writer);
pMan.NetWriteParticles(writer);
writer.Write(MSG_END);
gamer.SendData(writer, SendDataOptions.None);
}
}
}
if (gamer.IsDataAvailable)
{
NetworkGamer sender;
gamer.ReceiveData(reader, out sender);
if (!sender.IsLocal)
{
byte type = reader.ReadByte();
if (netPlay.Joined)
{
for (int i = 0; i < c.Length; i++)
{
if (i != 1)
{
if (c[i] != null)
{
c[i].ReceivedNetUpdate = false;
}
}
}
}
bool end = false;
while (!end)
{
byte msg = reader.ReadByte();
switch (msg)
{
case MSG_END:
end = true;
break;
case MSG_CHARACTER:
int defID = NetPacker.SbyteToInt(reader.ReadSByte());
int team = NetPacker.SbyteToInt(reader.ReadSByte());
int ID = NetPacker.SbyteToInt(reader.ReadSByte());
if (c[ID] == null)
{
c[ID] = new Character(new Vector2(),
Game1.charDef[defID],
ID, team);
}
c[ID].ReadFromNet(reader);
c[ID].ReceivedNetUpdate = true;
break;
case MSG_PARTICLE:
byte pType = reader.ReadByte();
bool bg = reader.ReadBoolean();
switch (pType)
{
case Particle.PARTICLE_NONE:
//
break;
case Particle.PARTICLE_BLOOD:
pMan.AddParticle(new Blood(reader), bg, true);
break;
case Particle.PARTICLE_BLOOD_DUST:
pMan.AddParticle(new BloodDust(reader), bg, true);
break;
case Particle.PARTICLE_BULLET:
pMan.AddParticle(new Bullet(reader), bg, true);
break;
case Particle.PARTICLE_FIRE:
pMan.AddParticle(new Fire(reader), bg, true);
break;
case Particle.PARTICLE_FOG:
pMan.AddParticle(new Fog(reader), bg, true);
break;
case Particle.PARTICLE_HEAT:
pMan.AddParticle(new Heat(reader), bg, true);
break;
case Particle.PARTICLE_HIT:
pMan.AddParticle(new Hit(reader), bg, true);
break;
case Particle.PARTICLE_MUZZLEFLASH:
pMan.AddParticle(new MuzzleFlash(reader), bg, true);
break;
case Particle.PARTICLE_ROCKET:
pMan.AddParticle(new Rocket(reader), bg, true);
break;
case Particle.PARTICLE_SHOCKWAVE:
pMan.AddParticle(new Shockwave(reader), bg, true);
break;
case Particle.PARTICLE_SMOKE:
pMan.AddParticle(new Smoke(reader), bg, true);
break;
default:
//Error!
break;
}
break;
}
}
if (netPlay.Joined)
{
for (int i = 0; i < c.Length; i++)
{
if (i != 1)
{
if (c[i] != null)
{
if (c[i].ReceivedNetUpdate == false)
{
c[i] = null;
}
}
}
}
}
}
}
}
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
{
this.Exit();
}
if (this.IsActive)
{
switch (currentGameState)
{
case GameState.SignIn:
{
if (Gamer.SignedInGamers.Count < 1)
{
Guide.ShowSignIn(1, false);
log.Add("Opened User SignIn Interface");
}
else
{
currentGameState = GameState.SearchSession;
log.Add(Gamer.SignedInGamers[0].Gamertag + " logged in - proceed to SearchSession");
}
}
break;
case GameState.SearchSession:
{
AvailableNetworkSessionCollection activeSessions = NetworkSession.Find(NetworkSessionType.SystemLink, 4, null);
if (activeSessions.Count == 0)
{
currentGameState = GameState.CreateSession;
log.Add("No active sessions found - proceed to CreateSession");
}
else
{
AvailableNetworkSession sessionToJoin = activeSessions[0];
networkSession = NetworkSession.Join(sessionToJoin);
string myString = "Joined session hosted by " + sessionToJoin.HostGamertag;
myString += " with " + sessionToJoin.CurrentGamerCount.ToString() + " players";
myString += " and " + sessionToJoin.OpenPublicGamerSlots.ToString() + " open player slots.";
log.Add(myString);
HookSessionEvents();
currentGameState = GameState.InSession;
}
}
break;
case GameState.CreateSession:
{
networkSession = NetworkSession.Create(NetworkSessionType.SystemLink, 4, 16);
networkSession.AllowHostMigration = true;
networkSession.AllowJoinInProgress = false;
log.Add("New session created");
HookSessionEvents();
currentGameState = GameState.InSession;
}
break;
case GameState.InSession:
{
//send data to all other players in session
writer.Write(gameTime.TotalGameTime.Minutes);
writer.Write(gameTime.TotalGameTime.Seconds);
LocalNetworkGamer localGamer = networkSession.LocalGamers[0];
localGamer.SendData(writer, SendDataOptions.ReliableInOrder);
//receive data from all other players in session
while (localGamer.IsDataAvailable)
{
NetworkGamer sender;
localGamer.ReceiveData(reader, out sender);
string gamerTime = "";
gamerTime += sender.Gamertag + ": ";
gamerTime += reader.ReadInt32() + "m ";
gamerTime += reader.ReadInt32() + "s";
gamerTimes[sender.Gamertag] = gamerTime;
}
networkSession.Update();
}
break;
}
}
base.Update(gameTime);
}
// PacketWriter packetWriter2 = new PacketWriter();
public static void PushToNetwork()
{
PacketWriter packetWriter2 = new PacketWriter();
int count = outQ.Count;
for (int i = 0; i < count; i++)
{
// Read the header
QueueHdr qH = outQ.Dequeue();
switch (qH.type)
{
case Queue_type.QUEUE_SHIP_BOMB:
packetWriter2.Write(qH.inSeqNum);
packetWriter2.Write(qH.outSeqNum);
packetWriter2.Write((int)qH.type);
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
InputQueue.add(qH);
}
if (Game1.networkSession.IsHost)
{
LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host;
server.SendData(packetWriter2, SendDataOptions.InOrder);
}
}
foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers)
{
if (!Game1.networkSession.IsHost)
{
InputQueue.add(qH);
// Write our latest input state into a network packet.
//packetWriter2.Write(qH.inSeqNum);
//packetWriter2.Write(qH.outSeqNum);
//packetWriter2.Write((int)qH.type);
// packetWriter2.Write((int)qH.data);
// Send our input data to the server.//
gamer.SendData(packetWriter2,
SendDataOptions.InOrder, Game1.networkSession.Host);
}
}
break;
case Queue_type.QUEUE_SHIP_MISSILE:
packetWriter2.Write(qH.inSeqNum);
packetWriter2.Write(qH.outSeqNum);
packetWriter2.Write((int)qH.type);
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
InputQueue.add(qH);
}
if (Game1.networkSession.IsHost)
{
LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host;
server.SendData(packetWriter2, SendDataOptions.InOrder);
}
}
foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers)
{
if (!Game1.networkSession.IsHost)
{
InputQueue.add(qH);
// Write our latest input state into a network packet.
//packetWriter2.Write(qH.inSeqNum);
//packetWriter2.Write(qH.outSeqNum);
//packetWriter2.Write((int)qH.type);
// packetWriter2.Write((int)qH.data);
// Send our input data to the server.
gamer.SendData(packetWriter2,
SendDataOptions.InOrder, Game1.networkSession.Host);
}
}
break;
case Queue_type.QUEUE_SHIP_IMPULSE:
packetWriter2.Write(qH.inSeqNum);
packetWriter2.Write(qH.outSeqNum);
packetWriter2.Write((int)qH.type);
Ship_Impulse_Message sim = (Ship_Impulse_Message)qH.data;
packetWriter2.Write((Vector2)sim.impulse);
Debug.WriteLine("Outputq - sim.impulse = " + sim.impulse);
Debug.WriteLine("Outputq - sim.X = " + sim.impulse.X);
Debug.WriteLine("Outputq - sim.Y = " + sim.impulse.Y);
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
InputQueue.add(qH);
}
if (Game1.networkSession.IsHost)
{
LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host;
server.SendData(packetWriter2, SendDataOptions.InOrder);
}
}
foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers)
{
if (!Game1.networkSession.IsHost)
{
InputQueue.add(qH); ///just added 207pm
// Write our latest input state into a network packet.
//packetWriter2.Write(qH.inSeqNum);
//packetWriter2.Write(qH.outSeqNum);
//packetWriter2.Write((int)qH.type);
//Ship_Impulse_Message sim = (Ship_Impulse_Message)qH.data;
//packetWriter2.Write((Vector2)sim.impulse);
// Send our input data to the server.
gamer.SendData(packetWriter2,
SendDataOptions.InOrder, Game1.networkSession.Host);
}
}
break;
case Queue_type.QUEUE_SHIP_ROT:
//send to input queue
//packetWriter2.Write(qH.inSeqNum);
// packetWriter2.Write(qH.outSeqNum);
// packetWriter2.Write((int)qH.type);
// Ship_Impulse_Message sim = (Ship_Impulse_Message)qH.data;
// packetWriter2.Write((Vector2)sim.impulse);
packetWriter2.Write(qH.inSeqNum);
packetWriter2.Write(qH.outSeqNum);
packetWriter2.Write((int)qH.type);
Ship_Rot_Message rotMessage = (Ship_Rot_Message)qH.data;
packetWriter2.Write(rotMessage.rotation);
Debug.WriteLine(" OutputQ - rotMessage.rotation = " + rotMessage.rotation);
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
InputQueue.add(qH);
}
}
if (Game1.networkSession.IsHost)
{
LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host;
server.SendData(packetWriter2, SendDataOptions.InOrder);
}
foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers)
{
if (!Game1.networkSession.IsHost)
{
// Write our latest input state into a network packet.
//packetWriter2.Write(qH.inSeqNum);
//packetWriter2.Write(qH.outSeqNum);
//packetWriter2.Write((int)qH.type);
//Ship_Rot_Message rotMessage = (Ship_Rot_Message)qH.data;
//packetWriter2.Write(rotMessage.rotation);
// packetWriter2.Write((Vector2)qH.data);
// Send our input data to the server.
gamer.SendData(packetWriter2,
SendDataOptions.InOrder, Game1.networkSession.Host);
}
}
break;
case Queue_type.QUEUE_PHYSICS_BUFFER:
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
InputQueue.add(qH);
}
}
if (Game1.networkSession != null)
{
// packetWriter2.Write(gamer.Id);
packetWriter2.Write(qH.inSeqNum);
packetWriter2.Write(qH.outSeqNum);
packetWriter2.Write((int)qH.type);
//Debug.WriteLine("qH.inSeqNum from PushToNetwork = " + qH.inSeqNum);
//Debug.WriteLine("qH.outSeqNum from PushToNetwork = " + qH.outSeqNum);
//Debug.WriteLine("qH.type from PushToNetwork = " + qH.type);
//PhysicsBuffer[] localPhysicsBuff = new PhysicsBuffer[];
PhysicsBuffer_Message PhysicsBuff_MessageInQueueHdr = new PhysicsBuffer_Message((PhysicsBuffer_Message)qH.data);
//get the count from the buffer
packetWriter2.Write(PhysicsBuff_MessageInQueueHdr.count);
//Debug.WriteLine("PhysicsBuff_MessageInQueueHdr.count = " + PhysicsBuff_MessageInQueueHdr.count);
PhysicsBuffer[] localPhysicsBuff = new PhysicsBuffer[PhysicsBuff_MessageInQueueHdr.count];
//get the the physics buffer struct of id, position , rotation out
localPhysicsBuff = PhysicsBuff_MessageInQueueHdr.pBuff;
for (int j = 0; j < PhysicsBuff_MessageInQueueHdr.count; j++)
{
PhysicsBuffer myPhysicsBuffer = new PhysicsBuffer();
myPhysicsBuffer.id = localPhysicsBuff[j].id;
myPhysicsBuffer.position = localPhysicsBuff[j].position;
myPhysicsBuffer.rotation = localPhysicsBuff[j].rotation;
packetWriter2.Write(myPhysicsBuffer.id);
packetWriter2.Write(myPhysicsBuffer.position);
packetWriter2.Write(myPhysicsBuffer.rotation);
//Debug.WriteLine("myPhysicsBuffer.id = " + myPhysicsBuffer.id);
//Debug.WriteLine("myPhysicsBuffer.position = " + myPhysicsBuffer.position);
//Debug.WriteLine("myPhysicsBuffer.rotation = " + myPhysicsBuffer.rotation);
}
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host;
server.SendData(packetWriter2, SendDataOptions.InOrder);
}
}
// if this is the client machine, need to send to server
}
// Send our input data to the server.
//if (Game1.networkSession != null)
//{
// if (Game1.networkSession.IsHost)
// {
// foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers)
// {
// gamer.SendData(packetWriter2,
// SendDataOptions.InOrder, Game1.networkSession.);
// }
// }
//}
break;
case Queue_type.QUEUE_EVENT:
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
InputQueue.add(qH);
}
}
if (Game1.networkSession != null)
{
// Write our latest input state into a network packet.
packetWriter2.Write(qH.inSeqNum);
packetWriter2.Write(qH.outSeqNum);
packetWriter2.Write((int)qH.type);
// packetWriter2.Write((int)qH.data);
Event_Message eventMsg = new Event_Message((Event_Message)qH.data);
packetWriter2.Write(eventMsg.GameID_A);
// Debug.WriteLine("eventMsg " + eventMsg.GameID_A);
packetWriter2.Write(eventMsg.GameID_B);
// Debug.WriteLine("eventMsg " + eventMsg.GameID_B);
packetWriter2.Write(eventMsg.collision_pt);
// Debug.WriteLine("eventMsg " + eventMsg.collision_pt);
if (Game1.networkSession != null)
{
if (Game1.networkSession.IsHost)
{
LocalNetworkGamer server = (LocalNetworkGamer)Game1.networkSession.Host;
server.SendData(packetWriter2, SendDataOptions.InOrder);
}
}
// Send our input data to the server.
// gamer.SendData(packetWriter2,
// SendDataOptions.InOrder, Game1.networkSession.Host);
}
//foreach (LocalNetworkGamer gamer in Game1.networkSession.LocalGamers)
//{
// if (!Game1.networkSession.IsHost)
// {
// // Write our latest input state into a network packet.
// packetWriter2.Write(qH.inSeqNum);
// packetWriter2.Write(qH.outSeqNum);
// packetWriter2.Write((int)qH.type);
// // Ship_Rot_Message rotMessage = (Ship_Rot_Message)qH.data;
// // packetWriter2.Write(rotMessage.rotation);
// // packetWriter2.Write((Vector2)qH.data);
// // Send our input data to the server.
// gamer.SendData(packetWriter2,
// SendDataOptions.InOrder, Game1.networkSession.Host);
// }
//}
break;
default:
break;
}
}
}
