예제 #1
0
        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);
        }
예제 #2
0
        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();
            }
        }
예제 #3
0
        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);
        }
예제 #4
0
        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
        }
예제 #5
0
        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();
        }
예제 #6
0
        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();
        }
예제 #7
0
        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);
        }
예제 #8
0
        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);
                }
            }
        }
예제 #9
0
        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);
        }
예제 #10
0
        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;
        }
예제 #11
0
        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}.");
        }
예제 #12
0
        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();
        }
예제 #13
0
        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.");
        }