public NetOutgoingMessage CreateMessage(NetMessageType messageType)
{
NetOutgoingMessage mes = server.CreateMessage();
mes.Write((short)messageType);
return(mes);
}
private bool MatchPlayer(NetConnection playerConn)
{
NetOutgoingMessage nom = server.CreateMessage();
//Check to see if there is an available opponent
foreach (NetConnection nc in server.Connections)
{
if (!playerConns.ContainsKey(nc))
{
//Game game = new Game(new List<NetConnection> { nc, playerConn }, server);
//games.Add(game);
playerConns.Add(nc, playerConn);
playerConns.Add(playerConn, nc);
//host player set to red team
nom.Write((int)MsgType.GameStart + "," + 0);
server.SendMessage(nom, nc, NetDeliveryMethod.ReliableOrdered, 0);
//Joining player set to blue team
nom = server.CreateMessage();
nom.Write((int)MsgType.GameStart + "," + 1);
server.SendMessage(nom, playerConn, NetDeliveryMethod.ReliableOrdered, 0);
_managerLogger.AddLogMessage(new Util.LogMessage {
Id = "0", Message = "Players matched!"
});
return(true);
}
}
_managerLogger.AddLogMessage(new Util.LogMessage {
Id = "0", Message = "No Opponent found"
});
nom.Write("No Opponents Available");
server.SendMessage(nom, playerConn, NetDeliveryMethod.ReliableOrdered, 0);
return(false);
}
public void Run(LoggerManager loggerManager, MongoClient mongoClient, NetServer server, NetIncomingMessage inc, Player player, List <Player> allPlayers, List <GameRoom> gameRooms)
{
var sender = Server.GetPlayer(inc, allPlayers);
if (sender.LastMessageTime + TimeSpan.FromSeconds(3) > DateTime.Now)
{
var spammsg = server.CreateMessage();
spammsg.Write((byte)PacketTypes.ChatMessage);
DataConvert.WriteMessage(spammsg, new Message("You are sending messages too fast", "[SERVER]"));
server.SendMessage(spammsg, sender.Conn, NetDeliveryMethod.ReliableOrdered);
return;
}
sender.LastMessageTime = DateTime.Now;
var message = inc.ReadString();
var fullMessage = new Message(message, sender.Username);
var outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.ChatMessage);
DataConvert.WriteMessage(outmsg, fullMessage);
Server.SendToGameRoomPlayers(server, outmsg, sender, gameRooms);
}
public static void Send(Packet packet, Session session, NetDeliveryMethod method = NetDeliveryMethod.ReliableOrdered, int sequenceChannel = 0)
{
var message = server.CreateMessage();
Packet.WriteToMessage(packet, message);
session.Connection.SendMessage(message, method, sequenceChannel);
}
private void HandleStatusChanged(NetIncomingMessage inc)
{
if (netServer == null)
{
return;
}
DebugConsole.NewMessage(inc.SenderConnection.Status.ToString());
switch (inc.SenderConnection.Status)
{
case NetConnectionStatus.Connected:
NetOutgoingMessage outMsg = netServer.CreateMessage();
outMsg.Write(OwnerSteamID);
outMsg.Write((byte)(PacketHeader.IsConnectionInitializationStep | PacketHeader.IsServerMessage));
NetSendResult result = netServer.SendMessage(outMsg, netConnection, NetDeliveryMethod.ReliableUnordered);
if (result != NetSendResult.Sent && result != NetSendResult.Queued)
{
DebugConsole.NewMessage("Failed to send connection confirmation message to owner: " + result.ToString(), Microsoft.Xna.Framework.Color.Yellow);
}
break;
case NetConnectionStatus.Disconnected:
DebugConsole.NewMessage("Owner disconnected: closing the server...");
GameServer.Log("Owner disconnected: closing the server...", ServerLog.MessageType.ServerMessage);
Close(DisconnectReason.ServerShutdown.ToString() + "/ Owner disconnected");
break;
}
}
/// <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);
}
}
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
NetIncomingMessage msgInc;
while ((msgInc = Server.ReadMessage()) != null)
{
switch (msgInc.MessageType)
{
case NetIncomingMessageType.Data:
ReadData(msgInc); break;
}
Server.Recycle(msgInc);
}
NetOutgoingMessage msgOut = Server.CreateMessage();
msgOut.Write((byte)MessageContentType.MapData);
msgOut.Write(Map.Objects.Count);
foreach (GameObject obj in Map.Objects.Values)
{
msgOut.Write(obj.ID);
msgOut.Write((byte)obj.Type);
obj.WriteTo(msgOut);
}
Server.SendToAll(msgOut, NetDeliveryMethod.UnreliableSequenced);
}
/// <summary>
/// Sends a packet to all clients.
/// </summary>
/// <param name="packet">The packet to send</param>
private void BroadcastPacket(Packet packet)
{
var deliveryMethod = packet.DeliveryMethod;
var msg = packet.ToMessage(server.CreateMessage());
server.SendToAll(msg, deliveryMethod);
}
static void StartServer()
{
server.Start();
NetIncomingMessage message;
while (true)
{
message = server.WaitMessage(500);
if (message != null)
{
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage response = server.CreateMessage();
response.Write((byte)1); // Do I need to do this?
server.SendDiscoveryResponse(response, message.SenderEndPoint);
break;
case NetIncomingMessageType.DebugMessage:
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(Server) Debug: " + message.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
string reason = message.ReadString();
Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " " + status + ": " + reason);
if (status == NetConnectionStatus.Connected)
{
Console.WriteLine("Remote hail: " + message.SenderConnection.RemoteHailMessage.ReadString());
}
break;
case NetIncomingMessageType.Data:
// incoming chat message from a client
string chat = message.ReadString();
// broadcast this to all connections, except sender
List <NetConnection> all = server.Connections; // get copy
//all.Remove(message.SenderConnection);
Console.WriteLine(all + "hello ");
NetOutgoingMessage om = server.CreateMessage();
server.SendMessage(om, all, NetDeliveryMethod.ReliableOrdered, 0);
break;
default:
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("(Server) Unrecognized message type! (" + message.MessageType + ")");
break;
}
}
server.Recycle(message);
}
Thread.Sleep(1);
}
private NetOutgoingMessage PrepareFirstPackage()
{
NetOutgoingMessage outMsg = server.CreateMessage();
//Number Players
outMsg.Write(clientList.Count);
//Map Filename
outMsg.Write(mapName);
//Map Current State
for (int i = 0; i < map.height; i++)
{
for (int j = 0; j < map.width; j++)
{
outMsg.Write(map.world[i, j].lifePoint);
outMsg.Write(map.world[i, j].alive);
outMsg.Write(map.world[i, j].bloque);
outMsg.Write(map.world[i, j].draw);
outMsg.Write(map.world[i, j].hitable);
}
}
return(outMsg);
}
public void Run(LoggerManager loggerManager, MongoClient mongoClient, NetServer server, NetIncomingMessage inc, Player player, List <Player> allPlayers, List <GameRoom> gameRooms)
{
if (_inputId == -1)
{
NetOutgoingMessage outmsg = server.CreateMessage();
outmsg.Write((byte)PacketTypes.PlayerPosition);
Library.DataConvert.WritePlayer(outmsg, player);
server.SendToAll(outmsg, NetDeliveryMethod.ReliableOrdered);
}
NetOutgoingMessage outmsg2 = server.CreateMessage();
outmsg2.Write((byte)PacketTypes.PlayerPosition);
Library.DataConvert.WritePlayer(outmsg2, player, _inputId);
var tempRoom = new GameRoom();
foreach (var room in gameRooms)
{
if (room.Players.Any(x => x.Username == player.Username))
{
tempRoom = room;
}
}
foreach (var tempPlayer in tempRoom.Players)
{
server.SendMessage(outmsg2, tempPlayer.Conn, NetDeliveryMethod.ReliableOrdered);
}
}
//Interface functions
/// <summary>
/// To be called frequently. Sends a message to each approved connectiont to check they are still there
/// </summary>
void ILidgrenServer.Beat()
{
//Recycle the message
NetOutgoingMessage outgoingMessage;
//Loop through each connected object sending it a beat
foreach (NetConnection netConnection in ConnectionList)
{
//Log the message
lidgrenConsoleOutputGUI.WriteConsole($"Sending beat to: {netConnection}", LogLevel.Everything);
//Create the new message
outgoingMessage = netServer.CreateMessage();
//Write whether it is a new message from the server (true) or a reply to a message from the client (false)
outgoingMessage.Write(true);
//Write true if a body exists to read
outgoingMessage.Write(false);
//Pad so that future reading is easily done
outgoingMessage.WritePadBits();
//Write the message type (note it's been squished to 8 bits therefore max 256 message types)
outgoingMessage.Write((byte)0);
//Send the message
netServer.SendMessage(outgoingMessage, netConnection, NetDeliveryMethod.Unreliable);
}
}
// Mobo client is connecting to the server
public static void Connect()
{
// Read client indentifier
long uid = in_message.ReadInt64();
// Read name of player
string playername = in_message.ReadString();
// Read position of player
int x = in_message.ReadInt32();
int y = in_message.ReadInt32();
// Wait a little to make sure client is connected
System.Threading.Thread.Sleep(100);
// Create new player object for connencting client
Player.players.Add(new Player(playername, x, y, 0, uid));
// Now send this new player all the players in the server
foreach (Player player in Player.players)
{
// Write a new message with incoming parameters, and send the all connected clients.
out_message = Server.CreateMessage();
out_message.Write(CONNECT);
out_message.Write(player.name);
out_message.Write(player.uid);
out_message.Write(player.x);
out_message.Write(player.y);
// Send via TCP to make sure the new player recieves every one
Server.SendMessage(out_message, Server.Connections, NetDeliveryMethod.ReliableOrdered, 0);
}
Program.log.Add(string.Format("{0} (UID:{1}) connected.", playername, uid));
}
/// <summary>
/// Sends a message through a channel with defined message delivery type.
/// </summary>
/// <param name="msg">The Message in byte[].</param>
/// <param name="msgDelivery">The <see cref="MessageDelivery" />.</param>
/// <param name="msgChannel">The message channel.</param>
/// <returns>True if the message was sent succesfully.</returns>
public bool SendMessage(byte[] msg, MessageDelivery msgDelivery, int msgChannel)
{
// _netConfig.RedirectPackets = true;
NetSendResult sendResult;
switch (_config.SysType)
{
case SysType.Peer:
//sendMsg = _netPeer.CreateMessage(msg);
//sendMsg.Write(msg);
break;
case SysType.Client:
var sendMsgClient = _netClient.CreateMessage();
sendMsgClient.Write(msg);
sendResult = _netClient.SendMessage(sendMsgClient, (NetDeliveryMethod)msgDelivery, msgChannel);
return(sendResult == NetSendResult.Sent);
case SysType.Server:
var sendMsgServer = _netServer.CreateMessage();
sendMsgServer.Write(msg);
if (_netServer.ConnectionsCount > 0)
{
_netServer.SendMessage(sendMsgServer, _netServer.Connections, (NetDeliveryMethod)msgDelivery, msgChannel);
}
return(true);
}
return(false);
}
private static void JudgeConnection(NetIncomingMessage message)
{
string name = message.ReadString();
bool taken = false;
foreach (Player player in connections.Values)
{
if (player.Name == name)
{
taken = true;
}
}
if (!taken)
{
Random random = new Random();
// TO DO: Encapsulate the alert command
NetOutgoingMessage userConnectMessage = server.CreateMessage();
userConnectMessage.Write((byte)NetworkCommand.Alert);
userConnectMessage.Write("User " + name + " has connected.");
server.SendToAll(userConnectMessage, NetDeliveryMethod.ReliableUnordered);
message.SenderConnection.Approve();
connections[message.SenderConnection] = new Player(false, name, new Vector2(random.Next(-128, 128), random.Next(-128, 128)), Vector2.Zero, 0);
}
else
{
message.SenderConnection.Deny("Someone with the name \"" + name + "\" is already connected to the server.");
}
}
private static void process(string inMess)
{
Console.WriteLine("Data " + inMess);
PlayerData p = JsonConvert.DeserializeObject <PlayerData>(inMess);
switch (p.header)
{
case "Join":
// Add the player to the server copy
Players.Add(p);
// send the message to all clients that players are joined
foreach (PlayerData player in Players)
{
PlayerData joined = new PlayerData("Joined", player.imageName, player.playerID, player.X, player.Y);
string json = JsonConvert.SerializeObject(joined);
//
NetOutgoingMessage JoinedMessage = server.CreateMessage();
JoinedMessage.Write(json);
server.SendToAll(JoinedMessage, NetDeliveryMethod.ReliableOrdered);
}
break;
default:
break;
}
}
private void Sender_Send(object sender, Packets.Packet packet)
{
NetOutgoingMessage msg = _server.CreateMessage(4);
packet.Write(msg);
_server.SendMessage(msg, Connector.GetConnection(packet.Connection), packet.Method.ToNetDeliveryMethod());
}
public void SendUnconnectedMessage(iPacket packet, IPEndPoint receiver)
{
NetOutgoingMessage sendMsg = server.CreateMessage();
sendMsg = packet.Pack(sendMsg);
server.SendUnconnectedMessage(sendMsg, receiver);
}
// Adds the default information to a packet and sends it to all clients.
public void SendPacketToAll <T>(T packet) where T : Packet <T>
{
NetOutgoingMessage msg = server.CreateMessage();
msg = PacketHelper.AddDefaultInformationToPacket(msg, typeof(T).Name, packet.Get_PacketIdentifier());
msg = packet.PackPacketIntoMessage(msg, packet);
server.SendToAll(msg, NetDeliveryMethod.ReliableOrdered);
}
public void SendInGameString(String s)
{
NetOutgoingMessage msg = server.CreateMessage();
msg.Write(((int)MessageTypes.InGame).ToString() + ":" + ((int)GameCommandTypes.Chat).ToString() + ":" + "0" + ":" + lockstep.ToString() + ":" + s);
server.SendToAll(msg, NetDeliveryMethod.ReliableOrdered);
}
/// <summary>
/// Send a new player to the clients.
/// </summary>
/// <param name="player"></param>
/// <param name="inc"></param>
public static void SendNewPlayer(Player player, NetIncomingMessage inc)
{
var outMessage = server.CreateMessage();
outMessage.Write((byte)PacketType.NewPlayer);
player.writeToMessage(outMessage);
server.SendToAll(outMessage, inc.SenderConnection, NetDeliveryMethod.ReliableOrdered, 0);
}
public void Send(object client, string data)
{
NetConnection conn = (NetConnection)client;
NetOutgoingMessage msg = _netServer.CreateMessage();
msg.Write(data);
_netServer.SendMessage(msg, conn, NetDeliveryMethod.ReliableOrdered);
}
public void OnIncomingDiscoveryRequest(NetPeer peer, NetIncomingMessage msg)
{
Console.WriteLine($"Received server discovery request from {msg.SenderConnection.RemoteEndPoint.Address}:{msg.SenderConnection.RemoteEndPoint.Port}");
NetOutgoingMessage response = server.CreateMessage();
response.Write("PlanetbaseMultiplayer.Server");
server.SendDiscoveryResponse(response, msg.SenderEndPoint);
}
/// <summary>
/// Sends an event with a network object to clients.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="clientConnections"></param>
/// <param name="ev"></param>
/// <param name="obj"></param>
/// <param name="method">Unreliable by default.</param>
public void SendEventToClient <T>(IList <NetConnection> clientConnections, NetworkEvents.Event ev, T obj,
NetDeliveryMethod method = NetDeliveryMethod.Unreliable)
{
var msg = server.CreateMessage();
var bytes = ev.Serialize(obj);
msg.Write(bytes);
server.SendMessage(msg, clientConnections, method, 0);
}
public override void SendMessage(IGameMessage _IGameMessage, GameMessageImportance _Importance)
{
NetOutgoingMessage om = netServer.CreateMessage();
om.Write((byte)_IGameMessage.MessageType);
_IGameMessage.Encode(om);
netServer.SendToAll(om, _Importance == GameMessageImportance.VeryImportant ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.Unreliable); // ReliableUnordered
}
public static void SendMessage(String ident, Action <NetOutgoingMessage> builder,
NetConnection recipient, NetDeliveryMethod method, int sequenceChannel = 0)
{
var msg = _server.CreateMessage();
msg.Write(_indices[ident]);
builder(msg);
_server.SendMessage(msg, recipient, method, sequenceChannel);
}
public void SendPacket(IPacket packet, NetClient client)
{
var message = server.CreateMessage();
message.Write((byte)packet.GetId());
packet.ToMessage(message);
server.SendMessage(message, client.ServerConnection, NetDeliveryMethod.ReliableSequenced, 0);
}
//TODO: do this in other places
public void Send(Packet v, NetConnection ToThis, NetDeliveryMethod DeliveryType)
{
var SendMessage = myServer.CreateMessage();
mySendFormatter.Serialize(myStream, v);
SendMessage.Write(myStream.ToArray());
myServer.SendMessage(SendMessage, ToThis, DeliveryType); //TODO: tweak this so it works for game and update
myStream.SetLength(0);
myStream.Position = 0;
}
public static void SendDataTo(string hexID, NetOutgoingMessage data, NetDeliveryMethod deliveryMethod)
{
if (Authentication.Player.Count == 0)
{
return;
}
outgoingPacket = Socket.CreateMessage(data.LengthBytes);
outgoingPacket.Write(data);
Socket.SendMessage(outgoingPacket, Authentication.FindByHexID(hexID).Connection, deliveryMethod);
}
public NetOutgoingMessage CreateMessage()
{
if (IsServer)
{
return(_Server.CreateMessage());
}
else
{
return(_Client.CreateMessage());
}
}
static void Main(string[] args)
{
int loopStartTime = 0;
int loopEndTime = 0;
float deltaSecond = 0;
//Frequency to return data
const float ReturnDataPerSecond = 20;
float lastSentData = 0;
//Team containers
ShapeTeamContainer greenTeam = new ShapeTeamContainer(ShapeTeam.GREEN);
ShapeTeamContainer redTeam = new ShapeTeamContainer(ShapeTeam.RED);
NetPeerConfiguration config = new NetPeerConfiguration("ShapeSpace");
config.Port = 55678;
config.MaximumConnections = maxPlayers;
config.ConnectionTimeout = 10;
config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
server = new NetServer(config);
//Console.WriteLine(server.Configuration.LocalAddress);
physicsWorld = new World(Vector2.Zero);
//50px = 1m
ConvertUnits.SetDisplayUnitToSimUnitRatio(50f);
try
{
server.Start();
}
catch(Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e);
Console.ForegroundColor = ConsoleColor.White;
WaitForKeyPress();
}
Console.WriteLine("Server Started Sucessfully!");
//Main program loop
while(true)
{
deltaSecond = (loopEndTime - loopStartTime) / 1000f;
lastSentData += deltaSecond;
loopStartTime = Environment.TickCount;
//Handle incoming messages
NetIncomingMessage msg;
while ((msg = server.ReadMessage()) != null)
{
//Console.WriteLine(msg.MessageType);
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
//A swith handling ShapeSpace custom message types
switch((ShapeCustomNetMessageType)msg.ReadByte())
{
case ShapeCustomNetMessageType.InputUpdate:
int playerIndex = msg.ReadInt32();
float timeSinceLast = msg.ReadFloat();
Vector2 input = msg.ReadVector2();
connectedPlayers[playerIndex].inputs.Add(new InputWithTime(timeSinceLast,input));
//Console.WriteLine(timeSinceLast + ": " + input.ToString());
break;
case ShapeCustomNetMessageType.SetupRequest:
NetOutgoingMessage returnMessage = server.CreateMessage();
NetworkPlayer newPlayer = new NetworkPlayer(physicsWorld, msg.SenderConnection, new Vector2(0,0));
//ShapeTeam team = (ShapeTeam)msg.ReadByte();
string username = msg.ReadString();
try
{
//newPlayer.SetTeam(team);
newPlayer.SetUserName(username);
int spot = AddNewPlayer(newPlayer);
newPlayer.indexOnServer = spot;
//Assign the new player to the team with the least amount of players
ShapeTeamContainer newPlayerTeam = greenTeam.GetNumberOfMembers() < redTeam.GetNumberOfMembers() ? greenTeam : redTeam;
bool isBank = newPlayerTeam.AddPlayer(newPlayer.indexOnServer);
newPlayer.SetTeam(newPlayerTeam.GetTeam());
newPlayer.body.Position = ConvertUnits.ToSimUnits(newPlayerTeam.basePosition);
if (isBank)
newPlayer.SetClass(new ShapeClassBank());
else
newPlayer.SetClass(new ShapeClassKnocker());
newPlayer.OnCreateRemnant += CreateRemnant;
}
catch(Exception e)
{
returnMessage.Write((byte)ShapeCustomNetMessageType.SetupFailed);
returnMessage.Write(e.Message);
server.SendMessage(returnMessage, newPlayer.netConnection, NetDeliveryMethod.ReliableUnordered);
break;
}
returnMessage.Write((byte)ShapeCustomNetMessageType.SetupSuccessful);
returnMessage.Write(newPlayer.indexOnServer);
returnMessage.Write((byte)newPlayer.team);
returnMessage.Write(connectedPlayersActual);
for (int i = 0; i < connectedPlayers.Length; i++)
{
if(connectedPlayers[i] != null)
{
returnMessage.Write(connectedPlayers[i].indexOnServer);
returnMessage.Write((byte)connectedPlayers[i].team);
returnMessage.Write(connectedPlayers[i].power);
}
}
server.SendMessage(returnMessage, newPlayer.netConnection, NetDeliveryMethod.ReliableUnordered);
if(connectedPlayersActual > 1)
{
NetOutgoingMessage newPlayerMessage = server.CreateMessage();
newPlayerMessage.Write((byte)ShapeCustomNetMessageType.NewPlayerJoined);
newPlayerMessage.Write(newPlayer.indexOnServer);
newPlayerMessage.Write((byte)newPlayer.team);
newPlayerMessage.Write(/*newPlayer.power*/5);
server.SendMessage(newPlayerMessage, GetRecipients(newPlayer.indexOnServer), NetDeliveryMethod.ReliableUnordered, 0);
}
Console.WriteLine("Player connected");
break;
}
break;
case NetIncomingMessageType.DiscoveryRequest:
NetOutgoingMessage response = server.CreateMessage();
response.Write("This is a Shape Space server");
server.SendDiscoveryResponse(response, msg.SenderEndPoint);
break;
case NetIncomingMessageType.ConnectionApproval:
Console.WriteLine("A client is asking to connect");
//Approve the connection and send back a hailmessage containing server info back
NetOutgoingMessage hailMessage = server.CreateMessage();
hailMessage.Write(maxPlayers);
msg.SenderConnection.Approve(hailMessage);
break;
case NetIncomingMessageType.StatusChanged:
if(msg.ReadByte() == (byte)NetConnectionStatus.Disconnected)
{
//Console.WriteLine("Player disconnected: " + FindPlayerByNetConnection(msg.SenderConnection).Username);
RemovePlayer(msg.SenderConnection);
}
break;
default:
Console.WriteLine("Unhandled type: " + msg.MessageType + " Info: \"" + msg.ReadString() + "\"");
break;
}
server.Recycle(msg);
}
//Move players
UpdatePlayers(deltaSecond);
//Simulate the world
physicsWorld.Step(1f/100f);
//Return data to clients
if (lastSentData >= 1f/ReturnDataPerSecond && connectedPlayersActual > 0)
{
//List<NetConnection> recipients = new List<NetConnection>();
NetOutgoingMessage outMess = server.CreateMessage();
outMess.Write((byte)ShapeCustomNetMessageType.LocationUpdate);
outMess.Write(connectedPlayersActual);
for (int i = 0; i < maxPlayers; i++)
{
if (connectedPlayers[i] != null)
{
outMess.Write(connectedPlayers[i].indexOnServer);
outMess.Write(connectedPlayers[i].power);
outMess.Write(lastSentData);
outMess.Write(ConvertUnits.ToDisplayUnits(connectedPlayers[i].body.Position));
int trailCount = connectedPlayers[i].trail.Count;
outMess.Write(trailCount);
for(int j = 0; j < trailCount; j++)
{
//outMess.Write(connectedPlayers[i].trail[j].Id);
outMess.Write(connectedPlayers[i].trail[j].position);
outMess.Write(connectedPlayers[i].trail[j].size);
}
}
}
//Write all remnants positions
int remnantCount = remnants.Count;
outMess.Write(remnantCount);
for (int j = 0; j < remnantCount; j++)
{
outMess.Write(remnants[j].position);
outMess.Write(remnants[j].size);
}
server.SendMessage(outMess, GetRecipients(-1), NetDeliveryMethod.UnreliableSequenced, 2);
lastSentData = 0;
}
//Make sure the server runs at about 60 frames per second
if(deltaSecond * 1000 < 1000/17)
Thread.Sleep(Convert.ToInt32(1000/17 - deltaSecond * 1000));
loopEndTime = Environment.TickCount;
}
}
