Example #1
0
        /// <summary>
        /// Triggered when the client is ready to download the game state
        /// </summary>
        static public void Handle_CS_Ready(CS_Ready pkt, Player player)
        {
            using (LogAssume.Assume(player._server._logger))
            {                   //Fake patch server packet
                SC_PatchInfo pinfo = new SC_PatchInfo();

                pinfo.Unk1        = false;
                pinfo.patchServer = "patch.station.sony.com";
                pinfo.patchPort   = 0x1b58;
                pinfo.patchXml    = "patch/infantry/Zone7130.xml";

                player._client.sendReliable(pinfo);

                //Send him the asset list
                SC_AssetInfo assets = new SC_AssetInfo(Helpers._server._assets.getAssetList());

                //Optional updates?
                if ((int)player.PermissionLevel >= 3)
                {
                    assets.bOptionalUpdate = true;
                }
                else
                {
                    assets.bOptionalUpdate = false;
                }

                player._client.sendReliable(assets);

                //We can now consider him past the login process
                player._bLoggedIn = true;
            }
        }
Example #2
0
        /// <summary>
        /// Creates a new packet based on the typeID and the received content
        /// inside the buffer. The user has to create an own implementation
        /// of this interface.
        /// </summary>
        public PacketBase createPacket(NetworkClient client, ushort typeID, byte[] buffer, int offset, int size)
        {       //Ready our packet base
            PacketBase packet = null;

            size--;

            //Was it a system packet?
            if (buffer[offset++] == 0)
            {
                //Yes, find the appropriate type
                return(createSystemPacket(typeID, buffer, offset, size));
            }

            //So what was the typeid?
            switch (typeID)
            {
            case SC_Login.TypeID:
                packet = new SC_Login(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;


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

            return(packet);
        }
Example #3
0
 /// <summary>
 /// Handles the server's PatchInfo reply
 /// </summary>
 static public void Handle_SC_PatchInfo(SC_PatchInfo pkt, Client client)
 {
     Log.write("(PatchServer={0}:{1}) (Xml={2})", pkt.patchServer, pkt.patchPort, pkt.patchXml);
 }
Example #4
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);
        }