private void SendDiscoveryResponse(IPEndPoint ip)
{
NetOutgoingMessage response;
switch (_config.SysType)
{
case SysType.Peer:
response = _netPeer.CreateMessage();
response.Write(_peerIDString);
_netPeer.SendDiscoveryResponse(response, ip);
break;
case SysType.Client:
response = _netClient.CreateMessage();
response.Write(_peerIDString);
_netClient.SendDiscoveryResponse(response, ip);
break;
case SysType.Server:
response = _netServer.CreateMessage();
response.Write(_peerIDString);
_netServer.SendDiscoveryResponse(response, ip);
break;
}
}
/// <summary>
/// Reads every message in the queue and returns a list of data messages.
/// Other message types just write a Console note.
/// This should be called every update by the Game Screen
/// The Game Screen should implement the actual handling of messages.
/// </summary>
/// <returns></returns>
public List <NetIncomingMessage> CheckForMessages()
{
mIncomingMessages.Clear();
NetIncomingMessage incomingMessage;
string output = "";
while ((incomingMessage = mPeer.ReadMessage()) != null)
{
switch (incomingMessage.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
mPeer.SendDiscoveryResponse(null, incomingMessage.SenderEndPoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
if (mRole == AgentRole.Server)
{
output += incomingMessage.ReadString() + "\n";
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)incomingMessage.ReadByte();
if (mRole == AgentRole.Server)
{
output += "Status Message: " + incomingMessage.ReadString() + " \n";
}
if (status == NetConnectionStatus.Connected)
{
//PLAYER CONNECTED
//Message to send the player their ID
NetOutgoingMessage idMessage = mPeer.CreateMessage();
idMessage.Write((byte)MessageType.PlayerID);
idMessage.Write(nextPlayerID++);
mPeer.SendMessage(idMessage, incomingMessage.SenderConnection, NetDeliveryMethod.ReliableOrdered);
IsPlayerConnected = true;
}
break;
case NetIncomingMessageType.Data:
mIncomingMessages.Add(incomingMessage);
break;
default:
// unknown message type
break;
}
}
if (mRole == AgentRole.Server)
{
StreamWriter textOut = new StreamWriter(new FileStream("log.txt", FileMode.Append, FileAccess.Write));
textOut.Write(output);
textOut.Close();
}
return(mIncomingMessages);
}
void ReadInData()
{
NetworkMessage client_input = new NetworkMessage();
NetIncomingMessage im;
while ((im = server.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.Data:
byte[] msg = im.ReadBytes(im.LengthBytes);
client_input = NetworkMessage.Deserialize(msg);
OutputQueue.AddToQueue(client_input.GetData());
Debug.WriteLine(msg);
break;
case NetIncomingMessageType.DiscoveryRequest:
// Create a response
NetOutgoingMessage om = server.CreateMessage();
om.Write("Connecting to DOG server");
server.SendDiscoveryResponse(om, im.SenderEndPoint);
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("Received from " + im.SenderEndPoint + ": " + im.ReadString() + Environment.NewLine);
break;
}
server.Recycle(im);
}
}
//////////////////////////////////////////////////////////////////////////////
#region Inheritance
protected override bool HandleMessage(NetPeer peer, NetIncomingMessage msg)
{
if (base.HandleMessage(peer, msg))
{
return(true);
}
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
{
if (m_respondsToDiscovery)
{
NetOutgoingMessage message = peer.CreateMessage();
PostNotificationImmediately(NetworkNotifications.LocalClientDiscovered, message);
peer.SendDiscoveryResponse(message, msg.SenderEndPoint);
return(true);
}
return(false);
}
}
return(false);
}
public Object Listener() // Listens for incoming messages on your peer port.
{
NetIncomingMessage message = peer.ReadMessage(); // Reads any incoming messages assuming there are any.
if (message != null) // Makes sure there actually is a message.
{
switch (message.MessageType) // Checks for the message type that we grabbed above.
{
case NetIncomingMessageType.DiscoveryRequest: // Someone is looking for you because they requested this port number.
NetOutgoingMessage res = peer.CreateMessage(); // Creates a response / packet to send back.
res.Write("Here!"); // Replies with "Here!" in theory you could customize this for different networks to choose what to do
peer.SendDiscoveryResponse(res, message.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse: // Your request was received and you got a response back.
peer.Connect(message.SenderEndPoint); // Since you got a message back you connect to the end point.
break;
case NetIncomingMessageType.Data: // You received Data or an update from a peer
return(DeserializeData(message.ReadBytes(message.LengthBytes)));
}
}
return(null);
}
public void HandleWebConnections()
{
NetIncomingMessage message;
while ((message = peer.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
HandleData(message);
break;
case NetIncomingMessageType.StatusChanged:
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
Debug.WriteLine("Connected!");
break;
case NetConnectionStatus.Disconnected:
Debug.WriteLine("Disconnected...");
break;
}
break;
case NetIncomingMessageType.ConnectionApproval:
message.SenderConnection.Approve();
break;
case NetIncomingMessageType.DiscoveryResponse:
peer.Connect(message.SenderEndPoint);
connecting = false;
break;
case NetIncomingMessageType.DiscoveryRequest:
var msg = peer.CreateMessage();
msg.Write("hi");
peer.SendDiscoveryResponse(msg, message.SenderEndPoint);
peer.Connect(message.SenderEndPoint);
isServer = true;
break;
case NetIncomingMessageType.DebugMessage:
Debug.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.WriteLine(message.ReadString());
break;
default:
Debug.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
peer.Recycle(message);
}
}
private static void Main(string[] args)
{
map.generate();
Console.WriteLine(("Enter Server name:"));
var name = Console.ReadLine();
var config = new NetPeerConfiguration("PythonRouge")
{
Port = 32078
};
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
Server = new NetServer(config);
Server.Start();
Console.WriteLine("Ready");
NetIncomingMessage msg;
while (true)
{
while ((msg = Server.ReadMessage()) != null)
{
Console.WriteLine("Got Message");
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
string reason = msg.ReadString();
Console.WriteLine(status + " " + reason);
break;
case NetIncomingMessageType.ConnectionApproval:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.Data:
msgHandler(msg);
break;
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.DiscoveryRequest:
// Create a response and write some example data to it
NetOutgoingMessage response = Server.CreateMessage();
Console.WriteLine("Client request");
response.Write(name);
// Send the response to the sender of the request
Server.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
Server.Recycle(msg);
}
}
}
static void Main(string[] args)
{
var config = new NetPeerConfiguration("MultiPlayer");
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
config.AcceptIncomingConnections = true;
config.Port = 5002;
var Me = new NetPeer(config);
Me.Start();
Me.DiscoverLocalPeers(5001);
while (true)
{
NetIncomingMessage message;
while ((message = Me.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
Console.WriteLine(message.ReadString());
break;
case NetIncomingMessageType.DiscoveryRequest:
var response = Me.CreateMessage("Uuum hi..?");
Me.SendDiscoveryResponse(response, message.SenderEndPoint);
Console.WriteLine($"Someone at {message.SenderEndPoint.Address} is attempting to discover us!");
break;
case NetIncomingMessageType.DiscoveryResponse:
Me.Connect(message.SenderEndPoint);
Console.WriteLine($"Peer discovered at {message.SenderEndPoint.Address}. Attempting to connect.");
//TODO connect?
break;
case NetIncomingMessageType.ConnectionApproval:
message.SenderConnection.Approve();
Console.WriteLine($"Uuum. Someone connected. I don't really know what to do now...");
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine(message.ReadString());
break;
default:
Console.WriteLine(message.ReadString());
break;
}
}
}
}
public static void HandlePeerMessages(object peer)
{
if (peer is NetPeer)
{
NetPeer p = ((NetPeer)peer);
NetIncomingMessage msg = ((NetPeer)peer).ReadMessage();
string machineName;
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
if (!peers.ContainsKey(msg.SenderEndpoint))
{
Console.WriteLine("DiscoveryRequest from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port);
NetOutgoingMessage requestResponse = p.CreateMessage();
requestResponse.Write(Environment.MachineName);
p.SendDiscoveryResponse(requestResponse, msg.SenderEndpoint);
}
break;
case NetIncomingMessageType.DiscoveryResponse:
machineName = msg.ReadString();
Boolean connectedToPeer = false;
foreach (NetConnection conn in p.Connections)
{
if (conn.RemoteEndpoint == msg.SenderEndpoint)
{
connectedToPeer = true;
}
}
if (!connectedToPeer)
{
if (!peers.ContainsKey(msg.SenderEndpoint))
{
Console.WriteLine("DiscoveryResponse from " + msg.SenderEndpoint.Address + " port: " + msg.SenderEndpoint.Port +
" machine name: " + machineName);
peers.Add(msg.SenderEndpoint, machineName);
}
NetOutgoingMessage hailMessage = p.CreateMessage();
hailMessage.Write(Environment.MachineName);
NetConnection senderConn = p.Connect(msg.SenderEndpoint, hailMessage);
}
break;
}
p.Recycle(msg);
}
}
public List <NetIncomingMessage> ReadMessages()
{
_incomingMessages.Clear();
NetIncomingMessage msg;
while ((msg = _peer.ReadMessage()) != null)
{
//Log("Received " + msg.MessageType + " message");
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
_peer.SendDiscoveryResponse(null, msg.SenderEndpoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
if (_role == AgentRole.Server)
{
Log(msg.ReadString());
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
Log("Status message: " + msg.ReadString());
if (status == NetConnectionStatus.Connected)
{
OnPlayerConnect(msg.SenderConnection);
}
else if (status == NetConnectionStatus.Disconnected)
{
OnPlayerDisconnect(msg.SenderConnection);
}
break;
case NetIncomingMessageType.Data:
_incomingMessages.Add(msg);
break;
default:
Log("ERROR: Unknown message type");
break;
}
}
return(_incomingMessages);
}
public void HandleMessage(NetIncomingMessage message, ref bool recycle)
{
Debug.Assert(!didDisconnect);
RemotePeer senderRemotePeer = null;
if (message.SenderConnection != null)
{
senderRemotePeer = message.SenderConnection.Tag as RemotePeer;
}
try
{
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest: // (Clients trying to find LAN games)
{
var response = NetPeer.CreateMessage();
DiscoveredGame.WriteDiscoveryResponse(owner.appConfig, response, owner.GameInfo, IsFull, owner.NetworkApplication.GetDiscoveryData());
NetPeer.SendDiscoveryResponse(response, message.SenderEndPoint);
}
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
switch (status)
{
case NetConnectionStatus.Connected:
HandleConnection(message.SenderConnection);
break;
case NetConnectionStatus.Disconnected:
HandleDisconnection(message.SenderConnection, message);
break;
}
break;
case NetIncomingMessageType.UnconnectedData:
HandleUnconnectedMessage(message);
break;
case NetIncomingMessageType.Data:
HandleNetworkManagementFromClient(message);
break;
}
}
catch (NetworkDataException exception)
{
NetworkDataError(senderRemotePeer, exception);
}
}
void HandleWebConnections()
{
NetIncomingMessage message;
while ((message = peer.ReadMessage()) != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.Data:
// data code
break;
case NetIncomingMessageType.StatusChanged:
switch (message.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
Debug.WriteLine("Connected!");
break;
case NetConnectionStatus.Disconnected:
ship2 = null;
Debug.WriteLine("Disconnected...");
break;
}
break;
case NetIncomingMessageType.DiscoveryResponse:
peer.Connect("176.135.163.41", 8000, peer.CreateMessage("yes"));
break;
case NetIncomingMessageType.DiscoveryRequest:
var msg = peer.CreateMessage();
msg.Write("hi");
peer.SendDiscoveryResponse(msg, message.SenderEndPoint);
break;
case NetIncomingMessageType.DebugMessage:
Console.WriteLine(message.ReadString());
break;
default:
Console.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
peer.Recycle(message);
}
}
internal static void SendRequestHostsResponse(NetPeer peer, IPEndPoint recipientEndPoint, bool localDiscovery, Guid guid, NetworkSessionPublicInfo publicInfo)
{
var response = peer.CreateMessage();
response.Write((byte)MasterServerMessageType.RequestHosts);
response.Write((byte)MasterServerMessageResult.Ok);
response.Write(guid.ToString());
publicInfo.Pack(response);
if (localDiscovery)
{
peer.SendDiscoveryResponse(response, recipientEndPoint);
}
else
{
peer.SendUnconnectedMessage(response, recipientEndPoint);
}
}
public static void RecvMCS()
{
while (true)
{
Thread.Sleep(10);
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
Console.WriteLine(((NetConnectionStatus)msg.ReadByte()).ToString());
break;
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage response = server.CreateMessage();
response.Write("Server InduZtry");
server.SendDiscoveryResponse(response, msg.SenderEndPoint);
recipient = server.Connect(msg.SenderEndPoint);
Console.WriteLine("Discovered Peer " + msg.SenderEndPoint);
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
server.Recycle(msg);
}
}
}
public void messageStream()
{
while (isActive)
{
if (watch == null)
{
watch = Stopwatch.StartNew();
}
else
{
watch.Reset();
}
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
addToLog("Discovery Request from ip: " + msg.SenderEndPoint.Address.ToString());
NetOutgoingMessage resp = peer.CreateMessage();
resp.Write(playerName);
peer.SendDiscoveryResponse(resp, msg.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse:
addToLog("Discovery Response from player: " + msg.ReadString());
peer.Connect(msg.SenderEndPoint);
isConnected = true;
break;
case NetIncomingMessageType.ConnectionApproval:
msg.SenderConnection.Approve();
NetOutgoingMessage send = this.createPeerInfo(msg.SenderEndPoint, "");
break;
case NetIncomingMessageType.Data:
try{
int messageType = (int)msg.ReadByte();
if (((MessageType)messageType) == MessageType.File)
{
string[] gameInfo = TransferLogic.getFileInfo(msg); //sets msg cursor at files contents
TransferLogic logic = TransferLogic.instantiateTransfer(gameInfo);
TransferLogic.createGameStructure(gameInfo[1]);
user.CurrentGame = gameInfo[1];
if (logic != null)
{
byte[] contents = msg.ReadBytes(logic.length);
logic.writeFile(contents);
logic.copyToGameFile();
}
}
else if (((MessageType)messageType) == MessageType.FileUpdate)
{
string length = TransferLogic.getNextPart(msg);
int len;
if (int.TryParse(length, out len))
{
TransferLogic logic = new TransferLogic("persistent.sfs", user.CurrentGame, FileType.PERSISTENT, len);
logic.readSaveUpdate(msg);
}
}
}catch (Exception e) { Console.WriteLine(e.Message); }
break;
case NetIncomingMessageType.UnconnectedData:
break;
case NetIncomingMessageType.StatusChanged:
break;
default:
break;
}
}
lock (_taskLock) {
if (sendTasks.Count > 0)
{
MultiplayerTask send = sendTasks.Dequeue();
send.peer = new MultiplayerTask.Peer();
send.peer.playerName = this.playerName;
send.peer.connect = false;
NetOutgoingMessage snd = peer.CreateMessage();
snd.Write(JsonConvert.SerializeObject(send));
}
}
watch.Stop();
long elapsed = watch.ElapsedMilliseconds;
Thread.Sleep(1000 / networkRate - (int)elapsed);
}
}
public void ProcessNet()
{
// read messages
while (!shouldQuit)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
//Request from other peers
case NetIncomingMessageType.DiscoveryRequest:
if (allowDiscovery)
{
NetOutgoingMessage response = peer.CreateMessage();
response.Write(name);
response.Write(peer.UniqueIdentifier.ToString());
//Send the response to the sender of the request
peer.SendDiscoveryResponse(response, msg.SenderEndPoint);
}
break;
case NetIncomingMessageType.DiscoveryResponse:
string peerName = msg.ReadString();
string peerUniqueId;
try
{
peerUniqueId = msg.ReadString();
}
catch (Exception error)
{
peerUniqueId = "HighNoon";
}
string myId = peer.UniqueIdentifier.ToString(); //returns "random" no.
if (myId != peerUniqueId) // if (name == peerName)
{
msg.Write(peerName);
msg.Write(peerUniqueId);
if (isNewOpponent(peerName, peerUniqueId))
{
}
;
foundPeers.Add(msg);
OpponentEventArgs opponent = new OpponentEventArgs();
opponent.opponentName = peerName;
if (peerUniqueId == "HighNoon")
{
NetOutgoingMessage response = peer.CreateMessage();
response.Write(name);
peer.SendDiscoveryResponse(response, msg.SenderEndPoint);
}
onOpponentDetected(opponent);
}
break;
case NetIncomingMessageType.ConnectionApproval: //This means that we are being challenged
if (allowDiscovery)
{
int charNum = 0;
string challengerName = msg.ReadString();
try
{
charNum = msg.ReadInt32();
}
catch (Exception ex)
{
}
ChallengeEventArgs receivedChallenge = new ChallengeEventArgs();
receivedChallenge.challengerName = challengerName;
receivedChallenge.characterNumber = charNum;
msg.Write(challengerName);
challenger = msg;
onChallengeReceived(receivedChallenge);
}
else
{
msg.SenderConnection.Deny();
}
break;
case NetIncomingMessageType.StatusChanged:
//Got rid of if statements here
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
ConnectionEventArgs connectionStatus = new ConnectionEventArgs();
if (status == NetConnectionStatus.Connected)
{
challenger = msg;
allowDiscovery = false;
connectionStatus.connected = true;
connectionStatus.message = "Connected";
onConnected(connectionStatus);
NetOutgoingMessage piece = peer.CreateMessage();
if (goFirst)
{
piece.Write((int)6);
piece.Write("Light");
}
else
{
piece.Write((int)6);
piece.Write("Dark");
}
piece.Write(name);
peer.SendMessage(piece, challenger.SenderConnection, NetDeliveryMethod.ReliableOrdered);
//MessageBox.Show("You are Connected!");
}
if (status == NetConnectionStatus.Disconnected)
{
string reason = msg.ReadString();
allowDiscovery = true;
connectionStatus.connected = false;
connectionStatus.message = reason;
onDisconnected(connectionStatus);
//MessageBox.Show("Something happened :( " + reason);
}
break;
case NetIncomingMessageType.Data:
//Reads what kind of protocol inside the message received
int command = msg.ReadInt32();
// Message transmission
if (command == (int)Protocol.Type.chatMessage)
{
MessageEventArgs message = new MessageEventArgs();
message.text = msg.ReadString();
onMessageReceived(message);
//MessageBox.Show("Message: " + message.text);
}
// Move transmission
if (command == (int)Protocol.Type.move)
{
string playerName = msg.ReadString();
string gameType = msg.ReadString();
int fromRow;
int fromCol;
int toRow;
int toCol;
//Trying for Locomotion
if (gameType == "Locomotion")
{
fromRow = msg.ReadInt32();
fromCol = msg.ReadInt32();
toRow = msg.ReadInt32();
toCol = msg.ReadInt32();
}
else //If not
{
string HighNoonMove = msg.ReadString();
fromRow = 6 - int.Parse(HighNoonMove[0].ToString());
fromCol = int.Parse(HighNoonMove[1].ToString());
toRow = 6 - int.Parse(HighNoonMove[2].ToString());
toCol = int.Parse(HighNoonMove[3].ToString());
}
MoveEventArgs move = new MoveEventArgs();
move.playerName = playerName;
move.fromRow = fromRow;
move.fromCol = fromCol;
move.toRow = toRow;
move.toCol = toCol;
onMoveReceived(move);
//MessageBox.Show("From:" + fromRow.ToString() + fromCol.ToString() + " to " + toRow.ToString() + toCol.ToString());
}
break;
default:
//
break;
}
}
}
//Console.WriteLine("Exiting net thread!");
}
/// <summary> Message loop to check type of message and handle it accordingly </summary>
public void MessageLoop()
{
while ((_msg = _peer.ReadMessage()) != null)
{
s_bpsBytes += _msg.LengthBytes;
switch (_msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
//Debug.WriteLine("ReceivePeersData DiscoveryRequest");
_peer.SendDiscoveryResponse(null, _msg.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse:
// just connect to first server discovered
//Debug.WriteLine("ReceivePeersData DiscoveryResponse CONNECT");
if (_peer.Connections.Any(x => x.RemoteEndPoint.Address.Equals(_msg.SenderEndPoint.Address)))
{
Debug.WriteLine("allreadyConnected");
}
else
{
_peer.Connect(_msg.SenderEndPoint);
}
break;
case NetIncomingMessageType.ConnectionApproval:
//Debug.WriteLine("ReceivePeersData ConnectionApproval");
_msg.SenderConnection.Approve();
//broadcast this to all connected clients
SendPeerInfo(_msg.SenderEndPoint.Address, _msg.SenderEndPoint.Port);
break;
case NetIncomingMessageType.Data:
//another client sent us data
//Read TypeData First
Enums.MessageType mType = (Enums.MessageType)_msg.ReadByte();
if (mType == Enums.MessageType.String)
{
var metadata = _msg.ReadString();
if (metadata == "StartEvent")
{
var map = _msg.ReadString();
_isMaster = false;
MasterNetConnection = _peer.Connections.FirstOrDefault(x => x.RemoteEndPoint.Address.ToString() == _msg.SenderEndPoint.Address.ToString());
Game1.Inst.Scene.Raise("startgame", map);
}
else if (metadata == "metadata")
{
Game1.Inst.Scene.Raise("network_data_text", _msg.ReadString());
}
}
else if (mType == Enums.MessageType.PeerInformation)
{
int byteLenth = _msg.ReadInt32();
byte[] addressBytes = _msg.ReadBytes(byteLenth);
IPAddress ip = new IPAddress(addressBytes);
int port = _msg.ReadInt32();
//connect
IPEndPoint endPoint = new IPEndPoint(ip, port);
Debug.WriteLine("Data::PeerInfo::Detecting if we're connected");
if (_peer.GetConnection(endPoint) == null)
{ //are we already connected?
//Don't try to connect to ourself!
if (_peer.Configuration.LocalAddress.GetHashCode() != endPoint.Address.GetHashCode() ||
_peer.Configuration.Port.GetHashCode() != endPoint.Port.GetHashCode())
{
Debug.WriteLine(string.Format("Data::PeerInfo::Initiate new connection to: {0}:{1}", endPoint.Address.ToString(), endPoint.Port.ToString()));
_peer.Connect(endPoint);
}
}
}
else if (mType == Enums.MessageType.Entity || mType == Enums.MessageType.EntityLight)
{
var cbody = new CBody();
var ctransform = new CTransform();
string modelname = "";
bool isPlayer = false;
int id = 0;
id = mType == Enums.MessageType.EntityLight ? _msg.ReadEntityLight(ref cbody, ref ctransform, ref modelname, ref isPlayer) : _msg.ReadEntity(ref cbody, ref ctransform, ref modelname, ref isPlayer);
Game1.Inst.Scene.Raise("entityupdate", new EntitySync {
ID = id, CBody = cbody, CTransform = ctransform, ModelFileName = modelname, IsPlayer = isPlayer
});
}
else if (mType == Enums.MessageType.CTransform)
{
var metadata = _msg.ReadString();
var data = _msg.ReadCTransform();
//Game1.Inst.Scene.Raise("network_data", data);
}
else if (mType == Enums.MessageType.Vector3)
{
var metadata = _msg.ReadString();
var data = _msg.ReadCTransform();
//Game1.Inst.Scene.Raise("network_data", data);
}
else if (mType == Enums.MessageType.CText)
{
var id = _msg.ReadInt32();
var data = _msg.ReadCText();
Game1.Inst.Scene.Raise("network_menu_data_received", new MenuItem {
CText = data, Id = id
});
}
else if (mType == Enums.MessageType.Int32)
{
var metadata = _msg.ReadString();
var data = _msg.ReadInt32();
if (metadata == "network_game_end")
{
Game1.Inst.Scene.Raise("game_end", data);
}
}
else if (mType == Enums.MessageType.PlayerInfo)
{
var date = _msg.ReadInt64();
if (!players.Any(x => x.IP == _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString()))
{
players.Add(new NetworkPlayer {
IP = _msg.SenderEndPoint.Address.ToString() + " " + _msg.SenderEndPoint.Port.ToString(), Time = new DateTime(date), You = false
});
Game1.Inst.Scene.Raise("update_peers", players.OrderBy(x => x.Time).ToList());
}
}
//Console.WriteLine("END ReceivePeersData Data");
break;
case NetIncomingMessageType.UnconnectedData:
Debug.WriteLine("UnconnectedData: " + _msg.ReadString());
break;
case NetIncomingMessageType.VerboseDebugMessage:
Debug.WriteLine(NetIncomingMessageType.VerboseDebugMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
Debug.WriteLine(NetIncomingMessageType.DebugMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.WriteLine(NetIncomingMessageType.WarningMessage + " " + _msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Debug.WriteLine(NetIncomingMessageType.ErrorMessage + " " + _msg.ReadString());
break;
default:
Debug.WriteLine("ReceivePeersData Unknown type: " + _msg.MessageType.ToString());
try
{
Debug.WriteLine(_msg.SenderConnection);
if (_msg.SenderConnection.Status == NetConnectionStatus.Disconnected)
{
//Maybe try to reconnect
}
Debug.WriteLine(_msg.ReadString());
}
catch
{
Debug.WriteLine("Couldn't parse unknown to string.");
}
break;
}
}
}
/// <summary>
/// Handles when the server has received a message
/// </summary>
private void MessageReceived(object peer)
{
// Get the incoming message
NetIncomingMessage inMsg = ((NetPeer)peer).ReadMessage();
// We don't want the server to crash on one bad packet
try
{
// Determine the message type to correctly handle it
switch (inMsg.MessageType)
{
// Handle when a client's status has changed
case NetIncomingMessageType.StatusChanged:
// Gets the status and reason
NetConnectionStatus status = (NetConnectionStatus)inMsg.ReadByte();
string reason = inMsg.ReadString();
// Depending on the status, we handle players joining or leaving
switch (status)
{
// A player has disconnected
case NetConnectionStatus.Disconnected:
PlayerLeft(myPlayers[inMsg.SenderConnection], reason);
break;
// A player is connecting
case NetConnectionStatus.Connected:
// Send the welcome packet
SendWelcomePacket(myPlayers[inMsg.SenderConnection].PlayerId);
break;
}
// Log the message
Log("Connection status updated for connection from {0}: {1}", inMsg.SenderEndPoint, status);
break;
// Handle when a player is trying to join
case NetIncomingMessageType.ConnectionApproval:
if (IsSinglePlayerMode & (inMsg.SenderEndPoint.Address.ToString() != myAddress.ToString() || myPlayers.Where(X => !X.IsBot).Count() > 0))
{
inMsg.SenderConnection.Deny("Server is in singleplayer mode");
break;
}
// Get the client's info an hashed password from the packet
ClientTag clientTag = ClientTag.ReadFromPacket(inMsg);
string hashedPass = inMsg.ReadString();
// Make sure we are in the lobby when joining new players
if (myState == ServerState.InLobby)
{
// Check the password if applicable
if ((myTag.PasswordProtected && myPassword.Equals(hashedPass)) | (!myTag.PasswordProtected))
{
// Check to see if the lobby is full
if (myPlayers.GetNextAvailableId() != -1)
{
// Go ahead and try to join that playa
PlayerJoined(clientTag, inMsg.SenderConnection);
Log("Player \"{0}\" joined from {1}", clientTag.Name, clientTag.Address);
}
else
{
// Deny connection if lobby is full
inMsg.SenderConnection.Deny("Game is full");
Log("Player \"{0}\" was denied access to full game from {1}", clientTag.Name, clientTag.Address);
}
}
else
{
// F**k you brah!
inMsg.SenderConnection.Deny("Password authentication failed");
Log("Player \"{0}\" failed to connect (password failed) from {1}", clientTag.Name, clientTag.Address);
}
}
else
{
// We are mid-way through a game
inMsg.SenderConnection.Deny("Game has already started");
Log("Player \"{0}\" attempted to connect mid game from {1}", clientTag.Name, clientTag.Address);
}
break;
// Handle when the server has received a discovery request
case NetIncomingMessageType.DiscoveryRequest:
// Make sure our tag is up to date
myTag.PlayerCount = myPlayers.PlayerCount;
myTag.SupportedPlayerCount = myPlayers.Count;
if (!IsSinglePlayerMode && State == ServerState.InLobby)
{
// Prepare the response
NetOutgoingMessage msg = myServer.CreateMessage();
// Write the tag to the response
myTag.WriteToPacket(msg);
// Send the response
myServer.SendDiscoveryResponse(msg, inMsg.SenderEndPoint);
Log("Pinged discovery response to {0}", inMsg.SenderEndPoint);
}
break;
// Handles when the server has received data
case NetIncomingMessageType.Data:
HandleMessage(inMsg);
break;
}
}
// An exception has occured parsing the packet
catch (Exception e)
{
// Log the exception
Log("Encountered exception parsing packet from {0}:\n\t{1}", inMsg.SenderEndPoint, e);
Logger.Write(e);
}
PumpMessages();
}
private void TimerUpdate(object sender, EventArgs e)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
HandleIncomingMessage(msg);
break;
case NetIncomingMessageType.DiscoveryResponse:
LogText("Connected to server: " + msg.SenderEndPoint);
peer.Connect(msg.SenderEndPoint.Address.ToString(), mPort);
foundServer = true;
break;
case NetIncomingMessageType.DiscoveryRequest:
LogText("Client connected.");
NetOutgoingMessage response = peer.CreateMessage();
peer.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
LogText(msg.ReadString());
break;
//case NetIncomingMessageType.StatusChanged:
// msg.ReadByte();
// string reason = msg.ReadString();
// LogText(reason);
// break;
//default:
// LogText(msg.MessageType.ToString());
// break;
}
}
if (mReadyToSendMore)
{
if (mFileStreamIn != null)
{
SendSegment();
}
else if (mFileQueue.Count > 0)
{
SendFile(mFileQueue[0]);
mFileQueue.RemoveAt(0);
}
}
if (!foundServer && stopWatch.Elapsed > TimeSpan.FromSeconds(1.0))
{
stopWatch.Stop();
LogText("No server found, creating one.");
StartServer();
}
}
static void Main(string[] args)
{
Dictionary <long, IPEndPoint[]> registeredHosts = new Dictionary <long, IPEndPoint[]>();
NetPeerConfiguration config = new NetPeerConfiguration("master");
config.SetMessageTypeEnabled(NetIncomingMessageType.UnconnectedData, true);
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.Port = 15002;
NetPeer peer = new NetPeer(config);
peer.Start();
// keep going until ESCAPE is pressed
Console.WriteLine("Press ESC to quit");
while (!Console.KeyAvailable || Console.ReadKey().Key != ConsoleKey.Escape)
{
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
Console.WriteLine("Discover message from: " + msg.SenderEndPoint);
// Create a response and write some example data to it
NetOutgoingMessage response = peer.CreateMessage();
response.Write("master");
// Send the response to the sender of the request
peer.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
case NetIncomingMessageType.UnconnectedData:
//
// We've received a message from a client or a host
//
// by design, the first byte always indicates action
switch ((MasterServerMessageType)msg.ReadByte())
{
case MasterServerMessageType.RegisterHost:
// It's a host wanting to register its presence
var id = msg.ReadInt64(); // server unique identifier
Console.WriteLine("Got registration for host " + id);
registeredHosts[id] = new IPEndPoint[]
{
msg.ReadIPEndPoint(), // internal
msg.SenderEndPoint // external
};
break;
case MasterServerMessageType.RequestHostList:
// It's a client wanting a list of registered hosts
Console.WriteLine("Sending list of " + registeredHosts.Count + " hosts to client " + msg.SenderEndPoint);
// Clear original list.
NetOutgoingMessage outMsg = peer.CreateMessage();
outMsg.Write(true);
peer.SendUnconnectedMessage(outMsg, msg.SenderEndPoint);
foreach (var kvp in registeredHosts)
{
// send registered host to client
NetOutgoingMessage om = peer.CreateMessage();
om.Write(false);
om.Write(kvp.Key);
om.Write(kvp.Value[0]);
om.Write(kvp.Value[1]);
peer.SendUnconnectedMessage(om, msg.SenderEndPoint);
}
break;
case MasterServerMessageType.RequestIntroduction:
// It's a client wanting to connect to a specific (external) host
IPEndPoint clientInternal = msg.ReadIPEndPoint();
long hostId = msg.ReadInt64();
string token = msg.ReadString();
Console.WriteLine(msg.SenderEndPoint + " requesting introduction to " + hostId + " (token " + token + ")");
// find in list
IPEndPoint[] elist;
if (registeredHosts.TryGetValue(hostId, out elist))
{
// found in list - introduce client and host to eachother
Console.WriteLine("Sending introduction...");
peer.Introduce(
elist[0], // host internal
elist[1], // host external
clientInternal, // client internal
msg.SenderEndPoint, // client external
token // request token
);
}
else
{
Console.WriteLine("Client requested introduction to nonlisted host!");
}
break;
case MasterServerMessageType.RemoveHost:
long idRemove = msg.ReadInt64();
Console.WriteLine("De-register host " + idRemove);
registeredHosts.Remove(idRemove);
break;
case MasterServerMessageType.HostConnected:
long host = msg.ReadInt64();
Console.WriteLine("host: " + host + " is connected.");
registeredHosts.Remove(host); // Remove this host.
break;
}
break;
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
// print diagnostics message
Console.WriteLine(msg.ReadString());
break;
}
}
}
peer.Shutdown("shutting down");
}
void ReadMessage()
{
NetIncomingMessage inMsg;
if ((inMsg = peer.ReadMessage()) != null)
{
#if DEBUG
Console.WriteLine($"msg: {inMsg.MessageType}");
#endif
switch (inMsg.MessageType)
{
case NetIncomingMessageType.Data:
// Handle custom messages
Process(inMsg);
break;
case NetIncomingMessageType.DiscoveryResponse:
try
{
// Parse game data
FoundGame fg = ByteSerializer.ByteArrayToObject <FoundGame>(inMsg.Data);
// skip if game is already discovered / up to date
if (DiscoveredHosts.Contains(new KeyValuePair <IPEndPoint, FoundGame>(inMsg.SenderEndPoint, fg)))
{
break;
}
// Add server to list
DiscoveredHosts.Add(inMsg.SenderEndPoint, fg);
Console.WriteLine($"Discovered host at: {inMsg.SenderEndPoint}");
}
catch { }
break;
case NetIncomingMessageType.DiscoveryRequest:
if (isHost && !gameActive)
{
peer.SendDiscoveryResponse(PacketFactory.CreateFoundGameMessage(peer, FoundGame.CreateFromGrid(grid, peer.ConnectionsCount + 1)), inMsg.SenderEndPoint);
}
break;
case NetIncomingMessageType.StatusChanged:
// handle connection status messages
if (isHost)
{
switch (inMsg.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
if (isHost)
{
PlayerConnection np = new PlayerConnection(Player.GetRandomisedPlayer(), inMsg.SenderConnection.RemoteEndPoint);
peers.Add(np);
players.Add(np.player);
}
Console.WriteLine($"{inMsg.SenderConnection.RemoteEndPoint} {inMsg.SenderConnection.Status}");
Console.WriteLine($"{peers.Count + 1} players currently connected");
break;
case NetConnectionStatus.Disconnected:
if (isHost)
{
PlayerConnection p = (from peer in peers where Equals(inMsg.SenderConnection.RemoteEndPoint, peer.ipEndPoint) select peer).Single();
peers.Remove(p);
players.Remove(p.player);
}
Console.WriteLine($"{inMsg.SenderConnection.RemoteEndPoint} {inMsg.SenderConnection.Status}");
Console.WriteLine($"{peers.Count + 1} players currently connected");
break;
}
}
else
{
switch (inMsg.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
case NetConnectionStatus.Disconnected:
Console.WriteLine($"{inMsg.SenderConnection.RemoteEndPoint} {inMsg.SenderConnection.Status}");
Console.WriteLine($"{peer.Connections.Count + 1} players currently connected");
break;
}
}
break;
case NetIncomingMessageType.ConnectionApproval:
if (isHost)
{
if (gameActive)
{
inMsg.SenderConnection.Deny("Game already started");
break;
}
// not max players
if (grid.maxPlayers >= peer.ConnectionsCount + 1)
{
inMsg.SenderConnection.Approve();
}
else
{
inMsg.SenderConnection.Deny("Game is full");
}
}
else
{
inMsg.SenderConnection.Approve(); // TODO: Validate with gameID
}
break;
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
Console.WriteLine(inMsg.ReadString());
break;
default: throw new ArgumentOutOfRangeException();
}
peer.Recycle(inMsg);
}
}
public void Update(GameTime gameTime)
{
nextSendUpdates = NetTime.Now;
var listOfIncomingMessages = new List <NetIncomingMessage>();
var nMessages = peer.ReadMessages(listOfIncomingMessages);
foreach (var message in listOfIncomingMessages)
{
sentDataGametime = gameTime.ElapsedGameTime.TotalMilliseconds;
//RECIEVE DATA
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
// Create a response and write some example data to it
NetOutgoingMessage response = peer.CreateMessage();
response.Write(NetworkHelper.GetCurrentIPAddress());
// Send the response to the sender of the request
peer.SendDiscoveryResponse(response, message.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse:
Console.WriteLine("Found server at " + message.SenderEndPoint + " name: " + message.ReadString());
break;
case NetIncomingMessageType.Data:
Console.WriteLine("Incoming game-data");
//Recieves data and puts it in the networkInputComponent for the remote player entity
if (remotePlayerEntity != null)
{
var transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(remotePlayerEntity);
//Console.WriteLine(transformComponent.Position.ToString());
var velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(remotePlayerEntity);
var posx = message.ReadFloat();
var posy = message.ReadFloat();
var posz = message.ReadFloat();
var velx = message.ReadFloat();
var vely = message.ReadFloat();
var velz = message.ReadFloat();
velocityComponent.Velocity = new Vector3(velx, vely, velz);
transformComponent.Position = new Vector3(posx, posy, posz);
}
break;
case NetIncomingMessageType.StatusChanged:
// handle connection status messages
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
if (status == NetConnectionStatus.RespondedConnect)
{
Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " responded to connection!");
}
if (status == NetConnectionStatus.Connected)
{
Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " connected, yay!");
}
if (status == NetConnectionStatus.Disconnecting)
{
Console.WriteLine(message.SenderConnection.RemoteUniqueIdentifier + " disconnected!");
//should we shut down th server if the client disconnects?
peer.Shutdown("bye!");
}
break;
case NetIncomingMessageType.DebugMessage:
// handle debug messages
// (only received when compiled in DEBUG mode)
Console.WriteLine(message.ReadString());
break;
/* .. */
default:
Console.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
}
/********************************************************************************************************/
/*********************************************SEND DATA**************************************************/
/********************************************************************************************************/
currentTime = NetTime.Now;
if (currentTime > nextSendUpdates)
{
foreach (NetConnection player in peer.Connections)
{
NetOutgoingMessage om = peer.CreateMessage();
//sends data over the network to the host/client
var transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(localPlayerEntity);
var velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(localPlayerEntity);
om.Write(transformComponent.Position.X);
om.Write(transformComponent.Position.Y);
om.Write(transformComponent.Position.Z);
om.Write(velocityComponent.Velocity.X);
om.Write(velocityComponent.Velocity.Y);
om.Write(velocityComponent.Velocity.Z);
peer.SendMessage(om, player, NetDeliveryMethod.UnreliableSequenced);
if (runDiagnostics)
{
Diagnostics(om, gameTime);
}
}
//send data 30 times per second
nextSendUpdates += (1.0 / 30.0);
}
if (nMessages > 0)
{
Console.WriteLine(nMessages + " incoming messages!");
}
}
private void waitForMessages()
{
while (peerOn)
{
if (DateTime.Now > nextPingTime)
{
for (int i = 0; i < availablePeers.Count; i++) //foreach (peerType p in availablePeers)
{
peerType p = availablePeers[i];
NetOutgoingMessage ping = peer.CreateMessage();
ping.Write((short)SentDataType.ping);
peer.SendUnconnectedMessage(ping, p.address);
}
lastPingTime = DateTime.Now;
nextPingTime = lastPingTime.AddSeconds(1);
}
for (int i = 0; i < availablePeers.Count; i++) //foreach (peerType p in availablePeers)
{
peerType p = availablePeers[i];
if (p.lastPing < DateTime.Now.AddSeconds(-2))
{
availablePeers.Remove(p);
PlayerRemoved(p, EventArgs.Empty);
}
}
NetIncomingMessage msg;
while ((msg = peer.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
// In case status changed
// It can be one of these
// NetConnectionStatus.Connected;
// NetConnectionStatus.Connecting;
// NetConnectionStatus.Disconnected;
// NetConnectionStatus.Disconnecting;
// NetConnectionStatus.None;
// NOTE: Disconnecting and Disconnected are not instant unless client is shutdown with disconnect()
Console.WriteLine(msg.SenderConnection.ToString() + " status changed. " + (NetConnectionStatus)msg.SenderConnection.Status);
if (msg.SenderConnection.Status == NetConnectionStatus.Connected)
{
if (Connected != null)
{
foreach (peerType p in availablePeers)
{
if (p.address.Equals(peer.Connections[0].RemoteEndPoint))
{
clientName = p.name;
}
}
Connected(msg, EventArgs.Empty);
}
}
if (msg.SenderConnection.Status == NetConnectionStatus.Disconnected)
{
if (Disconnected != null)
{
Disconnected(msg, EventArgs.Empty);
}
}
break;
case NetIncomingMessageType.ConnectionApproval:
msg.SenderConnection.Approve();
iAmPlayer1 = false;
break;
case NetIncomingMessageType.DiscoveryRequest:
#region old stuff
//NetOutgoingMessage resp = peer.CreateMessage();
//resp.Write(peerName);
//resp.Write(GAME_NAME);
//peer.SendDiscoveryResponse(resp, msg.SenderEndPoint);
//System.Net.IPAddress myAddress;
//System.Net.IPAddress myAddressMask;
//myAddress = NetUtility.GetMyAddress(out myAddressMask);
//bool same = msg.SenderEndPoint.Address.Equals(myAddress);
//if (!same)
//{
// bool discoverSender = true;
// foreach (peerType p in availablePeers)
// {
// if (p.address.Equals(msg.SenderEndPoint.Address))
// {
// discoverSender = false;
// break;
// }
// }
// if (discoverSender)
// {
// peer.DiscoverKnownPeer(msg.SenderEndPoint);
// }
//}
#endregion
Console.WriteLine("Type = DiscoveryRequest; Sender = " + msg.SenderEndPoint.ToString());
getPeerId(msg.SenderEndPoint);
if (!listContainsIPEndPoint(msg.SenderEndPoint) && msg.SenderEndPoint != myIPEndPoint)
{
peer.DiscoverKnownPeer(msg.SenderEndPoint);
}
break;
case NetIncomingMessageType.DiscoveryResponse:
Console.WriteLine("Type = DiscoveryResponse; Sender = " + msg.SenderEndPoint);
string foundPeerName = msg.ReadString();
string foundGameName = msg.ReadString();
Console.WriteLine(foundPeerName);
Console.WriteLine(foundGameName);
addPeerToList(foundPeerName, foundGameName, msg.SenderEndPoint);
Console.WriteLine("Available Peers:");
foreach (peerType p in availablePeers)
{
Console.WriteLine(p.name);
}
// Raise event causing lobby list to be updated.
if (Discovered != null)
{
Discovered(msg, EventArgs.Empty);
}
break;
case NetIncomingMessageType.Data:
#region Data
//Console.ForegroundColor = ConsoleColor.Cyan;
//Console.WriteLine(msg.ReadString());
//Console.ResetColor();
short type = msg.ReadInt16();
//Console.WriteLine("Type = Data; Subtype = " + type + " Sender = " + msg.SenderEndPoint);
if (type == (short)SentDataType.move)
{
Console.WriteLine("Type = move; Sender = " + msg.SenderEndPoint);
moveType move = new moveType();
move.quad = msg.ReadInt16();
move.position = msg.ReadInt16();
move.isClockwise = msg.ReadBoolean();
if (MoveReceived != null)
{
MoveReceived(move, EventArgs.Empty);
}
}
else if (type == (short)SentDataType.globalChat)
{
string message = msg.ReadString();
}
else if (type == (short)SentDataType.privateChat)
{
string message = msg.ReadString();
}
else if (type == (short)SentDataType.idRequest)
{
Console.WriteLine("Type = idRequest; Sender = " + msg.SenderEndPoint);
sendId(msg.SenderEndPoint);
}
else if (type == (short)SentDataType.idResponse)
{
Console.WriteLine("Type = idResponse; Sender = " + msg.SenderEndPoint);
otherId = msg.ReadInt32();
// Discovery Response
if (otherId != myId)
{
NetOutgoingMessage resp = peer.CreateMessage();
resp.Write(peerName);
resp.Write(GAME_NAME);
peer.SendDiscoveryResponse(resp, msg.SenderEndPoint);
}
else
{
myIPEndPoint = msg.SenderEndPoint;
}
}
break;
#endregion
case NetIncomingMessageType.UnconnectedData:
#region Unconnected Data
type = msg.ReadInt16();
if (type == (short)SentDataType.move)
{
Console.WriteLine("Type = move; Sender = " + msg.SenderEndPoint);
short quadrant = msg.ReadInt16();
short position = msg.ReadInt16();
bool isClockwise = msg.ReadBoolean();
}
else if (type == (short)SentDataType.globalChat)
{
string message = msg.ReadString();
}
else if (type == (short)SentDataType.privateChat)
{
string message = msg.ReadString();
}
else if (type == (short)SentDataType.idRequest)
{
Console.WriteLine("Type = idRequest; Sender = " + msg.SenderEndPoint);
sendId(msg.SenderEndPoint);
}
else if (type == (short)SentDataType.idResponse)
{
Console.WriteLine("Type = idResponse; Sender = " + msg.SenderEndPoint);
otherId = msg.ReadInt32();
// Discovery Response
if (otherId != myId)
{
NetOutgoingMessage resp = peer.CreateMessage();
resp.Write(peerName);
resp.Write(GAME_NAME);
peer.SendDiscoveryResponse(resp, msg.SenderEndPoint);
}
else
{
myIPEndPoint = msg.SenderEndPoint;
}
}
else if (type == (short)SentDataType.connectRequest)
{
// Raise event causing user to get connection request
if (ConnectionRequest != null)
{
pendingConnectRequester = msg.SenderEndPoint;
ConnectionRequest(msg.ReadString(), EventArgs.Empty);
}
}
else if (type == (short)SentDataType.ping)
{
if (peer.Connections.Count == 0)
{
NetOutgoingMessage resp = peer.CreateMessage();
resp.Write((short)SentDataType.pingResponse);
peer.SendUnconnectedMessage(resp, msg.SenderEndPoint);
}
}
else if (type == (short)SentDataType.pingResponse)
{
foreach (peerType p in availablePeers)
{
if (p.address == msg.SenderEndPoint)
{
p.lastPing = DateTime.Now;
}
}
}
break;
#endregion
default:
Console.WriteLine("Unhandled type: " + msg.MessageType);
break;
}
peer.Recycle(msg);
}
}
}
