private void LoadHandlers()
{
packetHandlers = new List <PacketHandlers>();
var handlers = reflection.GetTypes(typeof(IPacketHandler))
.Select(t => (IPacketHandler)reflection.GetInstance(t))
.ToArray();
foreach (var handler in handlers)
{
var hndlr = new PacketHandlers
{
Instance = handler,
Handlers = new Dictionary <string, MethodInfo>()
};
var methods = handler.GetType().GetMethods();
foreach (var method in methods)
{
var args = method.GetParameters();
if (args.Length < 1)
{
continue;
}
var first = args.First();
if (!first.ParameterType.GetTypeInfo().ImplementedInterfaces.Any(t => t == typeof(IPacketMap)))
{
continue;
}
if (first.ParameterType.IsAbstract || first.ParameterType.IsInterface)
{
continue;
}
var packet = (IPacketMap)Activator.CreateInstance(first.ParameterType);
if (hndlr.Handlers.ContainsKey(packet.Command.ToUpper()))
{
broadcast.BroadcastException(new Exception(), $"Handler already exists in {method.Name} for {packet.Command}");
continue;
}
hndlr.Handlers.Add(packet.Command.ToUpper(), method);
}
packetHandlers.Add(hndlr);
}
}
static public void Initialize()
{
// Only initialize our subsystem if we're enabled
if (Configuration.Enabled)
{
// Initialize static members and connect to the creation callback of a NetState.
NetState.CreatedCallback = new NetStateCreatedCallback(NetStateCreated);
// Overwrite the packet handler for the relay packet since we need to change the
// encryption mode then.
PacketHandlers.Register(0xA0, 3, false, new OnPacketReceive(HookedPlayServer));
}
}
private void InvalidateDetectImpl()
{
PlayerMobile.FastwalkPrevention = ModuleEnabled && _DetectAction != SpeedhackAction.None;
if (PlayerMobile.FastwalkPrevention)
{
PacketHandlers.RegisterThrottler(0x02, PlayerMobile.MovementThrottle_Callback);
}
else
{
PacketHandlers.RegisterThrottler(0x02, null);
}
}
public static bool AddPacketHandler(PacketType packetType, PacketMethod handler)
{
bool result = false;
lock (PacketHandlers) {
if (!PacketHandlers.ContainsKey(packetType))
{
PacketHandlers.Add(packetType, handler);
result = true;
}
}
return(result);
}
public static void Main(string[] args)
{
//Lets do the loading here to catch any exceptions.
Console.WriteLine("For future updates visit http://www.CamSpark.com");
MapData.load(); //this has to be packed once all mapdata is gotten.
ObjectData.load();
ItemData.load(); //this has to be first because npcDrops use itemData.. i think.
NpcData.load(); //first load the npc data.
NpcDrop.load(); //second load the npc drops. [order does matter here, as it binds to npcData].
NpcSpawn.load(); //finally you can spawn the npcs.
LaddersAndStairs.load();
objectManager = new WorldObjectManager();
groundItemManager = new GroundItemManager();
shopManager = new ShopManager();
minigames = new MinigamesHandler();
grandExchange = new GrandExchange();
clanManager = new ClanManager();
packetHandlers = new PacketHandlers();
loginHandler = new LoginHandler();
registerEvent(new RunEnergyEvent());
registerEvent(new LevelChangeEvent());
registerEvent(new SpecialRestoreEvent());
registerEvent(new SkullCycleEvent());
registerEvent(new AreaVariables());
registerEvent(new AggressiveNpcEvent());
registerEvent(new LowerPotionCyclesEvent());
objectManager.getFarmingPatches().processPatches();
isRunning = true;
new Thread(new ThreadStart(Server.gameThread)).Start();
new Thread(new ThreadStart(Server.eventProcessingThread)).Start();
Console.Title = "Runescape 2 530 C# Server";
// Startup the Server Listener
try
{
IPEndPoint ipe = new IPEndPoint(0, Constants.SERVER_PORT);
serverListenerSocket = new System.Net.Sockets.Socket(ipe.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
serverListenerSocket.Bind(ipe);
serverListenerSocket.Listen(25); //backlog
serverListenerSocket.BeginAccept(new AsyncCallback(acceptCallback), serverListenerSocket);
Console.WriteLine("Runescape 2 530 C# server started on port " + Constants.SERVER_PORT);
}
catch (SocketException ioe)
{
misc.WriteError("Error: Unable to startup listener on " + Constants.SERVER_PORT + " - port already in use?");
misc.WriteError(ioe.Message.ToString());
isRunning = false;
}
}
/// <summary>
/// Registers a set of packet handlers to be used by new connections
/// </summary>
/// <param name="handlers">The handlers to register</param>
public void RegisterPacketHandlers(IEnumerable <IPacketHandler> handlers)
{
foreach (IPacketHandler handler in handlers)
{
if (!PacketHandlers.ContainsKey(handler.Type))
{
PacketHandlers.Add(handler.Type, new List <IPacketHandler>(new[] { handler }));
}
else
{
PacketHandlers[handler.Type].Add(handler);
}
}
}
public bool Contains(uint serial)
{
if (_itemsProperties.TryGetValue(serial, out ItemProperty p))
{
return(true); //p.Revision != 0; <-- revision == 0 can contain the name.
}
// if we don't have the OPL of this item, let's request it to the server.
// Original client seems asking for OPL when character is not running.
// We'll ask OPL when mouse is over an object.
PacketHandlers.AddMegaClilocRequest(serial);
return(false);
}
public void SetPacketHandler(ClientPacketId id, NetPacketHandler packetHandler)
{
if (packetHandler == null)
{
throw new ArgumentNullException(nameof(packetHandler));
}
if (PacketHandlers.ContainsKey(id))
{
throw new ArgumentException($"A packet handler is already registered for \"{id}\".", nameof(id));
}
PacketHandlers.Add(id, packetHandler);
}
public void RegisterPacketHandler(IPacket packet, PacketHandler handler)
{
//TODO: Allow multiple handlers for a single packet.
if (packet == null)
{
throw new ArgumentNullException("packet");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
PacketHandlers.Add(packet.ID, handler);
}
public static void Initialize()
{
m_OldEFHandler = PacketHandlers.GetHandler(0xEF);
PacketHandlers.Register(0xEF, 21, false, new Server.Network.OnPacketReceive(LoginServerSeed));
PacketHandlers.Register(Config.EncapsulationHeader, 0, false, new Server.Network.OnPacketReceive(UOExtPacket));
uint ip = (uint)(BitConverter.ToInt32(IPAddress.Parse(Config.IP).GetAddressBytes(), 0));
m_UOExtSupport = new UOExtSupport();
m_UOExtSupport.SetStatic();
m_handler = UOExt.PacketHandler.Instatinate();
Console.WriteLine("UOExt: Adapter started.");
}
private void m_Listener_OnReceiveEvent(PacketStream P, CityClient Client)
{
byte ID = (byte)P.ReadByte();
switch (ID)
{
case 0x00:
PacketHandlers.HandleCharacterCreate(P, Client);
break;
case 0x01:
PacketHandlers.HandleClientKeyReceive(P, ref Client);
break;
}
}
public bool Execute(string[] paramsList)
{
try
{
PacketHandlers.SearchPacketHandler(Assembly.GetAssembly(typeof(AssemblyHelper)));
return(true);
}
catch (Exception ex)
{
log.Error("搜索处理类失败!", ex);
}
return(false);
}
private static void CMConfig()
{
EquipItemRequestParent = PacketHandlers.GetHandler(0x13);
DropItemRequestParent = PacketHandlers.GetHandler(0x08);
DropItemRequestParent6017 = PacketHandlers.Get6017Handler(0x08);
EquipItemParent = OutgoingPacketOverrides.GetHandler(0x2E);
PacketHandlers.Register(0x13, 10, true, EquipItemRequest);
//PacketHandlers.Register6017(0x13, 10, true, EquipItemRequest6017);
PacketHandlers.Register(0x08, 14, true, DropItemRequest);
PacketHandlers.Register6017(0x08, 15, true, DropItemRequest6017);
OutgoingPacketOverrides.Register(0x2E, true, EquipItem);
}
private void OnReceivedPacket(object sender, PacketEventArgs args)
{
var packet = args.Packet;
//Console.WriteLine(packet.Type.ToString() + "," + packet.Opcode.ToString());
if (PacketHandlers.ContainsKey(packet.Type))
{
if (PacketHandlers[packet.Type].ContainsKey(packet.Opcode))
{
if (PacketHandlers[packet.Type][packet.Opcode] != null)
{
PacketHandlers[packet.Type][packet.Opcode](packet);
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Loading Content...");
FSO.Content.Content.Init(Settings.Default.GamePath, null);
Console.WriteLine("Success!");
Console.WriteLine("Starting VM server...");
PacketHandlers.Register((byte)PacketType.VM_PACKET, false, 0, new OnPacketReceive(VMPacket));
StartVM();
while (true)
{
Thread.Sleep(16);
}
}
protected void SetupSharedDependencies()
{
var packetHandlers = new PacketHandlers();
foreach (var packetHandlerModule in this.modules)
{
foreach (var packetHandler in packetHandlerModule.GetPacketHandlers())
{
this.serviceCollection.AddSingleton(packetHandler.Value);
}
}
this.serviceCollection.AddSingleton <TBuilderOptions>(this.options);
this.serviceCollection.AddSingleton(typeof(ILogger), logger);
this.serviceCollection.AddSingleton <IPacketHandlers, PacketHandlers>();
this.serviceCollection.AddSingleton <ILogLevelProvider, LogLevelProvider>();
}
static void Socket_SocketConnection_PacketReceived_Event(SocketConnection socketConnection, Packet pak)
{
if (pak.IsValid())
{
uint Header = pak.Readuint();
switch (Header)
{
case Packets.PAK_CLI_LGNRQST: PacketHandlers.HandleLoginRequest(socketConnection, pak); break;
case Packets.PAK_CLI_FRNDLSTRQST: PacketHandlers.HandleFriendListRequest(socketConnection, pak); break;
case Packets.PAK_CLI_MEMINFORQST: PacketHandlers.HandleMemberInfoRequest(socketConnection, pak); break;
case Packets.PAK_CLI_SNDMSG: PacketHandlers.HandleMessageSend(socketConnection, pak); break;
case Packets.PAK_CLI_CHNGSTSRQST: PacketHandlers.HandleStatusChangeRequest(socketConnection, pak); break;
case Packets.PAK_CLI_OFFLNMSGRQST: PacketHandlers.HandleOfflineMessagesRequest(socketConnection, pak); break;
case Packets.PAK_CLI_FRNDADDRQST: PacketHandlers.HandleFriendAddRequest(socketConnection, pak); break;
case Packets.PAK_CLI_FRNDDNYRQST: PacketHandlers.HandleFriendDenyRequest(socketConnection, pak); break;
case Packets.PAK_CLI_CHNGUPDTRQST: PacketHandlers.HandleChangeUpdateRequest(socketConnection, pak); break;
case Packets.PAK_CLI_FRNDRMVRQST: PacketHandlers.HandleFriendRemoveRequest(socketConnection, pak); break;
case Packets.PAK_CLI_CALL_RQST: PacketHandlers.HandleCallRequest(socketConnection, pak); break;
case Packets.PAK_CLI_CALL_ACC: PacketHandlers.HandleCallAccept(socketConnection, pak); break;
case Packets.PAK_CLI_CALL_DNY: PacketHandlers.HandleCallDeny(socketConnection, pak); break;
default:
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Invalid packet from {0}, 0x{1:X}", socketConnection.IP, Header);
break;
}
}
else
{
//Console.ForegroundColor = ConsoleColor.Red;
//Console.WriteLine("Invalid packet from {0}", socketConnection.IP);
//socketConnection.clientSocket.Close();
}
}
public static void Initialize()
{
PacketHandlers.Register(0xDA, 0, true, OnPacket);
RegisterSubCommand(0x6, ExitGame);
RegisterSubCommand(0xA, GivePoints);
RegisterSubCommand(0xB, RollDice);
RegisterSubCommand(0xC, BuildWalls);
RegisterSubCommand(0xD, ResetScores);
RegisterSubCommand(0xF, AssignDealer);
RegisterSubCommand(0x10, OpenSeat);
RegisterSubCommand(0x11, ChangeOption);
RegisterSubCommand(0x15, MoveWallBreakIndicator);
RegisterSubCommand(0x16, TogglePublicHand);
RegisterSubCommand(0x17, MoveTile);
RegisterSubCommand(0x18, MoveDealerIndicator);
}
public static void Initialize()
{
PacketHandlers.Register(0xDA, 0, true, new OnPacketReceive(OnPacket));
RegisterSubCommand(0x6, new OnMahjongPacketReceive(ExitGame));
RegisterSubCommand(0xA, new OnMahjongPacketReceive(GivePoints));
RegisterSubCommand(0xB, new OnMahjongPacketReceive(RollDice));
RegisterSubCommand(0xC, new OnMahjongPacketReceive(BuildWalls));
RegisterSubCommand(0xD, new OnMahjongPacketReceive(ResetScores));
RegisterSubCommand(0xF, new OnMahjongPacketReceive(AssignDealer));
RegisterSubCommand(0x10, new OnMahjongPacketReceive(OpenSeat));
RegisterSubCommand(0x11, new OnMahjongPacketReceive(ChangeOption));
RegisterSubCommand(0x15, new OnMahjongPacketReceive(MoveWallBreakIndicator));
RegisterSubCommand(0x16, new OnMahjongPacketReceive(TogglePublicHand));
RegisterSubCommand(0x17, new OnMahjongPacketReceive(MoveTile));
RegisterSubCommand(0x18, new OnMahjongPacketReceive(MoveDealerIndicator));
}
private void OnMessage(SockChatConnection conn, string msg)
{
bool hasSession = conn.Session != null;
RateLimitState rateLimit = RateLimitState.None;
if (!hasSession || !Context.RateLimiter.HasRankException(conn.Session.User))
{
rateLimit = Context.RateLimiter.BumpConnection(conn);
}
Logger.Debug($@"[{conn}] {rateLimit}");
if (!hasSession && rateLimit == RateLimitState.Drop)
{
conn.Close();
return;
}
IEnumerable <string> args = msg.Split(IServerPacket.SEPARATOR);
if (!Enum.TryParse(args.ElementAtOrDefault(0), out ClientPacketId packetId))
{
return;
}
if (packetId != ClientPacketId.Authenticate)
{
if (!hasSession)
{
return;
}
if (rateLimit == RateLimitState.Drop)
{
Context.BanUser(conn.Session.User, Context.RateLimiter.BanDuration, UserDisconnectReason.Flood);
return;
} /*else if(rateLimit == RateLimitState.Warn)
* sess.SendPacket(new FloodWarningPacket(Context.Bot));*/
}
if (PacketHandlers.TryGetValue(packetId, out IPacketHandler handler))
{
handler.HandlePacket(new PacketHandlerContext(args, conn));
}
}
public static void Configure()
{
EventSink.QuestGumpRequest += XmlQuest.QuestButton;
ContentChangeParent = PacketHandlers.GetHandler(0x66);
UseReqParent = PacketHandlers.GetHandler(0x06);
LookReqParent = PacketHandlers.GetHandler(0x09);
PacketHandlers.Register(0x66, 0, true, BaseEntryBook.ContentChange);
PacketHandlers.Register(0x06, 5, true, XmlAttach.UseReq);
PacketHandlers.Register(0x09, 5, true, XmlAttach.LookReq);
#if CLIENT6017
PacketHandlers.Register6017(0x66, 0, true, BaseEntryBook.ContentChange);
PacketHandlers.Register6017(0x06, 5, true, XmlAttach.UseReq);
PacketHandlers.Register6017(0x09, 5, true, XmlAttach.LookReq);
#endif
}
static void Init()
{
Console.WriteLine("Loading Content...");
FSO.Content.Content.Init(Settings.Default.GamePath, null);
Console.WriteLine("Success!");
Console.WriteLine("Starting VM server...");
PacketHandlers.Register((byte)PacketType.VM_PACKET, false, 0, new OnPacketReceive(VMPacket));
StartVM();
Stream inputStream = Console.OpenStandardInput();
while (true)
{
inst.SendMessage(Console.ReadLine());
}
}
public IClient Build()
{
var packetHandlers = new PacketHandlers();
foreach (var packetHandlerModule in this.modules)
{
foreach (var packetHandler in packetHandlerModule.GetPacketHandlers())
{
this.serviceCollection.AddSingleton(packetHandler.Value);
}
}
this.serviceCollection.AddSingleton(this.options);
this.serviceCollection.AddSingleton <IClient, Client>();
this.serviceCollection.AddSingleton <IClientPacketProcessor, ClientPacketProcessor>();
this.serviceCollection.AddSingleton <IPacketHandlers>(packetHandlers);
this.serviceCollection.AddSingleton <ILogLevelProvider, LogLevelProvider>();
if (this.logger == null)
{
this.serviceCollection.AddSingleton <ILogger, NoOpLogger>();
}
var serviceProvider = this.serviceCollection.BuildServiceProvider();
PacketSerialiserProvider.PacketSerialiser = serviceProvider.GetService <IPacketSerialiser>();
serviceProvider.GetService <ILogLevelProvider>().SetLogLevel(this.options.LogLevel);
foreach (var packetHandlerModule in this.modules)
{
foreach (var packetHandler in packetHandlerModule.GetPacketHandlers())
{
packetHandlers.Add(PacketSerialiserProvider.PacketSerialiser.CanReadName ? packetHandler.Key.Name : "Default",
(IPacketHandler)serviceProvider.GetService(packetHandler.Value));
}
}
if (!PacketSerialiserProvider.PacketSerialiser.CanReadName && packetHandlers.GetPacketHandlers().Count > 1)
{
throw new Exception("A PacketSerialiser which cannot identify a packet can only support up to one packet type");
}
return(serviceProvider.GetService <IClient>());
}
private void HandlePacket(byte typeA, byte typeB, byte flags1, byte flags2, byte[] data, uint position,
uint size)
{
var handler = PacketHandlers.GetHandlerFor(typeA, typeB);
string packetName;
if (handler != null)
{
packetName = $"{handler.GetType().Name} ({typeA:X}-{typeB:X})";
}
else
{
packetName = $"{typeA:X}-{typeB:X}";
}
Logger.Write($"[-->] Packet {packetName} (flags {(PacketFlags)flags1}) ({size + 8} bytes)");
if (Logger.VerbosePackets && size > 0) // TODO: This is trimming too far?
{
var dataTrimmed = new byte[size];
for (var i = 0; i < size; i++)
{
dataTrimmed[i] = data[i];
}
var info = string.Format("[-->] {0:X}-{1:X} Data:", typeA, typeB);
Logger.WriteHex(info, dataTrimmed);
}
var packet = new byte[size];
Array.Copy(data, position, packet, 0, size);
LogPacket(true, typeA, typeB, flags1, flags2, packet);
if (handler != null)
{
handler.HandlePacket(this, flags1, packet, 0, size);
}
else
{
Logger.WriteWarning("[!!!] UNIMPLEMENTED PACKET {0:X}-{1:X} - (Flags {2}) ({3} bytes)", typeA,
typeB, (PacketFlags)flags1, size);
}
// throw new NotImplementedException();
}
static NetworkFacade()
{
Client = new NetworkClient(GlobalSettings.Default.LoginServerIP, GlobalSettings.Default.LoginServerPort,
GonzoNet.Encryption.EncryptionMode.AESCrypto, true);
Client.OnConnected += new OnConnectedDelegate(UIPacketSenders.SendLoginRequest);
Controller = new NetworkController();
Controller.Init(Client);
RNGCryptoServiceProvider Random = new RNGCryptoServiceProvider();
ClientNOnce = new byte[16];
Random.GetNonZeroBytes(ClientNOnce);
//PacketHandlers.Init();
PacketHandlers.Register((byte)PacketType.LOGIN_NOTIFY, false, 0, new OnPacketReceive(Controller._OnLoginNotify));
PacketHandlers.Register((byte)PacketType.LOGIN_FAILURE, false, 0, new OnPacketReceive(Controller._OnLoginFailure));
PacketHandlers.Register((byte)PacketType.LOGIN_SUCCESS, true, 0, new OnPacketReceive(Controller._OnLoginSuccess));
PacketHandlers.Register((byte)PacketType.INVALID_VERSION, false, 2, new OnPacketReceive(Controller._OnInvalidVersion));
PacketHandlers.Register((byte)PacketType.CHARACTER_LIST, true, 0, new OnPacketReceive(Controller._OnCharacterList));
PacketHandlers.Register((byte)PacketType.CITY_LIST, true, 0, new OnPacketReceive(Controller._OnCityList));
PacketHandlers.Register((byte)PacketType.NEW_CITY_SERVER, true, 0, new OnPacketReceive(Controller._OnNewCity));
PacketHandlers.Register((byte)PacketType.CITY_SERVER_OFFLINE, true, 0, new OnPacketReceive(Controller._OnCityServerOffline));
PacketHandlers.Register((byte)PacketType.CHARACTER_CREATION_STATUS, true, 0, new OnPacketReceive(Controller._OnCharacterCreationProgress));
PacketHandlers.Register((byte)PacketType.RETIRE_CHARACTER_STATUS, true, 0, new OnPacketReceive(Controller._OnRetireCharacterStatus));
PacketHandlers.Register((byte)PacketType.LOGIN_NOTIFY_CITY, false, 0, new OnPacketReceive(Controller._OnLoginNotifyCity));
PacketHandlers.Register((byte)PacketType.LOGIN_SUCCESS_CITY, true, 0, new OnPacketReceive(Controller._OnLoginSuccessCity));
PacketHandlers.Register((byte)PacketType.LOGIN_FAILURE_CITY, false, 0, new OnPacketReceive(Controller._OnLoginFailureCity));
PacketHandlers.Register((byte)PacketType.CHARACTER_CREATE_CITY, true, 0, new OnPacketReceive(Controller._OnCharacterCreationStatus));
PacketHandlers.Register((byte)PacketType.REQUEST_CITY_TOKEN, true, 0, new OnPacketReceive(Controller._OnCityToken));
PacketHandlers.Register((byte)PacketType.CITY_TOKEN, true, 0, new OnPacketReceive(Controller._OnCityTokenResponse));
PacketHandlers.Register((byte)PacketType.PLAYER_JOINED_SESSION, true, 0, new OnPacketReceive(Controller._OnPlayerJoinedSession));
PacketHandlers.Register((byte)PacketType.PLAYER_LEFT_SESSION, true, 0, new OnPacketReceive(Controller._OnPlayerLeftSession));
PacketHandlers.Register((byte)PacketType.PLAYER_RECV_LETTER, true, 0, new OnPacketReceive(Controller._OnPlayerRecvdLetter));
PacketHandlers.Register((byte)PacketType.PLAYER_ALREADY_ONLINE, true, 0, new OnPacketReceive(Controller._OnPlayerAlreadyOnline));
PacketHandlers.Register((byte)PacketType.TIME_OF_DAY, true, 0, new OnPacketReceive(Controller._OnTimeOfDay));
PacketHandlers.Register((byte)PacketType.LOT_COST, true, 0, new OnPacketReceive(Controller._OnLotCost));
PacketHandlers.Register((byte)PacketType.LOT_UNBUILDABLE, true, 0, new OnPacketReceive(Controller._OnLotUnbuildable));
PacketHandlers.Register((byte)PacketType.LOT_PURCHASE_FAILED, true, 0, new OnPacketReceive(Controller._OnLotBuyFailed));
PacketHandlers.Register((byte)PacketType.LOT_PURCHASE_SUCCESSFUL, true, 0, new OnPacketReceive(Controller._OnLotPurchaseSuccessful));
PacketHandlers.Register((byte)PacketType.LOT_NAME_TOO_LONG, true, 0, new OnPacketReceive(Controller._OnLotNameTooLong));
PacketHandlers.Register((byte)PacketType.VM_PACKET, false, 0, new OnPacketReceive(UIPacketHandlers.OnVMPacket));
}
private void Dispose(bool disposing)
{
if (m_Disposed)
{
return;
}
if (disposing)
{
KeepAliveManager.Dispose();
NetworkManager.Dispose();
PluginManager.Dispose();
PacketHandlers.Clear();
DefaultPacketHandlers.Clear();
}
m_Disposed = true;
}
public static void MobileQuery2(NetState state, PacketReader pvSrc)
{
Mobile from = state.Mobile;
pvSrc.ReadInt32(); // 0xEDEDEDED
int type = pvSrc.ReadByte();
Mobile m = World.FindMobile(pvSrc.ReadInt32());
if (m != null)
{
switch (type)
{
case 0x00: // Unknown, sent by godclient
{
if (PacketHandlers.VerifyGC(state))
{
Console.WriteLine("God Client: {0}: Query 0x{1:X2} on {2} '{3}'", state, type, m.Serial, m.Name);
}
break;
}
case 0x04: // Stats
{
m.OnStatsQuery(from);
break;
}
case 0x05:
{
m.SendGump(new TMSS.ParallelSkillsGump(m));
break;
}
default:
{
pvSrc.Trace(state);
break;
}
}
}
}
public void Start()
{
Logger.WriteInternal("Server starting at " + DateTime.Now.ToString());
server = new Server();
Config.Load();
PacketHandlers.LoadPacketHandlers();
Logger.WriteInternal("[DB ] Loading database...");
database = new PolarisEF();
for (int i = 0; i < 10; i++)
{
queryServers.Add(new QueryServer(QueryMode.ShipList, 12099 + (100 * i)));
}
server.Run();
}
public void HandleServerPacket(byte[] PacketData)
{
//We need to essentially keep reading information from the packet until there is nothing left, at the start of each section of data will be the packet type identifier so you know what
//comes next and how it should be handled
//Open up the network packet
PacketReader Reader = new PacketReader(PacketData);
//Display how much information there is to be read from this packet
//Log.Print(Reader.BytesLeft() + " bytes of data left to read from the packet");
while (!Reader.FinishedReading())
{
int PacketType = Reader.ReadInt();
if (PacketHandlers.TryGetValue(PacketType, out PacketHandle PacketHandle))
{
PacketHandle.Invoke(Reader);
}
}
}
internal static bool ConnectClientToPC(NetState client, PlayerMobile Subject)
{
if (Subject != null && Subject.NetState == null)
{
Mobile clientMobile = client.Mobile;
Subject.NetState = client;
if (clientMobile != null)
{
clientMobile.NetState = null;
}
Subject.NetState.Mobile = Subject;
PacketHandlers.DoLogin(Subject.NetState, Subject);
return(true);
}
return(false);
}
