public int ReceiveData ( byte[] data, out NetworkGamer sender ) { throw new NotImplementedException(); }
public void EnableSendVoice ( NetworkGamer remoteGamer, bool enable ) { throw new NotImplementedException(); }
/* public void EnableSendVoice ( NetworkGamer remoteGamer, bool enable) { throw new NotImplementedException (); } */ public int ReceiveData ( byte[] data, int offset, out NetworkGamer sender) { if (data == null) throw new ArgumentNullException("data"); if (receivedData.Count <= 0) { sender = null; return 0; } lock (receivedData) { CommandReceiveData crd; // we will peek at the value first to see if we can process it crd = (CommandReceiveData)receivedData.Peek(); if (offset + crd.data.Length > data.Length) throw new ArgumentOutOfRangeException("data","The length + offset is greater than parameter can hold."); // no exception thrown yet so let's process it // take it off the queue receivedData.Dequeue(); Array.Copy(crd.data, offset, data, 0, data.Length); sender = crd.gamer; return data.Length; } }
public void SendData ( byte[] data, SendDataOptions options, NetworkGamer recipient) { CommandEvent cme = new CommandEvent(new CommandSendData(data, 0, data.Length, options, recipient, this )); Session.commandQueue.Enqueue(cme); }
internal void SendGamerStateChange(NetworkGamer gamer) { NetOutgoingMessage message = ((NetPeer)this.peer).CreateMessage(); message.Write((byte)6); message.Write((int)gamer.State); this.SendMessage(message, SendDataOptions.Reliable, gamer); }
internal WriteLeaderboardsEventArgs( NetworkGamer gamer, bool isLeaving ) { Gamer = gamer; IsLeaving = isLeaving; }
public void SendData( byte[] data, SendDataOptions options, NetworkGamer recipient ) { SendData(data, 0, data.Length, options, recipient); }
public int ReceiveData( byte[] data, int offset, out NetworkGamer sender ) { throw new NotImplementedException(); }
public void SendData( PacketWriter data, SendDataOptions options, NetworkGamer recipient ) { throw new NotImplementedException(); }
public void SendData( byte[] data, SendDataOptions options, NetworkGamer recipient ) { throw new NotImplementedException(); }
public void SendData ( PacketWriter data, SendDataOptions options, NetworkGamer recipient) { SendData(data.Data, 0, data.Length, options, recipient); data.Reset(); }
public HostChangedEventArgs( NetworkGamer oldHost, NetworkGamer newHost ) { OldHost = oldHost; NewHost = newHost; }
internal void SendGamerStateChange(NetworkGamer gamer) { NetOutgoingMessage om = peer.CreateMessage(); om.Write((byte)NetworkMessageType.GamerStateChange); om.Write((int)gamer.State); SendMessage(om, SendDataOptions.Reliable, gamer); }
private void ProcessGamerJoined(CommandGamerJoined command) { NetworkGamer gamer; if ((command.State & GamerStates.Local) != 0) { gamer = new LocalNetworkGamer(this, (byte)command.InternalIndex, command.State); _allGamers.AddGamer(gamer); _localGamers.AddGamer((LocalNetworkGamer)gamer); // Note - This might be in the wrong place for certain connections // Take a look at HoneycombRush tut for debugging later. if (Gamer.SignedInGamers.Count >= _localGamers.Count) { ((LocalNetworkGamer)gamer).SignedInGamer = Gamer.SignedInGamers[_localGamers.Count - 1]; } // We will attach a property change handler to local gamers // se that we can broadcast the change to other peers. gamer.PropertyChanged += HandleGamerPropertyChanged; } else { gamer = new NetworkGamer(this, (byte)command.InternalIndex, command.State); gamer.DisplayName = command.DisplayName; gamer.Gamertag = command.GamerTag; gamer.RemoteUniqueIdentifier = command.remoteUniqueIdentifier; _allGamers.AddGamer(gamer); _remoteGamers.AddGamer(gamer); } if ((command.State & GamerStates.Host) != 0) { hostingGamer = gamer; } gamer.Machine = new NetworkMachine(); gamer.Machine.Gamers.AddGamer(gamer); //gamer.IsReady = true; if (GamerJoined != null) { GamerJoined(this, new GamerJoinedEventArgs(gamer)); } #if !PORTABLE if (networkPeer != null && (command.State & GamerStates.Local) == 0) { networkPeer.SendPeerIntroductions(gamer); } if (networkPeer != null) { networkPeer.UpdateLiveSession(this); } #endif }
internal void SendData( byte[] data, SendDataOptions options, NetworkGamer gamer) { #if !PORTABLE this.SendMessage(NetworkMessageType.Data, data, options, gamer); #endif }
internal void SendGamerStateChange(NetworkGamer gamer) { Game.Instance.Log("SendGamerStateChange " + gamer.RemoteUniqueIdentifier); NetOutgoingMessage om = peer.CreateMessage(); om.Write((byte)NetworkMessageType.GamerStateChange); om.Write((int)gamer.State); SendMessage(om, SendDataOptions.Reliable, gamer); }
public void SendData ( byte[] data, int offset, int count, SendDataOptions options, NetworkGamer recipient) { CommandEvent cme = new CommandEvent(new CommandSendData(data, offset, count, options, recipient,this )); Session.commandQueue.Enqueue(cme); }
private void HandleGamerPropertyChanged(object sender, PropertyChangedEventArgs e) { NetworkGamer gamer = sender as NetworkGamer; if (gamer == null || !gamer.IsLocal) { return; } this.commandQueue.Enqueue(new CommandEvent((ICommand) new CommandGamerStateChange(gamer))); }
public CommandSendData(byte[] data, int offset, int count, SendDataOptions options, NetworkGamer gamer) { if (gamer != null) gamerInternalIndex = gamer.Id; this.data = new byte[count]; Array.Copy(data, offset, this.data, 0, count); this.offset = offset; this.count = count; this.options = options; this.gamer = gamer; }
internal void SendGamerStateChange(NetworkGamer gamer) { #if !WINDOWS_PHONE System.Console.WriteLine("SendGamerStateChange " + gamer.RemoteUniqueIdentifier); #endif NetOutgoingMessage om = peer.CreateMessage(); om.Write((byte)NetworkMessageType.GamerStateChange); om.Write((int)gamer.State); SendMessage(om, SendDataOptions.Reliable, gamer); }
private NetworkSession(NetworkSessionType sessionType, int maxGamers, int privateGamerSlots, NetworkSessionProperties sessionProperties, bool isHost, int hostGamer, AvailableNetworkSession availableSession) : this() { if (sessionProperties == null) { throw new ArgumentNullException("sessionProperties"); } _allGamers = new GamerCollection <NetworkGamer>(); _localGamers = new GamerCollection <LocalNetworkGamer>(); // for (int x = 0; x < Gamer.SignedInGamers.Count; x++) { // GamerStates states = GamerStates.Local; // if (x == 0) // states |= GamerStates.Host; // LocalNetworkGamer localGamer = new LocalNetworkGamer(this, (byte)x, states); // localGamer.SignedInGamer = Gamer.SignedInGamers[x]; // _allGamers.AddGamer(localGamer); // _localGamers.AddGamer(localGamer); // // // We will attach a property change handler to local gamers // // se that we can broadcast the change to other peers. // localGamer.PropertyChanged += HandleGamerPropertyChanged; // // } _remoteGamers = new GamerCollection <NetworkGamer>(); _previousGamers = new GamerCollection <NetworkGamer>(); hostingGamer = null; commandQueue = new Queue <CommandEvent>(); this.sessionType = sessionType; this.maxGamers = maxGamers; this.privateGamerSlots = privateGamerSlots; this.sessionProperties = sessionProperties; this.isHost = isHost; this.hostGamerIndex = hostGamer; if (isHost) { networkPeer = new MonoGamerPeer(this, null); } else { if (networkPeer == null) { networkPeer = new MonoGamerPeer(this, availableSession); } } CommandGamerJoined gj = new CommandGamerJoined(hostGamer, this.isHost, true); commandQueue.Enqueue(new CommandEvent(gj)); }
public Player(Game game, NetworkGamer gamer) : base(game) { Gamer = gamer; DrawOrder = 100; Width = Storage.Sprite("DefenseClass").Width; Height = Storage.Sprite("DefenseClass").Height; Texture = new Color[(int)(Width * Height)]; Class = Class.None; _previousPositions = new Queue<Tuple<Vector2, float>>(MaxPreviousPositions); }
private void ProcessGamerLeft(CommandGamerLeft command) { for (int index = 0; index < this._remoteGamers.Count; ++index) { if (this._remoteGamers[index].RemoteUniqueIdentifier == command.remoteUniqueIdentifier) { NetworkGamer aGamer = this._remoteGamers[index]; this._remoteGamers.RemoveGamer(aGamer); this._allGamers.RemoveGamer(aGamer); if (this.GamerLeft != null) this.GamerLeft((object) this, new GamerLeftEventArgs(aGamer)); } } }
public CommandSendData(byte[] data, int offset, int count, SendDataOptions options, NetworkGamer gamer, LocalNetworkGamer sender) { if (gamer != null) { this.gamerInternalIndex = (int)gamer.Id; } this.data = new byte[count]; Array.Copy((Array)data, offset, (Array)this.data, 0, count); this.offset = offset; this.count = count; this.options = options; this.gamer = gamer; this.sender = sender; }
public void SendData( PacketWriter data, SendDataOptions options, NetworkGamer recipient ) { // FIXME: Do we want to alloc like this? -flibit byte[] mem = (data.BaseStream as System.IO.MemoryStream).ToArray(); data.BaseStream.Seek(0, System.IO.SeekOrigin.Begin); NetworkSession.NetworkEvent evt = new NetworkSession.NetworkEvent() { Type = NetworkSession.NetworkEventType.PacketSend, Gamer = recipient, Packet = mem, Reliable = options }; Session.SendNetworkEvent(evt); }
private void ProcessGamerJoined(CommandGamerJoined command) { NetworkGamer networkGamer; if ((command.State & GamerStates.Local) != (GamerStates)0) { networkGamer = (NetworkGamer) new LocalNetworkGamer(this, (byte)command.InternalIndex, command.State); this._allGamers.AddGamer(networkGamer); this._localGamers.AddGamer((LocalNetworkGamer)networkGamer); if (Gamer.SignedInGamers.Count >= this._localGamers.Count) { ((LocalNetworkGamer)networkGamer).SignedInGamer = ((List <SignedInGamer>)Gamer.SignedInGamers)[this._localGamers.Count - 1]; } networkGamer.PropertyChanged += new PropertyChangedEventHandler(this.HandleGamerPropertyChanged); } else { networkGamer = new NetworkGamer(this, (byte)command.InternalIndex, command.State); networkGamer.DisplayName = command.DisplayName; networkGamer.Gamertag = command.GamerTag; networkGamer.RemoteUniqueIdentifier = command.remoteUniqueIdentifier; this._allGamers.AddGamer(networkGamer); this._remoteGamers.AddGamer(networkGamer); } if ((command.State & GamerStates.Host) != (GamerStates)0) { this.hostingGamer = networkGamer; } networkGamer.Machine = new NetworkMachine(); networkGamer.Machine.Gamers.AddGamer(networkGamer); if (this.GamerJoined != null) { this.GamerJoined((object)this, new GamerJoinedEventArgs(networkGamer)); } if (this.networkPeer != null && (command.State & GamerStates.Local) == (GamerStates)0) { this.networkPeer.SendPeerIntroductions(networkGamer); } if (this.networkPeer == null) { return; } this.networkPeer.UpdateLiveSession(this); }
private NetworkSession(NetworkSessionType sessionType, int maxGamers, int privateGamerSlots, NetworkSessionProperties sessionProperties, bool isHost, int hostGamer, AvailableNetworkSession availableSession) : this() { if (sessionProperties == null) throw new ArgumentNullException("sessionProperties"); this._allGamers = new GamerCollection<NetworkGamer>(); this._localGamers = new GamerCollection<LocalNetworkGamer>(); this._remoteGamers = new GamerCollection<NetworkGamer>(); this._previousGamers = new GamerCollection<NetworkGamer>(); this.hostingGamer = (NetworkGamer) null; this.commandQueue = new Queue<CommandEvent>(); this.sessionType = sessionType; this.maxGamers = maxGamers; this.privateGamerSlots = privateGamerSlots; this.sessionProperties = sessionProperties; this.isHost = isHost; this.hostGamerIndex = hostGamer; this.commandQueue.Enqueue(new CommandEvent((ICommand) new CommandGamerJoined(hostGamer, this.isHost, true))); }
void HandleGamerPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { NetworkGamer gamer = sender as NetworkGamer; if (gamer == null) { return; } // If the gamer is local then we need to broadcast that change to all other // connected peers. This is a double check here as we should only be handling // property changes for local gamers for now. if (gamer.IsLocal) { CommandGamerStateChange sc = new CommandGamerStateChange(gamer); CommandEvent cmd = new CommandEvent(sc); commandQueue.Enqueue(cmd); } }
public void SendData( byte[] data, int offset, int count, SendDataOptions options, NetworkGamer recipient ) { // FIXME: Do we want to alloc like this? -flibit byte[] mem = new byte[count]; Array.Copy(data, offset, mem, 0, mem.Length); NetworkSession.NetworkEvent evt = new NetworkSession.NetworkEvent() { Type = NetworkSession.NetworkEventType.PacketSend, Gamer = recipient, Packet = mem, Reliable = options }; Session.SendNetworkEvent(evt); }
private void SendMessage(NetOutgoingMessage om, SendDataOptions options, NetworkGamer gamer) { //Console.WriteLine("Data to send: " + data.Length); // foreach (NetConnection player in server.Connections) { // // ... send information about every other player (actually including self) // foreach (NetConnection otherPlayer in server.Connections) { // if (gamer != null && gamer.RemoteUniqueIdentifier != otherPlayer.RemoteUniqueIdentifier) { // continue; // } NetDeliveryMethod ndm = NetDeliveryMethod.Unreliable; switch (options) { case SendDataOptions.Reliable: ndm = NetDeliveryMethod.ReliableSequenced; break; case SendDataOptions.ReliableInOrder: ndm = NetDeliveryMethod.ReliableOrdered; break; case SendDataOptions.InOrder: ndm = NetDeliveryMethod.UnreliableSequenced; break; case SendDataOptions.None: ndm = NetDeliveryMethod.Unknown; break; } // send message //server.SendToAll (om, player, ndm); peer.SendToAll(om, ndm); // } // } }
public int ReceiveData(byte[] data, int offset, out NetworkGamer sender) { if (data == null) throw new ArgumentNullException("data"); if (this.receivedData.Count <= 0) { sender = (NetworkGamer) null; return 0; } else { lock (this.receivedData) { CommandReceiveData local_0 = this.receivedData.Peek(); if (offset + local_0.data.Length > data.Length) throw new ArgumentOutOfRangeException("data", "The length + offset is greater than parameter can hold."); this.receivedData.Dequeue(); Array.Copy((Array) local_0.data, offset, (Array) data, 0, data.Length); sender = local_0.gamer; return data.Length; } } }
public int ReceiveData(PacketReader data, out NetworkGamer sender) { lock (this.receivedData) { if (this.receivedData.Count >= 0) { data.Reset(0); CommandReceiveData local_0 = this.receivedData.Dequeue(); if (data.Length < local_0.data.Length) { data.Reset(local_0.data.Length); } Array.Copy((Array)local_0.data, (Array)data.Data, data.Length); sender = local_0.gamer; return(data.Length); } else { sender = (NetworkGamer)null; return(0); } } }
private void SendMessage(NetOutgoingMessage om, SendDataOptions options, NetworkGamer gamer) { NetDeliveryMethod netDeliveryMethod = (NetDeliveryMethod)1; switch (options) { case SendDataOptions.None: netDeliveryMethod = (NetDeliveryMethod)0; break; case SendDataOptions.Reliable: netDeliveryMethod = (NetDeliveryMethod)35; break; case SendDataOptions.InOrder: netDeliveryMethod = (NetDeliveryMethod)2; break; case SendDataOptions.ReliableInOrder: netDeliveryMethod = (NetDeliveryMethod)67; break; } this.peer.SendToAll(om, netDeliveryMethod); }
/* * public void EnableSendVoice ( * NetworkGamer remoteGamer, * bool enable) * { * throw new NotImplementedException (); * } */ public int ReceiveData( byte[] data, int offset, out NetworkGamer sender) { if (data == null) { throw new ArgumentNullException("data"); } if (receivedData.Count <= 0) { sender = null; return(0); } lock (receivedData) { CommandReceiveData crd; // we will peek at the value first to see if we can process it crd = (CommandReceiveData)receivedData.Peek(); if (offset + crd.data.Length > data.Length) { throw new ArgumentOutOfRangeException("data", "The length + offset is greater than parameter can hold."); } // no exception thrown yet so let's process it // take it off the queue receivedData.Dequeue(); Array.Copy(crd.data, offset, data, 0, data.Length); sender = crd.gamer; return(data.Length); } }
public void SendData ( byte[] data, SendDataOptions options, NetworkGamer recipient ) { throw new NotImplementedException(); }
internal void ConnectNetworkGamer(NetworkGamer gamer) { if (LocalNetworkGamer == null && IsNetworkGamer(gamer)) { LocalNetworkGamer = gamer as LocalNetworkGamer; LocalNetworkGamer.Tag = this; Flags = Calc.BitSet(0, (int)GamerFlags.Lobby); flagsIsDirty = true; #if DEBUG Log.Trace(String.Format("{0} connected to the session", GamerTag), 2.0f); #endif } }
internal bool IsNetworkGamer(NetworkGamer gamer) { LocalNetworkGamer local = gamer as LocalNetworkGamer; return LocalNetworkGamer == null && local != null && local.SignedInGamer == SignedInGamer; }
/// <summary> /// Write requests to the host. /// </summary> /// <param name="gamers">Clients</param> /// <param name="host">Host</param> public void clientWritePackets(GamerCollection<LocalNetworkGamer> gamers, NetworkGamer host) { Command cmd; foreach (LocalNetworkGamer gamer in gamers) { // TODO: Reimpliment. if(_writer.Length > 0) gamer.SendData(_writer, SendDataOptions.ReliableInOrder, host); } }
internal static Gamer GetGamerFromNetworkGamer(NetworkGamer gamer) { foreach( LocalGamer local in SignedInGamers ) { if (local.IsNetworkGamer(gamer)) { local.ConnectNetworkGamer(gamer); return local; } } return new RemoteGamer(gamer); }
internal void SendGamerStateChange (NetworkGamer gamer) { #if !WINDOWS_PHONE Game.Instance.Log("SendGamerStateChange " + gamer.RemoteUniqueIdentifier); #endif NetOutgoingMessage om = peer.CreateMessage (); om.Write ((byte)NetworkMessageType.GamerStateChange); om.Write ((int)gamer.State); SendMessage (om, SendDataOptions.Reliable, gamer); }
public HostChangedEventArgs(NetworkGamer aNewHost, NetworkGamer aOldHost) { newHost = aNewHost; oldHost = aOldHost; }
public int ReceiveData ( PacketReader data, out NetworkGamer sender) { lock (receivedData) { if (receivedData.Count >= 0) { data.Reset(0); // take it off the queue CommandReceiveData crd = (CommandReceiveData)receivedData.Dequeue(); // lets make sure that we can handle the data if (data.Length < crd.data.Length) { data.Reset(crd.data.Length); } Array.Copy(crd.data, data.Data, data.Length); sender = crd.gamer; return data.Length; } else { sender = null; return 0; } } }
public int ReceiveData ( byte[] data, out NetworkGamer sender) { return ReceiveData(data, 0, out sender); }
/// <summary> /// Helper draws the gamertag and status icons for a single NetworkGamer. /// </summary> void DrawGamer(NetworkGamer gamer, Vector2 position) { SpriteBatch spriteBatch = ScreenManager.SpriteBatch; SpriteFont font = ScreenManager.Font; Vector2 iconWidth = new Vector2(34, 0); Vector2 iconOffset = new Vector2(0, 12); Vector2 iconPosition = position + iconOffset; // Draw the "is ready" icon. if (gamer.IsReady) { spriteBatch.Draw(isReadyTexture, iconPosition, Color.Lime * TransitionAlpha); } iconPosition += iconWidth; // Draw the "is muted", "is talking", or "has voice" icon. if (gamer.IsMutedByLocalUser) { spriteBatch.Draw(voiceMutedTexture, iconPosition, Color.Red * TransitionAlpha); } else if (gamer.IsTalking) { spriteBatch.Draw(isTalkingTexture, iconPosition, Color.Yellow * TransitionAlpha); } else if (gamer.HasVoice) { spriteBatch.Draw(hasVoiceTexture, iconPosition, Color.White * TransitionAlpha); } // Draw the gamertag, normally in white, but yellow for local players. string text = gamer.Gamertag; if (gamer.IsHost) text += Resources.HostSuffix; Color color = (gamer.IsLocal) ? Color.Yellow : Color.White; spriteBatch.DrawString(font, text, position + iconWidth * 2, color * TransitionAlpha); }
public GamerLeftEventArgs(NetworkGamer aGamer) { this.gamer = aGamer; }
public int ReceiveData ( PacketReader data, out NetworkGamer sender ) { throw new NotImplementedException(); }
private void SendMessage (NetworkMessageType messageType, byte[] data, SendDataOptions options, NetworkGamer gamer) { NetOutgoingMessage om = peer.CreateMessage (); om.Write ((byte)messageType); om.Write (data); SendMessage (om, options, gamer); }
public GamerLeftEventArgs(NetworkGamer aGamer) { gamer = aGamer; }
public void SendData ( PacketWriter data, SendDataOptions options, NetworkGamer recipient ) { throw new NotImplementedException(); }
public HostChangedEventArgs(NetworkGamer aNewHost, NetworkGamer aOldHost) { this.newHost = aNewHost; this.oldHost = aOldHost; }
/// <summary> /// Update the player data for the sender based on the data in the packet. /// </summary> /// <param name="sender">The sender of the packet.</param> private void UpdatePlayerData(NetworkGamer sender) { if ((networkSession != null) && (networkSession.LocalGamers.Count > 0) && (sender != null)) { PlayerData playerData = sender.Tag as PlayerData; if (playerData != null) { playerData.Deserialize(packetReader); // see if we're still unique // -- this can happen legitimately as we receive introductory data //foreach (LocalNetworkGamer localNetworkGamer in // networkSession.LocalGamers) //{ // PlayerData localPlayerData = // localNetworkGamer.Tag as PlayerData; // if ((localPlayerData != null) && // !Ship.HasUniqueColorIndex(localNetworkGamer, // networkSession)) // { // localPlayerData.ShipColor = Ship.GetNextUniqueColorIndex( // localPlayerData.ShipColor, networkSession); // packetWriter.Write((int)World.PacketTypes.PlayerData); // localPlayerData.Serialize(packetWriter); // networkSession.LocalGamers[0].SendData(packetWriter, // SendDataOptions.ReliableInOrder); // } //} } } }
internal void SendPeerIntroductions (NetworkGamer gamer) { NetConnection playerConnection = null; foreach (NetConnection player in peer.Connections) { if (player.RemoteUniqueIdentifier == gamer.RemoteUniqueIdentifier) { playerConnection = player; } } if (playerConnection == null) { return; } foreach (NetConnection player in peer.Connections) { #if !WINDOWS_PHONE Game.Instance.Log("Introduction sent to: " + player.RemoteEndpoint); #endif NetOutgoingMessage om = peer.CreateMessage (); om.Write ((byte)NetworkMessageType.Introduction); om.Write (playerConnection.RemoteEndpoint.ToString ()); peer.SendMessage (om, player, NetDeliveryMethod.ReliableOrdered); } }
/// <summary> /// Update ship state based on the data in the packet. /// </summary> /// <param name="sender">The sender of the packet.</param> private void UpdateShipData(NetworkGamer sender) { if (sender != null) { PlayerData playerData = sender.Tag as PlayerData; //if ((playerData != null) && (playerData.Ship != null)) //{ // playerData.Ship.Position = packetReader.ReadVector2(); // playerData.Ship.Velocity = packetReader.ReadVector2(); // playerData.Ship.Rotation = packetReader.ReadSingle(); // playerData.Ship.Life = packetReader.ReadSingle(); // playerData.Ship.Shield = packetReader.ReadSingle(); // playerData.Ship.Score = packetReader.ReadInt32(); //} } }
internal void SendData ( byte[] data, SendDataOptions options, NetworkGamer gamer) { this.SendMessage (NetworkMessageType.Data, data, options, gamer); }
/// <summary> /// Draw the specified player's data in the screen - gamertag, etc. /// </summary> /// <param name="totalTime">The total time spent in the game.</param> /// <param name="networkGamer">The player to be drawn.</param> /// <param name="position">The center of the desired location.</param> /// <param name="spriteBatch">The SpriteBatch object used to draw.</param> /// <param name="lobby">If true, drawn "lobby style"</param> public void DrawPlayerData(float totalTime, NetworkGamer networkGamer, Vector2 position, SpriteBatch spriteBatch, bool lobby) { // safety-check the parameters, as they must be valid if (networkGamer == null) { throw new ArgumentNullException("networkGamer"); } if (spriteBatch == null) { throw new ArgumentNullException("spriteBatch"); } // get the player data PlayerData playerData = networkGamer.Tag as PlayerData; if (playerData == null) { return; } // draw the gamertag float playerStringScale = 1.0f; if (networkGamer.IsLocal) { // pulse the scale of local gamers playerStringScale = 1f + 0.08f * (1f + (float)Math.Sin(totalTime * 4f)); } string playerString = networkGamer.Gamertag; //TODO divide colors Color playerColor = Color.Green; Vector2 playerStringSize = playerFont.MeasureString(playerString); Vector2 playerStringPosition = position; spriteBatch.DrawString(playerFont, playerString, playerStringPosition, playerColor, 0f, new Vector2(playerStringSize.X / 2f, playerStringSize.Y / 2f), playerStringScale, SpriteEffects.None, 0f); // draw the chat texture Texture2D chatTexture = null; if (networkGamer.IsMutedByLocalUser) { chatTexture = chatMuteTexture; } else if (networkGamer.IsTalking) { chatTexture = chatTalkingTexture; } else if (networkGamer.HasVoice) { chatTexture = chatAbleTexture; } if (chatTexture != null) { float chatTextureScale = 0.9f * playerStringSize.Y / (float)chatTexture.Height; Vector2 chatTexturePosition = new Vector2(playerStringPosition.X - 1.2f * playerStringSize.X / 2f - 1.1f * chatTextureScale * (float)chatTexture.Width / 2f, playerStringPosition.Y); spriteBatch.Draw(chatTexture, chatTexturePosition, null, Color.White, 0f, new Vector2((float)chatTexture.Width / 2f, (float)chatTexture.Height / 2f), chatTextureScale, SpriteEffects.None, 0f); } // if we're in "lobby mode", draw a sample version of the ship, // and the ready texture if (lobby) { // draw the ship // draw the ready texture if ((readyTexture != null) && networkGamer.IsReady) { float readyTextureScale = 0.9f * playerStringSize.Y / (float)readyTexture.Height; Vector2 readyTexturePosition = new Vector2(playerStringPosition.X + 1.2f * playerStringSize.X / 2f + 2.2f + 1.1f * readyTextureScale * (float)readyTexture.Width / 2f, playerStringPosition.Y); spriteBatch.Draw(readyTexture, readyTexturePosition, null, Color.White, 0f, new Vector2((float)readyTexture.Width / 2f, (float)readyTexture.Height / 2f), readyTextureScale, SpriteEffects.None, 0f); } } else { } }
private void SendMessage (NetOutgoingMessage om, SendDataOptions options, NetworkGamer gamer) { //Console.WriteLine("Data to send: " + data.Length); // foreach (NetConnection player in server.Connections) { // // ... send information about every other player (actually including self) // foreach (NetConnection otherPlayer in server.Connections) { // if (gamer != null && gamer.RemoteUniqueIdentifier != otherPlayer.RemoteUniqueIdentifier) { // continue; // } NetDeliveryMethod ndm = NetDeliveryMethod.Unreliable; switch (options) { case SendDataOptions.Reliable: ndm = NetDeliveryMethod.ReliableSequenced; break; case SendDataOptions.ReliableInOrder: ndm = NetDeliveryMethod.ReliableOrdered; break; case SendDataOptions.InOrder: ndm = NetDeliveryMethod.UnreliableSequenced; break; case SendDataOptions.None: ndm = NetDeliveryMethod.Unknown; break; } // send message //server.SendToAll (om, player, ndm); peer.SendToAll (om, ndm); // } // } }
/// <summary> /// Kill the sender's ship based on data in the packet. /// </summary> /// <param name="sender">The sender of the packet.</param> private void KillShip(NetworkGamer sender) { if (sender != null) { PlayerData playerData = sender.Tag as PlayerData; if ((playerData != null)) { //GameplayObject source = null; //// read the index of the source of the last damage taken //int sourcePlayerIndex = packetReader.ReadInt32(); //if ((sourcePlayerIndex >= 0) && // (sourcePlayerIndex < networkSession.AllGamers.Count)) //{ // PlayerData sourcePlayerData = // networkSession.AllGamers[sourcePlayerIndex].Tag // as PlayerData; // source = sourcePlayerData != null ? sourcePlayerData.Ship : // null; //} //// kill the ship //playerData.Ship.Die(source, false); } } }