/// <summary>
/// Handler the server registers to react to network messages
/// </summary>
void ServerOnDataHandler(object source, NetworkEventArgs n)
{
NetIncomingMessage msg = n.GetData();
NetworkMessageType msgType = n.GetInfo();
if (msgType == NetworkMessageType.LoadFinish)
{
//just ignore the message content for now
_loadedClients++;
if (_loadedClients == _targetClientCount)
{
OnAllLoaded();
}
}
else if (msgType == NetworkMessageType.TankControl)
{
//read from old message
int networkId = msg.ReadInt32(32);
NetworkAction networkAction = (NetworkAction)msg.ReadByte();
//write to new message
NetOutgoingMessage relayMessage = Server.CreateMessage(n.GetData().LengthBits);
relayMessage.Write((byte)NetworkMessageType.TankControl);
relayMessage.Write(networkId, 32);
relayMessage.Write((byte)networkAction);
Server.SendToAll(relayMessage, NetDeliveryMethod.ReliableUnordered);
}
}
protected NetworkMessage(NetworkMessageType messageType, int playerIndex, long currentFrame, T data)
{
this.MessageType = messageType;
this.PlayerIndex = playerIndex;
this.CurrentFrame = currentFrame;
this.Data = data;
}
public static byte[] CreateMovementMessage(NetworkMessageType type, float amount)
{
string json = JsonConvert.SerializeObject(new { Amount = amount });
byte[] clientMessageAsByteArray = Encoding.ASCII.GetBytes(json);
return(AddTypeAndLengthToArray(clientMessageAsByteArray, (byte)type));
}
public static byte[] CreateZeroPayloadMessage(NetworkMessageType type)
{
byte[] message = new byte[2];
message[0] = (byte)type;
message[1] = 0;
return(message);
}
public static NetworkMessage Create(NetworkMessageType type, byte[] body)
{
switch (type)
{
case NetworkMessageType.Ping:
return(new NetworkPing());
case NetworkMessageType.DeviceName:
return(new NetworkDeviceName(body));
case NetworkMessageType.Text:
return(new NetworkText(body));
case NetworkMessageType.RemoteProcedureCall:
return(new NetworkRemoteProcedureCall(body));
case NetworkMessageType.RemoteFileRequest:
return(new NetworkRemoteFileRequest(body));
case NetworkMessageType.RemoteFile:
return(new NetworkRemoteFile(body));
default:
throw new NotSupportedException();
}
}
/// <summary>
/// When the server receives a message from a client, it needs to notify other clients. This is called in
/// all of the Create, Destroy and Update methods but only performs actual logic if running as server.
/// </summary>
/// <param name="entityId">The ID of the affected entity.</param>
/// <param name="ownerId">The owner of the affected entity</param>
/// <param name="payload">The payload from the original message.</param>
/// <param name="action">Type type of message, determining the action to be taken.</param>
private void BroadcastIfServer(long entityId, long ownerId, object payload, NetworkMessageType action)
{
if (Role == NetworkRole.Server)
{
SendDataMessage(entityId, ownerId, payload, action);
}
}
private void FinalizeEncoding()
{
this.networkStream.Write((int)NetworkMessageType.DataEnd);
byte[] receiveBuffer = new byte[65536];
while (true)
{
NetworkMessageType messageType = (NetworkMessageType)this.networkStream.ReadInt32();
if (messageType == NetworkMessageType.DataMessage)
{
int length = this.networkStream.ReadInt32();
while (length > 0)
{
int read = Math.Min(receiveBuffer.Length, length);
this.networkStream.ReadBytes(receiveBuffer, 0, read);
this.outputStream.Write(receiveBuffer, 0, read);
length -= read;
}
}
else if (messageType == NetworkMessageType.DataEnd)
{
break;
}
}
}
public void Setup(int length, NetworkMessageType sendType)
{
this.networkMessage = NetworkMessage.Create(-4, length, sendType);
//Number of chunks needed
receivePartsLength = (length + 4) / 500;
if ((length + 4) % 500 > 0)
{
receivePartsLength++;
}
//Check the send array can fit the chunks
if (receiveParts == null || receiveParts.Length < receivePartsLength)
{
int createLength = 128;
while (receivePartsLength > createLength)
{
createLength = createLength * 4;
}
receiveParts = new bool[createLength];
}
receivePartsLeft = receivePartsLength;
for (int i = 0; i < receivePartsLength; i++)
{
receiveParts[i] = false;
}
}
public PayloadUpdateAlarm(List <string> description, string serial, string updateAt, NetworkMessageType type)
{
this.Serial = serial;
this.Description = description;
this.UpdateAt = updateAt;
this.Type = type;
}
public override void DoUpdate()
{
//-------------------------------------------------------------------------------------------------------------
// After that, process network messages received during the last frame
//-------------------------------------------------------------------------------------------------------------
foreach (byte[] serializedMessage in this.receivedMessages)
{
if (serializedMessage != null && serializedMessage.Length > 0)
{
NetworkMessageType messageType = (NetworkMessageType)serializedMessage[0];
if (messageType == NetworkMessageType.InputBuffer)
{
this.ProcessInputBufferMessage(new InputBufferMessage(serializedMessage));
}
else if (messageType == NetworkMessageType.RandomSeedSynchronization)
{
this.ProcessRandomSeedSynchronizationMessage(new RandomSeedSynchronizationMessage(serializedMessage));
}
else if (messageType == NetworkMessageType.RandomSeedSynchronized)
{
this.ProcessRandomSeedSynchronizedMessage(new RandomSeedSynchronizedMessage(serializedMessage));
}
else if (messageType == NetworkMessageType.Syncronization)
{
this.ProcessSynchronizationMessage(new SynchronizationMessage(serializedMessage));
}
}
}
this.receivedMessages.Clear();
}
public static byte[] CreateMessage(NetworkMessageType type, string token)
{
string message = token;
byte[] clientMessageAsByteArray = Encoding.ASCII.GetBytes(message);
return(AddByteStartOfToArray(clientMessageAsByteArray, (byte)type));
}
public NetworkMessage Create(NetworkMessageType type)
{
if (constructors[(int)type] == null)
return null;
return constructors[(int)type]();
}
// this is a little hacky as there aren't actually any entities to process
// probably a sign that I'm abusing the entity component system. i think the proper
// way to do this is to create a simple entity that just has a component to hold
// a reference to the network agent. that's roughly how it would work in unity.
// might be best to use a TagSystem like for player input?
protected override void ProcessEntities(IDictionary <int, Entity> entities)
{
List <NetIncomingMessage> messages = _networkAgent.ReadMessages();
foreach (NetIncomingMessage netMessage in messages)
{
NetworkMessageType messageType = (NetworkMessageType)Enum.ToObject(typeof(NetworkMessageType), netMessage.ReadByte());
if (messageType == NetworkMessageType.PlayerConnect)
{
PlayerConnectMessage <UmbraEntityType> playerConnectMessage = new PlayerConnectMessage <UmbraEntityType>();
playerConnectMessage.Decode(netMessage);
PlayerConnect(playerConnectMessage);
}
else if (messageType == NetworkMessageType.EntityAdd)
{
EntityAddMessage <UmbraEntityType> addMessage = new EntityAddMessage <UmbraEntityType>();
addMessage.Decode(netMessage);
AddEntity(addMessage);
}
else if (messageType == NetworkMessageType.EntityMove)
{
EntityMoveMessage moveMessage = new EntityMoveMessage();
moveMessage.Decode(netMessage);
MoveEntity(moveMessage);
}
else if (messageType == NetworkMessageType.EntityRemove)
{
EntityRemoveMessage removeMessage = new EntityRemoveMessage();
removeMessage.Decode(netMessage);
RemoveEntity(removeMessage);
}
}
}
/// <summary>
/// When the server receives a message from a client, it needs to notify other clients. This is called in
/// all of the Create, Destroy and Update methods but only performs actual logic if running as server.
/// </summary>
/// <param name="entityId">The ID of the affected entity.</param>
/// <param name="ownerId">The owner of the affected entity</param>
/// <param name="payload">The payload from the original message.</param>
/// <param name="action">Type type of message, determining the action to be taken.</param>
private void BroadcastIfServer(ulong id, object payload, NetworkMessageType action)
{
if (Role == NetworkRole.Server)
{
SendDataMessage(id, payload, action);
}
}
/// <summary>
/// Helper function to control pause for each client
/// </summary>
private void SendPauseCommand(NetworkMessageType networkMessageType, NetworkPauseControl data)
{
NetOutgoingMessage message = Server.CreateMessage();
message.Write((byte)networkMessageType);
message.Write((byte)data);
Server.SendToAll(message, NetDeliveryMethod.ReliableUnordered);
}
public static void SendMessage(NetPeer peer, NetworkMessageType networkMessageType, int data, NetConnection recipient)
{
NetOutgoingMessage message = peer.CreateMessage();
message.Write((byte)networkMessageType);
message.Write(data, 32);
peer.SendMessage(message, recipient, NetDeliveryMethod.ReliableUnordered);
}
public NetworkMessage(NetworkMessageType type, string senderId, string receiverId = "", string message = "")
{
this.Type = type;
this.SenderId = senderId;
this.ReceiverId = receiverId;
this.Message = message;
this.TimeStamp = DateTime.Now.ToString();
}
public NetworkMessage(NetworkMessageType type)
{
stream = new MemoryStream();
writer = new BinaryWriter(stream);
MessageType = type;
writer.Write((byte)MessageType);
}
private void SendMessage(NetworkMessageType messageType, byte[] data, SendDataOptions options, NetworkGamer gamer)
{
NetOutgoingMessage message = ((NetPeer)this.peer).CreateMessage();
message.Write((byte)messageType);
message.Write(data);
this.SendMessage(message, options, gamer);
}
/// <summary>
/// Helper to send data to all clients
/// </summary>
private void SendToAll(NetworkMessageType networkMessageType, int data)
{
NetOutgoingMessage message = Server.CreateMessage();
message.Write((int)networkMessageType, 16);
message.Write(data, 32);
Server.SendToAll(message, NetDeliveryMethod.ReliableUnordered);
}
public NetworkPingEventArgs(NetworkMessageType type, IPEndPoint source, HardwareType hw, string hostname, TimeSpan uptime, float cpu, int dbm, uint net_recv) : base(type, source)
{
HostName = hostname;
HardwareType = hw;
Uptime = uptime;
CPU = cpu;
dBm = dbm;
NetRecv = net_recv;
}
public NetworkMessage Create(NetworkMessageType type)
{
if (constructors[(int)type] == null)
{
return(null);
}
return(constructors[(int)type]());
}
protected INetworkMessageOut CreateMessage(NetworkMessageType type)
{
if (NetworkImplementation == null)
{
throw new NullReferenceException("NetworkImplementation was not initialized.");
}
return(NetworkImplementation.CreateMessage(type));
}
public NetworkMessage(string senderIP, NetworkMessageType type, string senderId, DateTime timestamp, string receiverId = "", string message = "")
{
this.SenderIP = senderIP;
this.Type = type;
this.SenderId = senderId;
this.ReceiverId = receiverId;
this.Message = message;
this.TimeStamp = timestamp.ToString();
}
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 void Update()
{
if (client == null)
{
throw new Exception("net client object is null");
}
NetIncomingMessage msg = null;
while ((msg = client.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
{
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
if (clientDelegate != null)
{
if (status == NetConnectionStatus.Connected)
{
clientDelegate.OnNetworkClientConnect(this, 1);
}
if (status == NetConnectionStatus.Disconnected)
{
clientDelegate.OnNetworkClientDisconnect(this, 1);
}
}
}
break;
case NetIncomingMessageType.Data:
{
NetworkMessageType msgid = (NetworkMessageType)msg.PeekUInt16();
NetworkMessage flmsg = msgFactory.Create(msgid);
if ((clientDelegate != null) && (flmsg != null))
{
flmsg.Read(msg);
clientDelegate.OnNetworkClientMessage(this, flmsg);
}
}
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
default:
break;
}
client.Recycle(msg);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CoCoL.Network.PendingNetworkRequest"/> class for representing a locally created request.
/// </summary>
/// <param name="channelid">The channel to communicate over.</param>
/// <param name="channeldatatype">The datatype on the channel.</param>
/// <param name="type">The message type.</param>
/// <param name="value">The data value, if any.</param>
public PendingNetworkRequest(string channelid, Type channeldatatype, NetworkMessageType type, object value)
{
ChannelID = channelid;
ChannelDataType = channeldatatype;
RequestID = Guid.NewGuid().ToString("N");
SourceID = NetworkConfig.SelfID;
RequestType = type;
Value = value;
NoOffer = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="CoCoL.Network.PendingNetworkRequest"/> class for representing an incoming request.
/// </summary>
/// <param name="channelid">The channel to communicate over.</param>
/// <param name="channeldatatype">The datatype on the channel.</param>
/// <param name="requestid">The request ID.</param>
/// <param name="sourceid">The source ID.</param>
/// <param name="timeout">The request timeout</param>
/// <param name="type">The message type.</param>
/// <param name="value">The data in the message, if any.</param>
/// <param name="nooffer">If set to <c>true</c> the remote end does not have a two-phase instance associated.</param>
public PendingNetworkRequest(string channelid, Type channeldatatype, string requestid, string sourceid, DateTime timeout, NetworkMessageType type, object value, bool nooffer)
{
ChannelID = channelid;
RequestID = requestid;
SourceID = sourceid;
Timeout = timeout;
ChannelDataType = channeldatatype;
RequestType = type;
Value = value;
NoOffer = nooffer;
}
public static Offset <NetworkMessage> CreateNetworkMessage(FlatBufferBuilder builder,
uint id = 0,
NetworkMessageType msg_type = NetworkMessageType.NONE,
int msgOffset = 0)
{
builder.StartObject(3);
NetworkMessage.AddMsg(builder, msgOffset);
NetworkMessage.AddId(builder, id);
NetworkMessage.AddMsgType(builder, msg_type);
return(NetworkMessage.EndNetworkMessage(builder));
}
public void SendToAllClients(byte[] data, NetworkMessageType networkMessageType, SendType sendType)
{
if (client != null && client.IsValid)
{
ulong[] lobbyMemberIDs = client.Lobby.GetMemberIDs();
foreach (ulong steamID in lobbyMemberIDs)
{
SendToClient(steamID, data, (int)networkMessageType, sendType);
}
}
}
/// <summary>
/// Uses the provided entity to compose a data message.
/// ReliableSequenced method is suggested to balance performance with deliverability.
/// </summary>
/// <param name="entity">The entity to build a message from.</param>
/// <param name="action">The type of message to send.</param>
/// <param name="method">Delivery method.</param>
/// <param name="recipient">The recipient connection. Will send to all if null.</param>
private void SendDataMessage(INetworkEntity entity, NetworkMessageType action, NetConnection recipient = null)
{
// clients can't force a message for an entity they don't own
if (Role != NetworkRole.Server && entity.OwnerId != NetworkId)
{
throw new RedGrinException("Cannot send an update for an entity that is not owned by this client!");
}
object payload = entity.GetState();
SendDataMessage(entity.EntityId, entity.OwnerId, payload, action, recipient);
}
public NetMsgDelegate this[NetworkMessageType id]
{
get
{
return handlers[(int)id];
}
set
{
handlers[(int)id] = value;
}
}
private void SendMessage(NetworkMessageType messageType, byte[] data, SendDataOptions options, NetworkGamer gamer)
{
NetOutgoingMessage message = ((NetPeer) this.peer).CreateMessage();
message.Write((byte) messageType);
message.Write(data);
this.SendMessage(message, options, gamer);
}
public static void SendMessage(NetPeer peer, NetworkMessageType networkMessageType, int data, int recipient)
{
SendMessage(peer, networkMessageType, data, peer.Connections[recipient]);
}
private void sendRawData(NetworkMessageType nmt, MemoryStream memStream, object obj)
{
binaryFormatter.Serialize(memStream, obj);
byte[] byteDescriptor = getByteDescriptorFromStream(memStream, nmt);
// Send the message descriptor
this.SendAsync(byteDescriptor, byteDescriptor.Length);
// Send the data
byte[] data = memStream.ToArray();
this.SendAsync(data, data.Length);
}
//
// Handlers for sending network messages
//
private void sendRawData(NetworkMessageType nmt, object obj)
{
MemoryStream memStream = new MemoryStream();
sendRawData(nmt, memStream, obj);
}
private void receiveAsyncProcessing()
{
isReceiving = true;
if (rcvdMode == receivingMode.descriptorReceived)
{
int messageLength = BitConverter.ToInt32(rcvdByteBuffer, 0);
rcvdNetworkMessageType = (NetworkMessageType)BitConverter.ToInt32(rcvdByteBuffer, 4);
resetRcvdVariables();
receiveMessage(messageLength);
}
else if (rcvdMode == receivingMode.messageReceived)
{
byte[] data = new byte[rcvdBufferLength];
Buffer.BlockCopy(rcvdByteBuffer, 0, data, 0, rcvdBufferLength);
rcvdBuffer.Enqueue(new Pair<NetworkMessageType, byte[]>(rcvdNetworkMessageType, data));
receivedMessageHandle.Set();
resetRcvdVariables();
rcvdMode = receivingMode.none;
}
if (rcvdMode == receivingMode.none)
{
resetRcvdVariables();
receiveDescriptor();
}
}
public static void SendMessage(NetPeer peer, NetworkMessageType networkMessageType, int data, NetConnection recipient)
{
NetOutgoingMessage message = peer.CreateMessage();
message.Write((byte)networkMessageType);
message.Write(data, 32);
peer.SendMessage(message, recipient, NetDeliveryMethod.ReliableUnordered);
}
public virtual NetworkMessage Read(NetIncomingMessage msgIn)
{
type = (NetworkMessageType)msgIn.ReadUInt16();
return this;
}
public NetworkMessage(Guid senderID, Guid destinationID, Guid messageID, NetworkMessageType type, byte[] data, int fragment, int fragments, int life)
{
this.senderID = senderID;
this.destinationID = destinationID;
this.type = type;
this.messageID = messageID;
this.fragmentNumber = fragment;
this.fragmentTotal = fragments;
this.lifetime = life;
if (this.FragmentTotal == 1)
{
// Compress the data in a memory stream
using (MemoryStream ms = new MemoryStream())
{
using (GZipStream gzStream = new GZipStream(ms, CompressionMode.Compress, true))
{
gzStream.Write(data, 0, data.Length);
gzStream.Flush();
gzStream.Close();
this.gzData = ms.ToArray();
}
}
}
else
{
this.gzData = new byte[data.Length];
Array.Copy(data, this.gzData, data.Length);
}
}
public void Terminate(bool disconnectionAlreadyBegun, NetworkMessageType nmt, object data)
{
if (networkConnection != null && networkConnection.IsInitialized && isTerminated == false)
{
isTerminated = true;
try
{
bool isWorking = true;
bool received = false;
int state = disconnectionAlreadyBegun ? 2 : 0;
MessageBoxShow("Initiating disconnection of opponent..");
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
int attempts = 0;
while (isWorking && attempts < 4 && stopWatch.ElapsedMilliseconds < 10000)
{
if (state == 1)
{
networkConnection.ReceiveAsync();
received = networkConnection.ReceivedMessageHandle.WaitOne(3000);
if (received)
{
nmt = networkConnection.GetReceivedMessageType();
data = networkConnection.GetReceivedMessageFromQueue();
}
/*else
{
this.AppendMessage("No message received.");
}*/
state = (received) ? 2 : 1;
}
if (state == 0)
{
networkConnection.SendAsync(NetworkMessageType.DisconnectRequest, new DisconnectRequest(DateTime.Now));
AppendMessage("Sending disconnection request..");
state = 1;
}
else if (state == 2)
{
if (nmt == NetworkMessageType.DisconnectRequest)
{
this.AppendMessage("Answering disconnect request..");
networkConnection.SendAsync(NetworkMessageType.DisconnectRequestConfirmation,
new DisconnectRequestConfirmation(DateTime.Now));
networkConnection.AllSentHandle.WaitOne(3000);
isWorking = false;
}
else if (nmt == NetworkMessageType.DisconnectRequestConfirmation)
{
this.AppendMessage("Disconnect request confirmed");
isWorking = false;
}
else if (nmt != NetworkMessageType.None)
{
attempts--; // add for SimulationEvent message and so on
}
}
state = 1;
received = false;
attempts++;
}
this.AppendMessage("Closing connection..");
networkConnection.CloseConnection();
}
catch (SocketException e)
{
DebuggerIX.WriteLine(DebuggerTag.Net, "Terminate", "Disconnection failed. SocketException: " + e.Message);
this.AppendMessage("Connection closed with error message: " + e.Message);
}
this.AppendMessage("Connection closed.");
}
}
/// <summary>
/// Helper to send data to all clients
/// </summary>
private void SendToAll(NetworkMessageType networkMessageType, int data)
{
NetOutgoingMessage message = Server.CreateMessage();
message.Write((int)networkMessageType, 16);
message.Write(data, 32);
Server.SendToAll(message, NetDeliveryMethod.ReliableUnordered);
}
/// <summary>
/// Helper function to control pause for each client
/// </summary>
private void SendPauseCommand(NetworkMessageType networkMessageType, NetworkPauseControl data)
{
NetOutgoingMessage message = Server.CreateMessage();
message.Write((byte)networkMessageType);
message.Write((byte)data);
Server.SendToAll(message, NetDeliveryMethod.ReliableUnordered);
}
public EntityMessage(long entityId, NetworkMessageType messageType)
{
EntityId = entityId;
_messageType = messageType;
}
public NetworkMessage(byte[] bytes)
{
using (BinaryReader reader = new BinaryReader(new MemoryStream(bytes, 0, headerSize)))
{
this.senderID = new Guid(reader.ReadBytes(16));
this.destinationID = new Guid(reader.ReadBytes(16));
this.messageID = new Guid(reader.ReadBytes(16));
this.fragmentNumber = reader.ReadInt32();
this.fragmentTotal = reader.ReadInt32();
this.lifetime = reader.ReadInt32();
this.type = (NetworkMessageType)reader.ReadInt32();
}
int dataLength = bytes.Length - headerSize;
gzData = new byte[dataLength];
Array.Copy(bytes, headerSize, gzData, 0, dataLength);
}
/// <summary>
/// Customer main function
/// </summary>
/// <param name="nmt"></param>
public void SendAsync(NetworkMessageType nmt)
{
SendAsync(nmt, null);
}
public void SendAsync(NetworkMessageType nmt, object data)
{
if (nmt == NetworkMessageType.ListOfEvents)
{
if (outBuffer.Count > 0)
{
this.sendRawData(NetworkMessageType.ListOfEvents, new ListOfEventsMessage((long)data, outBuffer));
outBuffer.Clear();
}
}
else if (nmt == NetworkMessageType.GameChange)
{
if (data == null)
{
throw new InvalidStateException("SendAsync: data is null; expected GameWonMessage instance.");
}
this.sendRawData(NetworkMessageType.GameChange, (GameChangeMessage)data);
}
else if (nmt == NetworkMessageType.Authentication)
{
if (data == null)
{
throw new InvalidStateException("SendAsync: data is null; expected Autentization instance.");
}
this.sendRawData(NetworkMessageType.Authentication, (Authentication)data);
}
else if (nmt == NetworkMessageType.SimulationTime)
{
if (data == null)
{
throw new InvalidStateException("SendAsync: data is null; expected SimulationTimeMessage instance.");
}
this.sendRawData(NetworkMessageType.SimulationTime, (ListOfEventsMessage)data);
}
else if (nmt == NetworkMessageType.DisconnectRequest)
{
DisconnectRequest disconnectRequest = new DisconnectRequest(DateTime.Now);
this.sendRawData(NetworkMessageType.DisconnectRequest, disconnectRequest);
}
else if (nmt == NetworkMessageType.DisconnectRequestConfirmation)
{
DisconnectRequestConfirmation disconnectRequest = new DisconnectRequestConfirmation(DateTime.Now);
this.sendRawData(NetworkMessageType.DisconnectRequestConfirmation, disconnectRequest);
}
else if (nmt == NetworkMessageType.StartGame)
{
StartGame startGame = new StartGame(DateTime.Now);
this.sendRawData(NetworkMessageType.StartGame, startGame);
}
}
private byte[] getByteDescriptorFromStream(MemoryStream stream, NetworkMessageType nmt)
{
byte[] outByteBuffer = new byte[stream.Length];
stream.Read(outByteBuffer, 0, (int)stream.Length);
BitConverter.GetBytes(outByteBuffer.Length).CopyTo(outByteDescriptor, 0);
BitConverter.GetBytes((int)nmt).CopyTo(outByteDescriptor, 4);
return outByteDescriptor;
}
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 NetworkEventArgs(NetIncomingMessage data, NetworkMessageType info)
{
_data = data;
_info = info;
}
