Esempio n. 1
0
        public Server()
        {
            Console.Title         = "Minerva Login Server";
            Console.CursorVisible = false;

            int start = Environment.TickCount;

            Util.Info.PrintLogo();
            Console.WriteLine();
            Util.Info.PrintInfo();
            Console.WriteLine();

            AppDomain.CurrentDomain.UnhandledException += UnhandledException;

            Log.Start("Login"); // start logging service

            clients = new HashSet <ClientHandler>();

            Log.Message("Reading configuration...", Log.DefaultFG);
            conf = new Configuration();

            Log.Message("Registering events...", Log.DefaultFG);
            events = new EventHandler();

            events.OnClientDisconnect += (sender, client) =>
            {
                Log.Notice("Client {0} disconnected from Login Server", client.RemoteEndPoint);

                // temporary disabled
                //if (client.AccountID > 0 && syncServer != null)
                //    Authentication.UpdateOnline(syncServer, client.AccountID, false);

                clients.Remove(client);
            };

            events.OnError         += (sender, message) => Log.Error(message);
            events.OnReceivePacket += (sender, e) => Log.Received(e.Name, e.Opcode, e.Length);
            events.OnSendPacket    += (sender, e) => Log.Sent(e.Name, e.Opcode, e.Length);

            events.OnIPCReceivePacket += (sender, e) => Log.IPC_Received(e.Opcode, e.Length);
            events.OnIPCSendPacket    += (sender, e) => Log.IPC_Sent(e.Opcode, e.Length);

            Log.Message("Compiling and registering scripts...", Log.DefaultFG);
            scripts = new ScriptHandler();
            scripts.Concatenate("Events", new string[] { "mscorlib" });
            scripts.Run("Events");
            scripts.CreateInstance("Events");
            scripts.Invoke("_init_", events);

            Log.Message("Registering packets...", Log.DefaultFG);
            packets = new PacketHandler("login", new PacketProtocol().GetType(), events);

            Log.Level = conf.LogLevel;

            try
            {
                listener = new TcpListener(conf.ListenIp, conf.ListenPort);
                thread   = new Thread(Listen);
                thread.Start();
                // fixme
                syncServer = new SyncReceiver(conf.MasterIp.ToString(), conf.MasterPort, events);

                Log.Notice("Debugging mode: {0}", conf.Debug ? "on" : "off");
                Log.Notice("Whitelist: {0}", conf.WhiteList ? "on" : "off");
                Log.Notice("Minerva started in: {0} seconds", (Environment.TickCount - start) / 1000.0f);
            }
            catch (Exception e)
            {
                Log.FatalError(e.Message);
                #if DEBUG
                throw e;
                #endif
            }
        }
Esempio n. 2
0
        public Server(int server, int channel)
        {
            this.server  = server;
            this.channel = channel;

            Console.Title         = "Minerva Channel Server";
            Console.CursorVisible = false;

            int start = Environment.TickCount;

            Util.Info.PrintLogo();
            Console.WriteLine();
            Util.Info.PrintInfo();
            Console.WriteLine();

            AppDomain.CurrentDomain.UnhandledException += UnhandledException;

            Configuration.Load(string.Format("Channel_{0}_{1}", server, channel));
            Log.Start(string.Format("Channel_{0}_{1}", server, channel), Configuration.channelLog, Configuration.channelLogLvl);    // Start logging service

            clients = new Dictionary <ulong, ClientHandler>();
            events  = new EventHandler();

            events.OnClientDisconnect += (sender, client) => {
                if (client.RemoteEndPoint != null)
                {
                    Log.Notice("Client {0} disconnected from Channel Server", client.RemoteEndPoint);
                    if (client.AccountID > 0 && syncServer != null)
                    {
                        Authentication.UpdateOnline(syncServer, client.AccountID, false);
                    }
                    clients.Remove((ulong)client.Metadata["magic"]);
                }
            };

            events.OnError         += (sender, message) => { Log.Error(message, "[Channel::Server::" + sender.GetType() + "()]"); };
            events.OnReceivePacket += (sender, e) => { Log.Received(e.Name, e.Opcode, e.Length); };
            events.OnSendPacket    += (sender, e) => { Log.Sent(e.Name, e.Opcode, e.Length); };
            events.OnWarp          += (sender, client, map, x, y) => { client.Metadata["map"] = maps[map]; maps[map].MoveClient(client, x / 16, y / 16); maps[map].UpdateCells(client); };

            /*Console.WriteLine("Compiling and registering scripts...");
             * scripts = new ScriptHandler();
             * scripts.Concatenate("Events", new string[] { "mscorlib" });
             * scripts.Run("Events");
             * scripts.CreateInstance("Events");
             * dynamic result = scripts.Invoke("_init_", events);*/

            try
            {
                Log.Message("Reading configuration...", Log.DefaultFG);

                mapLoader = new MapLoader();
                maps      = mapLoader.LoadMaps();

                skillLoader = new SkillLoader();
                SkillData   = skillLoader.LoadSkills();

                Log.Message("Registering packets...", Log.DefaultFG);
                packets = new PacketHandler("world", new PacketProtocol().GetType(), events);

                var aa      = Configuration.channelIp;
                var address = BitConverter.ToUInt32(aa.GetAddressBytes(), 0);
                var port    = Configuration.channelPort;

                listener = new TcpListener(aa, port);
                thread   = new Thread(Listen);
                thread.Start();

                syncServer = new SyncReceiver(Configuration.masterIP, Configuration.masterPort, events);
                syncServer.OnSyncSuccess += (sender, e) =>
                {
                    var type       = Configuration.channelType;
                    var maxPlayers = Configuration.maxPlayers;
                    Authentication.RegisterChannel(syncServer, server, channel, type, address, port, maxPlayers);
                };

                Log.Notice("Minerva started in: {0} seconds", (Environment.TickCount - start) / 1000.0f);
            }
            catch (Exception e)
            {
                Log.Error(e.Message, "[Channel::" + e.Source + "::" + e.TargetSite + "()]");
                #if DEBUG
                throw e;
                #endif
            }
        }