public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character != null)
{
return;
}
var playerEntity = State.World.CreatePlayer(connection, "prt_fild08", Area.CreateAroundPoint(new Position(170, 367), 5));
connection.Entity = playerEntity;
connection.LastKeepAlive = Time.ElapsedTime;
connection.Character = playerEntity.Get <Character>();
connection.Character.IsActive = false;
var networkPlayer = playerEntity.Get <Player>();
networkPlayer.Connection = connection;
connection.Player = networkPlayer;
ServerLogger.Debug($"Player assigned entity {playerEntity}, creating entity at location {connection.Character.Position}.");
CommandBuilder.InformEnterServer(connection.Character, networkPlayer);
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null)
{
return; //we don't accept the keep-alive packet if they haven't entered the world yet
}
var player = connection.Entity.Get <Player>();
if (player.InActionCooldown())
{
ServerLogger.Debug("Player click ignored due to cooldown.");
return;
}
player.AddActionDelay(CooldownActionType.Click);
player.Target = EcsEntity.Null;
var x = msg.ReadInt16();
var y = msg.ReadInt16();
var target = new Position(x, y);
if (connection.Character.TryMove(ref connection.Entity, target, 0))
{
player.ClearTarget();
}
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null)
{
return;
}
var player = connection.Entity.Get <Player>();
if (player.InActionCooldown())
{
ServerLogger.Debug("Player sit/stand action ignored due to cooldown.");
return;
}
player.AddActionDelay(CooldownActionType.SitStand);
var isSitting = msg.ReadBoolean();
connection.Character.SitStand(ref connection.Entity, isSitting);
}
public static void HandleMessage(NetIncomingMessage msg)
{
var type = (PacketType)msg.ReadByte();
#if DEBUG
if (State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection) && connection.Entity.IsAlive())
{
ServerLogger.Debug($"Received message of type: {System.Enum.GetName(typeof(PacketType), type)} from entity {connection.Entity}.");
}
else
{
ServerLogger.Debug($"Received message of type: {System.Enum.GetName(typeof(PacketType), type)} from entity-less connection.");
}
State.LastPacketType = type;
State.PacketHandlers[(int)type](msg);
#endif
#if !DEBUG
try
{
State.LastPacketType = type;
State.PacketHandlers[(int)type](msg);
}
catch (Exception)
{
ServerLogger.LogError($"Error executing packet handler for packet type {type}");
throw;
}
#endif
}
public void PerformRemovals()
{
for (var i = 0; i < removeList.Count; i++)
{
var entity = removeList[i];
if (entity.IsNull() || !entity.IsAlive())
{
return;
}
ServerLogger.Debug($"Removing entity {entity} from world.");
var player = entity.Get <Player>();
var combatant = entity.Get <CombatEntity>();
var monster = entity.Get <Monster>();
var ch = entity.Get <Character>();
player?.Reset();
combatant?.Reset();
ch?.Reset();
monster?.Reset();
entity.Destroy();
}
removeList.Clear();
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null)
{
return;
}
var player = connection.Entity.Get <Player>();
if (player.InActionCooldown())
{
ServerLogger.Debug("Player stop action ignored due to cooldown.");
return;
}
player.AddActionDelay(CooldownActionType.StopAction);
connection.Character.StopAction();
connection.Player.ClearTarget();
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null)
{
return;
}
var player = connection.Entity.Get <Player>();
if (player.InActionCooldown())
{
ServerLogger.Debug("Player look action ignored due to cooldown.");
return;
}
player.AddActionDelay(CooldownActionType.FaceDirection);
var dir = (Direction)msg.ReadByte();
var head = (HeadFacing)msg.ReadByte();
connection.Character.ChangeLookDirection(ref connection.Entity, dir, head);
}
public static void ProcessIncomingMessages()
{
while (State.Server.ReadMessage(out var msg))
{
try
{
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
{
ServerLogger.Debug("[Network] Incoming connection request: " + msg.SenderConnection);
var playerConnection = new NetworkConnection(msg.SenderConnection);
playerConnection.LastKeepAlive = Time.ElapsedTime + 20; //you get an extra 20 seconds on first load before we kick you
var msgOut = State.Server.CreateMessage(64);
msgOut.Write((byte)0x90);
msg.SenderConnection.Approve(msgOut);
State.ConnectionLookup.Add(playerConnection.ClientConnection, playerConnection);
State.Players.Add(playerConnection);
}
break;
case NetIncomingMessageType.Data:
HandleMessage(msg);
break;
case NetIncomingMessageType.StatusChanged:
ServerLogger.Debug("Client status changed: " + System.Enum.GetName(typeof(NetConnectionStatus), msg.SenderConnection.Status));
break;
case NetIncomingMessageType.DebugMessage:
ServerLogger.Debug($"[Network] DebugMessage: {msg.ReadString()}");
break;
case NetIncomingMessageType.WarningMessage:
ServerLogger.LogWarning($"[Network] Warning: {msg.ReadString()}");
break;
default:
Console.WriteLine(
$"[Network] We encountered a packet type we didn't handle: {msg.MessageType}");
break;
}
}
#if !DEBUG
catch (Exception e)
{
ServerLogger.LogWarning("Received invalid packet which generated an exception. Error: " +
e.Message);
}
#endif
finally
{
State.Server.Recycle(msg);
}
}
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.DebugMode)
{
ServerLogger.LogWarning("Player connected with debug packet EnterServerSpecificMap, disconnecting player.");
State.PacketHandlers[(int)PacketType.Disconnect](msg); //yeah no
return;
}
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character != null)
{
return;
}
var mapName = msg.ReadString();
var hasPosition = msg.ReadBoolean();
var area = Area.Zero;
if (hasPosition)
{
var x = msg.ReadInt16();
var y = msg.ReadInt16();
var target = new Position(x, y);
ServerLogger.Debug($"Player chose to spawn at specific point: {x},{y}");
area = Area.CreateAroundPoint(target, 0);
}
var playerEntity = State.World.CreatePlayer(connection, mapName, area);
connection.Entity = playerEntity;
connection.LastKeepAlive = Time.ElapsedTime;
connection.Character = playerEntity.Get <Character>();
connection.Character.ClassId = 200; //Gamemaster
connection.Character.MoveSpeed = 0.08f;
connection.Character.IsActive = false;
var networkPlayer = playerEntity.Get <Player>();
networkPlayer.Connection = connection;
var ce = connection.Entity.Get <CombatEntity>();
ce.Stats.Atk = 9999;
ce.Stats.Atk2 = 9999;
ServerLogger.Debug($"Player assigned entity {playerEntity}, creating entity at location {connection.Character.Position}.");
CommandBuilder.InformEnterServer(connection.Character, networkPlayer);
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null || !connection.Character.IsActive)
{
ServerLogger.Debug("Ignored player ping packet as the player isn't alive in the world yet.");
return; //we don't accept the keep-alive packet if they haven't entered the world yet
}
connection.LastKeepAlive = Time.ElapsedTime;
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null)
{
return;
}
connection.Character.IsActive = true;
connection.Character.Map.SendAllEntitiesToPlayer(ref connection.Entity);
connection.Character.Map.SendAddEntityAroundCharacter(ref connection.Entity, connection.Character);
connection.Character.SpawnImmunity = 5f;
ServerLogger.Debug($"Player {connection.Entity} finished loading, spawning him on {connection.Character.Map.Name} at position {connection.Character.Position}.");
}
public override void HandlePacket(NetIncomingMessage msg)
{
if (!State.ConnectionLookup.TryGetValue(msg.SenderConnection, out var connection))
{
return;
}
if (connection.Character == null)
{
return;
}
var player = connection.Entity.Get <Player>();
if (player.InActionCooldown())
{
ServerLogger.Debug("Player stop action ignored due to cooldown.");
return;
}
var ch = connection.Character;
var map = ch.Map;
var p = new Position();
do
{
p = new Position(GameRandom.Next(0, map.Width - 1), GameRandom.Next(0, map.Height - 1));
} while (!map.WalkData.IsCellWalkable(p));
player.AddActionDelay(1.1f); //add 1s to the player's cooldown times. Should lock out immediate re-use.
ch.ResetState();
ch.SpawnImmunity = 5f;
map.TeleportEntity(ref connection.Entity, ch, p);
var ce = connection.Entity.Get <CombatEntity>();
ce.ClearDamageQueue();
}
public static void Init(World gameWorld)
{
State = new ServerState();
State.World = gameWorld;
//policy server is required for web build, but since webGL doesn't support lidgren, it's disabled
//StartPolicyServer();
if (!DataManager.TryGetConfigInt("Port", out var port))
{
throw new Exception("Configuration does not have value for port!");
}
if (!DataManager.TryGetConfigInt("MaxConnections", out var maxConnections))
{
throw new Exception("Configuration does not have value for max connections!");
}
if (DataManager.TryGetConfigInt("Debug", out var debug))
{
State.DebugMode = debug == 1;
}
#if DEBUG
State.DebugMode = true;
#else
ServerLogger.LogWarning("Server is started using debug mode config flag! Be sure this is what you want.");
#endif
ServerLogger.Log($"Starting server listening on port {port}, with a maximum of {maxConnections} connections.");
//Alright, now onto the regular server.
State.Config = new NetPeerConfiguration("RebuildZoneServer");
State.Config.Port = port;
State.Config.MaximumConnections = maxConnections;
State.Config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
State.Server = new NetServer(State.Config);
State.Server.Start();
var handlerCount = System.Enum.GetNames(typeof(PacketType)).Length;
State.PacketHandlers = new Action <NetIncomingMessage> [handlerCount];
foreach (var type in Assembly.GetAssembly(typeof(NetworkManager)).GetTypes()
.Where(t => t.IsClass && t.IsSubclassOf(typeof(ClientPacketHandler))))
{
var handler = (ClientPacketHandler)Activator.CreateInstance(type);
var packetType = handler.PacketType;
handler.State = State;
if (State.PacketHandlers[(int)packetType] != null)
{
throw new Exception($"Duplicate packet handler exists for type {packetType}!");
}
State.PacketHandlers[(int)packetType] = handler.HandlePacket;
}
for (var i = 0; i < handlerCount; i++)
{
if (State.PacketHandlers[i] == null)
{
ServerLogger.Debug($"No packet handler for packet type PacketType.{(PacketType) i} exists.");
State.PacketHandlers[i] = State.PacketHandlers[(int)PacketType.UnhandledPacket];
}
}
ServerLogger.Log("Server started.");
}
