Esempio n. 1
0
        /// <summary>
        /// Handles the servers's state packet
        /// </summary>
        static public void Handle_SC_State(SC_State pkt, Client client)
        {               //Consider the connection started now, time to send our login info..
            Database db = ((client as Client <Database>)._obj);

            db._syncStart.Set();

            //Prepare our login packet
            CS_Auth <Database> auth = new CS_Auth <Database>();

            auth.zoneID          = db._config["zoneid"].intValue;
            auth.password        = db._config["password"].Value;
            auth.zoneName        = db._server._config["server/zoneName"].Value;
            auth.zoneDescription = db._server._config["server/zoneDescription"].Value;
            auth.zoneIsAdvanced  = db._server._config["server/zoneIsAdvanced"].boolValue;
            auth.zoneIP          = db._server._config["server/bindIP"].Value;
            auth.zonePort        = db._server._config["server/bindPort"].intValue;

            client.sendReliable(auth);
        }
Esempio n. 2
0
        /// <summary>
        /// Handles the client's state packet
        /// </summary>
        static public void Handle_CS_State(CS_State pkt, Client client)
        {               //Update what we know of the client's connection state
            client._stats.clientCurrentUpdate  = pkt.clientCurrentUpdate;
            client._stats.clientAverageUpdate  = pkt.clientAverageUpdate;
            client._stats.clientShortestUpdate = pkt.clientShortestUpdate;
            client._stats.clientLongestUpdate  = pkt.clientLongestUpdate;
            client._stats.clientLastUpdate     = pkt.clientLastUpdate;

            client._stats.clientPacketsSent = pkt.packetsSent;
            client._stats.clientPacketsRecv = pkt.packetsReceived;
            client._stats.serverPacketsSent = client._packetsSent;
            client._stats.serverPacketsRecv = client._packetsReceived;

            //Prepare our reply
            SC_State sci = new SC_State();

            sci.tickCount       = pkt.tickCount;
            sci.serverTickCount = Environment.TickCount;
            sci.clientSentCount = pkt.packetsSent;
            sci.clientRecvCount = pkt.packetsReceived;
            sci.serverRecvCount = client._stats.serverPacketsRecv;
            sci.serverSentCount = client._stats.serverPacketsSent;

            client.send(sci);

            //Set our sync difference
            short wander   = (short)client._timeDiff;
            int   timeDiff = (sci.serverTickCount - pkt.tickCount) & 0xFFFF;

            client._timeDiff = (short)timeDiff;

            //Calculate the clock wander
            if (wander != 0)
            {
                wander = (short)Math.Abs(client._timeDiff - wander);
                client._stats.clockWander[client._stats.wanderIdx++ % 10] = wander;
            }

            //Adjust the client's data rates accordingly
            client.adjustRates(pkt.clientAverageUpdate);
        }
Esempio n. 3
0
        /// <summary>
        /// Handles the servers's state packet
        /// </summary>
        static public void Handle_SC_State(SC_State pkt, Client client)
        {       //Consider the connection started now, time to send our login info..
            InfClient c = ((client as Client <InfClient>)._obj);

            c._syncStart.Set();

            CS_Login login = new CS_Login();

            //Lets put some bogus stuff together...
            login.bCreateAlias = false;
            login.UID1         = 99999;
            login.UID2         = 99999;
            login.UID3         = 99999;
            login.NICInfo      = 4;
            login.SysopPass    = "";
            login.Username     = "******";
            login.Version      = (ushort)154;
            login.TicketID     = "3bd5c3e9-8bea-43b8-946e-40263f8a039a";

            //Send it!
            client.send(login);
        }
Esempio n. 4
0
        /// <summary>
        /// Handles the servers's state packet
        /// </summary>
        static public void Handle_SC_State(SC_State pkt, Client client)
        {       //Consider the connection started now, time to send our login info..
            GameClient c = ((client as Client <GameClient>)._obj);

            c._syncStart.Set();

            CS_Login login = new CS_Login();

            //Lets put some bogus stuff together...
            login.bCreateAlias = false;
            login.UID1         = 99999;
            login.UID2         = 99999;
            login.UID3         = 99999;
            login.NICInfo      = 4;
            login.SysopPass    = "";
            login.Username     = c._player._alias;
            login.Version      = (ushort)154;
            login.TicketID     = c._player._ticketid;

            //Send it!
            client.send(login);
        }
Esempio n. 5
0
 /// <summary>
 /// Handles the servers's state packet
 /// </summary>
 static public void Handle_SC_State(SC_State pkt, Client client)
 {
     client._stats.serverPacketsSent = pkt.serverSentCount;
     client._stats.serverPacketsRecv = pkt.serverRecvCount;
     client._timeDiff = (short)(Environment.TickCount - pkt.serverTickCount);
 }
Esempio n. 6
0
    {   /// <summary>
        /// Creates a new system protocol packet.
        /// </summary>
        public PacketBase createSystemPacket(ushort typeID, byte[] buffer, int offset, int size)
        {       //Ready our packet base
            PacketBase packet = null;

            offset++;
            size--;

            //What are we dealing with?
            switch (typeID)
            {
            case SC_Initial.TypeID:
                packet = new SC_Initial(typeID, buffer, offset, size);
                break;

            case SC_Login.TypeID:
                packet = new SC_Login(typeID, buffer, offset, size);
                break;

            case SC_State.TypeID:
                packet = new SC_State(typeID, buffer, offset, size);
                break;

            case SC_PatchInfo.TypeID:
                packet = new SC_PatchInfo(typeID, buffer, offset, size);
                break;

            case SC_AssetInfo.TypeID:
                packet = new SC_AssetInfo(typeID, buffer, offset, size);
                break;

            case SC_SetIngame.TypeID:
                packet = new SC_SetIngame(typeID, buffer, offset, size);
                break;

            case SC_Chat.TypeID:
                packet = new SC_Chat(typeID, buffer, offset, size);
                break;

            case BoxPacket.TypeID:
                packet = new BoxPacket(typeID, buffer, offset, size);
                break;

            case Disconnect.TypeID:
                packet = new Disconnect(typeID, buffer, offset, size);
                break;

            case PingPacket.TypeID:
                packet = new PingPacket(typeID, buffer, offset, size);
                break;

            case Reliable.TypeID:
                packet = new Reliable(typeID, buffer, offset, size, 0);
                break;

            case Reliable.TypeID + 1:
                packet = new Reliable(typeID, buffer, offset, size, 1);
                break;

            case Reliable.TypeID + 2:
                packet = new Reliable(typeID, buffer, offset, size, 2);
                break;

            case Reliable.TypeID + 3:
                packet = new Reliable(typeID, buffer, offset, size, 3);
                break;

            case OutOfSync.TypeID:
                packet = new OutOfSync(typeID, buffer, offset, size, 0);
                break;

            case OutOfSync.TypeID + 1:
                packet = new OutOfSync(typeID, buffer, offset, size, 1);
                break;

            case OutOfSync.TypeID + 2:
                packet = new OutOfSync(typeID, buffer, offset, size, 2);
                break;

            case OutOfSync.TypeID + 3:
                packet = new OutOfSync(typeID, buffer, offset, size, 3);
                break;

            case ReliableEcho.TypeID:
                packet = new ReliableEcho(typeID, buffer, offset, size, 0);
                break;

            case ReliableEcho.TypeID + 1:
                packet = new ReliableEcho(typeID, buffer, offset, size, 1);
                break;

            case ReliableEcho.TypeID + 2:
                packet = new ReliableEcho(typeID, buffer, offset, size, 2);
                break;

            case ReliableEcho.TypeID + 3:
                packet = new ReliableEcho(typeID, buffer, offset, size, 3);
                break;

            case ReliableBox.TypeID:
                packet = new ReliableBox(typeID, buffer, offset, size, 0);
                break;

            case ReliableBox.TypeID + 1:
                packet = new ReliableBox(typeID, buffer, offset, size, 1);
                break;

            case ReliableBox.TypeID + 2:
                packet = new ReliableBox(typeID, buffer, offset, size, 2);
                break;

            case ReliableBox.TypeID + 3:
                packet = new ReliableBox(typeID, buffer, offset, size, 3);
                break;

            case DataPacketRcv.TypeID:
                packet = new DataPacketRcv(typeID, buffer, offset, size, 0);
                break;

            case DataPacketRcv.TypeID + 1:
                packet = new DataPacketRcv(typeID, buffer, offset, size, 1);
                break;

            case DataPacketRcv.TypeID + 2:
                packet = new DataPacketRcv(typeID, buffer, offset, size, 2);
                break;

            case DataPacketRcv.TypeID + 3:
                packet = new DataPacketRcv(typeID, buffer, offset, size, 3);
                break;

            default:
                //An undefined packet.
                packet = new PacketDummy(typeID, buffer, offset, size);
                break;
            }

            return(packet);
        }