///// <summary>
///// Method for Receiving Messages. Only Peer Disovery Is Needed for this one.
///// </summary>
///// <param name="peer">Peer.</param>
//public void ClientMsgCallback(object peer)
//{
// NetIncomingMessage im;
// while ((im = vxEngine.GameClient.ReadMessage()) != null)
// {
// // handle incoming message
// switch (im.MessageType)
// {
// case NetIncomingMessageType.DebugMessage:
// case NetIncomingMessageType.ErrorMessage:
// case NetIncomingMessageType.WarningMessage:
// case NetIncomingMessageType.VerboseDebugMessage:
// string text = im.ReadString();
// vxConsole.WriteNetworkLine(im.MessageType + " : " + text);
// break;
// /**************************************************************/
// //DiscoveryResponse
// /**************************************************************/
// case NetIncomingMessageType.DiscoveryResponse:
// //Read In The Discovery Response
// string receivedMsg = im.ReadString();
// vxConsole.WriteNetworkLine("Server found at: " + im.SenderEndPoint + "\nmsg: " + receivedMsg);
// AddDiscoveredServer(receivedMsg);
// break;
// /**************************************************************/
// //StatusChanged
// /**************************************************************/
// case NetIncomingMessageType.StatusChanged:
// NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
// string reason = im.ReadString();
// vxConsole.WriteNetworkLine(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason);
// break;
// /**************************************************************/
// //ConnectionApproval
// /**************************************************************/
// case NetIncomingMessageType.ConnectionApproval:
// Console.WriteLine("Connetion Approval From: " + im.SenderEndPoint + "\nmsg: " + im.ReadString());
// break;
// /**************************************************************/
// //Data
// /**************************************************************/
// case NetIncomingMessageType.Data:
// // incoming chat message from a client
// string chat = im.ReadString();
// //Split the Text By Carriage Return
// string[] result = chat.Split(new string[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
// switch (result[0])
// {
// default:
// vxConsole.WriteNetworkLine("Broadcasting '" + chat + "'");
// /*
// // broadcast this to all connections, except sender
// List<NetConnection> all = vxEngine.GameSever.Connections; // get copy
// all.Remove(im.SenderConnection);
// if (all.Count > 0)
// {
// NetOutgoingMessage om2 = vxEngine.GameSever.CreateMessage();
// om2.Write(NetUtility.ToHexString(im.SenderConnection.RemoteUniqueIdentifier) + " said: " + chat);
// vxEngine.GameSever.SendMessage(om2, all, NetDeliveryMethod.ReliableOrdered, 0);
// }
// */
// break;
// }
// break;
// default:
// vxConsole.WriteNetworkLine("Unhandled type: " + im.MessageType + " " + im.LengthBytes + " bytes");
// break;
// }
// vxEngine.GameClient.Recycle(im);
// }
//}
private void AddDiscoveredServer(vxNetmsgServerInfo response)
{
Texture2D thumbnail = vxEngine.Assets.Textures.Arrow_Right;
vxServerListItem item = new vxServerListItem(vxEngine,
response.ServerName,
response.ServerIP,
response.ServerPort,
new Vector2(
(int)(2 * this.ArtProvider.Padding.X),
this.ArtProvider.Padding.Y + (this.ArtProvider.Padding.Y / 10 + 68) * (List_Items.Count + 1)),
thumbnail,
List_Items.Count);
//Set Item Width
item.ButtonWidth = ScrollPanel.Width - (int)(2 * this.ArtProvider.Padding.X) - ScrollPanel.ScrollBarWidth;
//Set Clicked Event
item.Clicked += GetHighlitedItem;
//Add item too the list
List_Items.Add(item);
foreach (vxServerListItem it in List_Items)
{
ScrollPanel.AddItem(it);
}
}
private void ServerMsgCallBack(object peer)
{
NetIncomingMessage im;
while ((im = this.Server.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
//LogServer(im.ReadString());
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
Console.WriteLine(im.ReadFloat());
//this.PlayerManager.Entites [im.SenderConnection.RemoteUniqueIdentifier].Ping = im.ReadFloat();
break;
/**************************************************************/
//Handle Discovery
/**************************************************************/
case NetIncomingMessageType.DiscoveryRequest:
LogServer(string.Format(" ------- Discovery Request Recieved from: {0}", im.SenderEndPoint));
vxNetServerEventDiscoverySignalRequest discoveryRequestEvent = new vxNetServerEventDiscoverySignalRequest(im.SenderEndPoint);
if (DiscoverySignalRequestRecieved != null)
{
DiscoverySignalRequestRecieved(this, discoveryRequestEvent);
}
if (discoveryRequestEvent.SendResponse == true)
{
// Create a response and write some example data to it
NetOutgoingMessage response = this.Server.CreateMessage();
//Send Back Connection Information, the client will still need to Authenticate with a Secret though
//response.Write(discoveryRequestEvent.Response);
var resp = new vxNetmsgServerInfo("Test Server",
this.Server.Configuration.BroadcastAddress.ToString(),
this.Server.Configuration.Port.ToString());
resp.EncodeMsg(response);
// Send the response to the sender of the request
this.Server.SendDiscoveryResponse(response, im.SenderEndPoint);
}
else
{
//The discovery response was blocked in the event. Notify on the server why but do not respond to the client.
LogServer(string.Format("\n--------------------------\nDISCOVERY REQUEST BLOCKED\n IPEndpoint: '{0}'\nREASON: '{1}' \n--------------------------\n", im.SenderEndPoint, discoveryRequestEvent.Response));
}
break;
/**************************************************************/
//Handle Connection Approval
/**************************************************************/
case NetIncomingMessageType.ConnectionApproval:
string s = im.ReadString();
if (s == "secret")
{
NetOutgoingMessage approve = Server.CreateMessage();
im.SenderConnection.Approve(approve);
LogServer(string.Format("{0} Connection Approved", im.SenderEndPoint));
}
else
{
im.SenderConnection.Deny();
LogServer(string.Format("{0} Connection DENIED!", im.SenderEndPoint));
}
break;
case NetIncomingMessageType.StatusChanged:
switch ((NetConnectionStatus)im.ReadByte())
{
case NetConnectionStatus.Connected:
LogServer(string.Format(" \t\t {0} Connected", im.SenderEndPoint));
if (ClientConnected != null)
{
ClientConnected(this, new vxNetServerEventClientConnected(im.SenderConnection.RemoteUniqueIdentifier));
}
break;
case NetConnectionStatus.Disconnected:
LogServer(string.Format("{0} Disconnected", im.SenderEndPoint));
//For what ever reason, a player has disconnected, so we need to remove it from the player list
//Send a message to all clients to remove this client from their list.
var rmvMsg = new vxNetmsgRemovePlayer(PlayerManager.Players[im.SenderConnection.RemoteUniqueIdentifier]);
//Send the message to all clients.
SendMessage(rmvMsg);
//Fire the Server Event for any outside events
if (ClientDisconnected != null)
{
ClientDisconnected(this, new vxNetServerEventClientDisconnected(im.SenderConnection.RemoteUniqueIdentifier));
}
//Finally remove the player from the server's list
if (PlayerManager.Players.ContainsKey(im.SenderConnection.RemoteUniqueIdentifier))
{
PlayerManager.Players.Remove(im.SenderConnection.RemoteUniqueIdentifier);
}
break;
default:
LogServer(im.ReadString());
break;
}
break;
case NetIncomingMessageType.Data:
var gameMessageType = (vxNetworkMessageTypes)im.ReadByte();
switch (gameMessageType)
{
/**************************************************************/
//Handle New Player Connection
/**************************************************************/
case vxNetworkMessageTypes.PlayerConnected:
//Decode the Message
var newPlayer = new vxNetmsgAddPlayer(im);
//Add the new player info to the Server List
PlayerManager.Add(newPlayer.PlayerInfo);
newPlayer.PlayerInfo.Status = vxEnumNetPlayerStatus.InServerLobbyNotReady;
//Now Update all clients with the Player list using the server Player List
var newPlayerList = new vxNetmsgUpdatePlayerList(this.PlayerManager);
SendMessage(newPlayerList);
break;
/**************************************************************/
//Handle Player Lobby Status Update
/**************************************************************/
case vxNetworkMessageTypes.UpdatePlayerLobbyStatus:
//Decode the list
var updatePlayerState = new vxNetmsgUpdatePlayerLobbyStatus(im);
//Update the internal server list
PlayerManager.Players[updatePlayerState.PlayerInfo.ID] = updatePlayerState.PlayerInfo;
//Now resend it back to all clients
SendMessage(updatePlayerState);
if (UpdatePlayerStatus != null)
{
UpdatePlayerStatus(this, new vxNetServerEventPlayerStatusUpdate(updatePlayerState.PlayerInfo));
}
break;
/**************************************************************/
//Handles an Update to a Player's Entity State
/**************************************************************/
case vxNetworkMessageTypes.UpdatePlayerEntityState:
//First decode the message
var updatePlayerEntityState = new vxNetmsgUpdatePlayerEntityState(im);
//get the time delay
var timeDelay = (float)(NetTime.Now - im.SenderConnection.GetLocalTime(updatePlayerEntityState.MessageTime));
//Then Update the Player in the Server List
PlayerManager.Players[updatePlayerEntityState.PlayerInfo.ID] = updatePlayerEntityState.PlayerInfo;
//Then fire any tied events in the server
if (UpdatePlayerEntityState != null)
{
UpdatePlayerEntityState(this, new vxNetServerEventPlayerStateUpdate(updatePlayerEntityState.PlayerInfo));
}
//Finally, relay the updated state too all clients.
SendMessage(updatePlayerEntityState);
break;
case vxNetworkMessageTypes.AddItem:
break;
case vxNetworkMessageTypes.RemoveItem:
break;
case vxNetworkMessageTypes.Other:
break;
}
break;
default:
break;
}
this.Server.Recycle(im);
}
}
/// <summary>
/// Constructor.
/// </summary>
public vxNetClientEventDiscoverySignalResponse(vxNetmsgServerInfo NetMsgServerInfo)
{
this.m_vxNetMsgServerInfo = NetMsgServerInfo;
}
