public bool EnterWorld(NetIncomingMessage inc, out NetOutgoingMessage message, out string username)
{
message = server.CreateMessage();
username = null;
if (inc.SenderConnection.RemoteHailMessage != null)
{
// Read opcode
GameMessageTypes opcode = (GameMessageTypes)inc.SenderConnection.RemoteHailMessage.ReadByte();
if (opcode != GameMessageTypes.HandShake)
{
return(false);
}
HandShakeMessage msg = new HandShakeMessage(inc.SenderConnection.RemoteHailMessage);
if (msg.Version == PacketHandler.PROTOCOL_VERSION && msg.Username != null && msg.Username.Length != 0)
{
username = msg.Username;
return(true);
}
}
return(false);
//new UpdatePlayerStateMessage(this.playerManager.AddPlayer(false)).Encode(hailMessage);
}
/// <summary>
/// Handle game message and choose what to do with it.
/// </summary>
/// <param name="Message">Message to handle.</param>
public void HandleGameMessage(NetIncomingMessage Message)
{
GameMessageTypes gameMessage = (GameMessageTypes)Message.ReadByte();
switch (gameMessage)
{
case GameMessageTypes.UpdateVesseState:
{
this.OnVesselUpdateState(new VesselMessage(Message));
break;
}
default:
{
Log.HandleLog(LOGMessageTypes.Error, "Unhandled game message type " + gameMessage);
break;
}
}
}
/// <summary>
/// Procédure qui traite les messages de type Data venant des client
/// </summary>
/// <param name="inc">Le message entrant</param>
public void TreatGameMessages(NetIncomingMessage inc)
{
GameMessageTypes messagetype = (GameMessageTypes)inc.ReadByte();
NetOutgoingMessage outmsg = GameServer.CreateMessage();
switch (messagetype)
{
case GameMessageTypes.GetMapSeed:
NetOutgoingMessage outmsg1 = GameServer.CreateMessage();
SendMapSeed sendmapseed = new SendMapSeed(GameSeed);
sendmapseed.EncodeMessage(outmsg1);
NetSendResult res = GameServer.SendMessage(outmsg1, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case GameMessageTypes.SendPlayerData:
PlayerDataGame playerdatagame = new PlayerDataGame();
playerdatagame.DecodeMessage(inc);
PlayerDataServer playerdataserver = new PlayerDataServer();
playerdataserver.TransferData(playerdatagame);
foreach (NetConnection co in GameServer.Connections)
{
if (co != inc.SenderConnection)
{
NetOutgoingMessage outmsg2 = GameServer.CreateMessage();
playerdataserver.EncodeMessage(outmsg2);
GameServer.SendMessage(outmsg2, co, NetDeliveryMethod.ReliableOrdered);
}
}
break;
case GameMessageTypes.SendArrival:
NetOutgoingMessage outmsg3 = GameServer.CreateMessage();
SendArrival msg = new SendArrival();
msg.DecodeMessage(inc);
if (PlayerList.Count > 0)
{
foreach (PlayerSignature ps in PlayerList)
{
SendPlayerListToNewPlayer(ps, inc);
}
}
AddNewPlayerToList(msg.Pseudo, msg.TeamNumber, msg.ID, msg.Weapon, inc.SenderConnection);
SendNewPlayerMessage(inc, msg.Pseudo, msg.ID, msg.TeamNumber, msg.Weapon);
outmsg3 = GameServer.CreateMessage();
ConfirmArrival nmsg = new ConfirmArrival();
nmsg.EncodeMessage(outmsg3);
GameServer.SendMessage(outmsg3, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered);
break;
case GameMessageTypes.NewBulletGame:
NewBulletGame nbmsg = new NewBulletGame();
nbmsg.DecodeMessage(inc);
NewBulletServer nbmsg2 = new NewBulletServer();
nbmsg2.TransferData(nbmsg);
foreach (NetConnection co in GameServer.Connections)
{
if (co != inc.SenderConnection)
{
NetOutgoingMessage outmsg4 = GameServer.CreateMessage();
nbmsg2.EncodeMessage(outmsg4);
GameServer.SendMessage(outmsg4, co, NetDeliveryMethod.ReliableOrdered);
}
}
break;
case GameMessageTypes.SendPlayerRespawn:
RespawnPlayerGame prmsg = new RespawnPlayerGame();
prmsg.DecodeMessage(inc);
RespawnPlayerServer prmsg2 = new RespawnPlayerServer();
prmsg2.TransferData(prmsg);
foreach (NetConnection co in GameServer.Connections)
{
if (co != inc.SenderConnection)
{
NetOutgoingMessage outmsg5 = GameServer.CreateMessage();
prmsg2.EncodeMessage(outmsg5);
GameServer.SendMessage(outmsg5, co, NetDeliveryMethod.ReliableOrdered);
}
}
break;
case GameMessageTypes.SendDeath:
PlayerDeathGame pdmsg = new PlayerDeathGame();
pdmsg.DecodeMessage(inc);
PlayerDeathServer pdmsg2 = new PlayerDeathServer();
pdmsg2.TransferData(pdmsg);
foreach (NetConnection co in GameServer.Connections)
{
if (co != inc.SenderConnection)
{
NetOutgoingMessage outmsg6 = GameServer.CreateMessage();
pdmsg2.EncodeMessage(outmsg6);
GameServer.SendMessage(outmsg6, co, NetDeliveryMethod.ReliableOrdered);
}
}
break;
case GameMessageTypes.SendDisconnection:
SendDisconnectionMessage(inc.ReadInt64(), inc);
break;
default:
break;
}
}
/// <summary>
/// Handle messages from server or client and choose what to do with them.
/// </summary>
private void HandleMessage()
{
NetIncomingMessage netIncomingMessage;
while ((netIncomingMessage = m_netServer.ReadMessage()) != null)
{
switch (netIncomingMessage.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
{
Log.HandleLog(LOGMessageTypes.Debug, netIncomingMessage.ReadString());
break;
}
case NetIncomingMessageType.WarningMessage:
{
Log.HandleLog(LOGMessageTypes.Warning, netIncomingMessage.ReadString());
break;
}
case NetIncomingMessageType.ErrorMessage:
{
Log.HandleLog(LOGMessageTypes.Error, netIncomingMessage.ReadString());
break;
}
case NetIncomingMessageType.UnconnectedData:
{
switch ((ServerMessageTypes)netIncomingMessage.ReadByte())
{
case ServerMessageTypes.RequestPing:
{
NetOutgoingMessage netOutgoingMessage = this.m_netServer.CreateMessage();
netOutgoingMessage.Write((byte)ServerMessageTypes.RequestPing);
netOutgoingMessage.Write(this.m_netServer.UniqueIdentifier);
this.m_netServer.SendUnconnectedMessage(netOutgoingMessage, netIncomingMessage.SenderEndPoint);
break;
}
}
break;
}
/*case NetIncomingMessageType.DiscoveryRequest:
* {
* NetOutgoingMessage ResponseMessage = this.m_netServer.CreateMessage();
*
* IGameMessage gameMessage = new DiscoveryRequestMessage
* {
* Hostname = "L.O.G. Server",
* Players = this.m_netServer.Connections.Count,
* MaximumPlayers = 32
* };
*
* gameMessage.EncodeMessage(ResponseMessage);
*
* this.m_netServer.SendDiscoveryResponse(ResponseMessage, netIncomingMessage.SenderEndPoint);
*
* break;
* }*/
case NetIncomingMessageType.StatusChanged:
{
switch ((NetConnectionStatus)netIncomingMessage.ReadByte())
{
case NetConnectionStatus.RespondedConnect:
Log.HandleLog(LOGMessageTypes.Info, "Incoming connection from", netIncomingMessage.SenderEndPoint);
break;
case NetConnectionStatus.Connected:
Log.HandleLog(LOGMessageTypes.Info, this.m_playersList[netIncomingMessage.SenderConnection].Username, "has joined the server");
break;
case NetConnectionStatus.Disconnected:
Log.HandleLog(LOGMessageTypes.Info, this.m_playersList[netIncomingMessage.SenderConnection].Username, "has left the server");
break;
}
break;
}
case NetIncomingMessageType.ConnectionApproval:
{
GameMessageTypes gameMessageType = (GameMessageTypes)netIncomingMessage.SenderConnection.RemoteHailMessage.ReadByte();
if (gameMessageType != GameMessageTypes.ConnectionApprovalRequest)
{
break;
}
ConnectionApprovalRequestMessage Message = new ConnectionApprovalRequestMessage(netIncomingMessage.SenderConnection.RemoteHailMessage);
if (Message.Version == APIMain.Version && Message.Username != null && Message.Username.Length > 0)
{
netIncomingMessage.SenderConnection.Approve(this.m_netServer.CreateMessage());
this.m_playersList.Add(netIncomingMessage.SenderConnection, new PlayerModel(netIncomingMessage.SenderConnection, Message.Username));
}
else
{
netIncomingMessage.SenderConnection.Deny("Wrong version or username!");
}
break;
}
case NetIncomingMessageType.Data:
{
this.m_playersList[netIncomingMessage.SenderConnection].messageHandler.HandleGameMessage(netIncomingMessage);
break;
}
default:
{
Log.HandleLog(LOGMessageTypes.Error,
String.Format("Unhandled type: {0} {1} bytes {2} | {3}", netIncomingMessage.MessageType, netIncomingMessage.LengthBytes, netIncomingMessage.DeliveryMethod,
netIncomingMessage.SequenceChannel));
break;
}
}
this.m_netServer.Recycle(netIncomingMessage);
}
}
