public PacketHandler(MethodInfo info, SessionStatus status, PacketProcessing processingplace, Type type)
{
methodCaller = (Action <WorldSession, ClientPacket>)GetType().GetMethod("CreateDelegate", BindingFlags.Static | BindingFlags.NonPublic).MakeGenericMethod(type).Invoke(null, new object[] { info });
sessionStatus = status;
ProcessingPlace = processingplace;
packetType = type;
}
void Unsubscribe(PacketProcessing Processor)
{
Processor.Connected -= ServerProcessor_Connected;
Processor.ConnectionLost -= ServerProcessor_ConnectionLost;
Processor.AudioCommandPacketReceived -= ServerProcessor_AudioCommandPacketReceived;
Processor.CommsIncomingPacketReceived -= ServerProcessor_CommsIncomingPacketReceived;
Processor.CommsOutgoingPacketReceived -= ServerProcessor_CommsOutgoingPacketReceived;
Processor.DestroyObjectPacketReceived -= ServerProcessor_DestroyObjectPacketReceived;
Processor.EngGridUpdatePacketReceived -= ServerProcessor_EngGridUpdatePacketReceived;
Processor.ExceptionEncountered -= ServerProcessor_ExceptionEncountered;
Processor.GameMessagePacketReceived -= ServerProcessor_GameMessagePacketReceived;
Processor.GameStartPacketReceived -= ServerProcessor_GameStartPacketReceived;
Processor.IncomingAudioPacketReceived -= ServerProcessor_IncomingAudioPacketReceived;
Processor.IntelPacketReceived -= ServerProcessor_IntelPacketReceived;
Processor.ObjectStatusUpdatePacketReceived -= ServerProcessor_ObjectStatusUpdatePacketReceived;
Processor.PackageReceived -= ServerProcessor_PackageReceived;
Processor.ShipAction2PacketReceived -= ServerProcessor_ShipAction2PacketReceived;
Processor.ShipAction3PacketReceived -= ServerProcessor_ShipAction3PacketReceived;
Processor.ShipActionPacketReceived -= ServerProcessor_ShipActionPacketReceived;
Processor.StationStatusPacketReceived -= ServerProcessor_StationStatusPacketReceived;
Processor.UndefinedPacketReceived -= ServerProcessor_UndefinedPacketReceived;
Processor.Unknown2PacketReceived -= ServerProcessor_Unknown2PacketReceived;
Processor.VersionPacketReceived -= ServerProcessor_VersionPacketReceived;
Processor.WelcomePacketReceived -= ServerProcessor_WelcomePacketReceived;
Processor.NewConnectionCreated -= Processor_NewClientConnected;
}
void ServerProcessor_PackageReceived(object sender, PackageEventArgs e)
{
Guid TargetID = Guid.Empty;
Guid SourceID = e.ID;
PacketProcessing pp = null;
if (!filteredPackets.Contains((uint)e.ReceivedPacket.PacketType))
{
KeyValuePair <PacketProcessing, ProxyPackageEventArgs> key = GetProxyPacketEventArgs(e);
pp = key.Key;
if (proxyType == ProxyType.OneServerConnectionToOneClientConnection)
{
pp.Send(TargetID, e.ReceivedPacket);
}
else
{
pp.Send(e.ReceivedPacket);
}
if (PackageReceived != null)
{
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(RaisePackageRecieved), key.Value);
}
}
//@@@
}
KeyValuePair <PacketProcessing, ProxyPackageEventArgs> GetProxyPacketEventArgs(PackageEventArgs e)
{
Guid TargetID = Guid.Empty;
KeyValuePair <PacketProcessing, ProxyPackageEventArgs> retVal;
PacketProcessing pp = (e.ReceivedPacket.Origin == OriginType.Client) ? serverProcessor : clientProcessor;
if (e.ReceivedPacket.Origin == OriginType.Client)
{
pp = serverProcessor;
if (proxyType == ProxyType.OneServerConnectionToOneClientConnection)
{
TargetID = ClientsToServers[e.ID];
}
}
else
{
pp = clientProcessor;
if (proxyType == ProxyType.OneServerConnectionToOneClientConnection)
{
TargetID = ServersToClients[e.ID];
}
}
retVal = new KeyValuePair <PacketProcessing, ProxyPackageEventArgs>(pp, new ProxyPackageEventArgs(e.ID, TargetID, e.ReceivedPacket));
return(retVal);
}
void Connect()
{
Disconnect();
if (!string.IsNullOrEmpty(View.Host) && View.Port > 0)
{
connector = new PacketProcessing();
ConnectorSubscribe();
connector.SetPort(View.Port);
connector.SetServerHost(View.Host);
connector.StartServerConnection();
}
reConnectCount++;
}
void StartServerConnection()
{
if (serverProcessor == null)
{
serverProcessor = new PacketProcessing();
serverProcessor.SetPort(ServerPort);
serverProcessor.SetServerHost(ServerHost);
serverProcessor.StartServerConnection();
}
else
{
if (proxyType == ProxyType.OneServerConnectionToOneClientConnection)
{
serverProcessor.StartServerConnection();
}
}
}
public Proxy(string serverHost, int serverPort, int listeningPort, ProxyType pType, uint[] packetFilter)
{
ServerHost = serverHost;
ServerPort = serverPort;
if (packetFilter != null)
{
filteredPackets = new List <uint>(packetFilter);
}
else
{
filteredPackets = new List <uint>();
}
proxyType = pType;
clientProcessor = new PacketProcessing();
clientProcessor.SetPort(listeningPort);
Subscribe(clientProcessor);
clientProcessor.StartClientListener();
}
private void UpdateUi(int packetsWaiting = 0)
{
if (!NeedInit)
{
if (BasicTeraData.Instance.WindowData.EnableChat != MessageFactory.ChatEnabled)
{
MessageFactory.ChatEnabled = BasicTeraData.Instance.WindowData.EnableChat;
if (BasicTeraData.Instance.WindowData.EnableChat)
{
AbnormalityTracker.AbnormalityAdded += NotifyProcessor.Instance.AbnormalityNotifierAdded;
AbnormalityTracker.AbnormalityRemoved += NotifyProcessor.Instance.AbnormalityNotifierRemoved;
}
else
{
AbnormalityTracker.AbnormalityAdded -= NotifyProcessor.Instance.AbnormalityNotifierAdded;
AbnormalityTracker.AbnormalityRemoved -= NotifyProcessor.Instance.AbnormalityNotifierRemoved;
}
PacketProcessing.Update();
}
NotifyProcessor.Instance.AbnormalityNotifierMissing();
}
_lastTick = DateTime.UtcNow.Ticks;
var handler = TickUpdated;
var currentBoss = Encounter;
var timedEncounter = TimedEncounter;
var entities = Database.Database.Instance.AllEntity();
var filteredEntities = entities.Select(entityid => EntityTracker.GetOrNull(entityid)).OfType <NpcEntity>().Where(npc => npc.Info.Boss).ToList();
if (packetsWaiting > 1500 && filteredEntities.Count > 1)
{
Database.Database.Instance.DeleteAllWhenTimeBelow(Encounter);
entities = Database.Database.Instance.AllEntity();
filteredEntities = entities.Select(entityid => EntityTracker.GetOrNull(entityid)).OfType <NpcEntity>().Where(npc => npc.Info.Boss).ToList();
}
var entityInfo = Database.Database.Instance.GlobalInformationEntity(currentBoss, timedEncounter);
if (currentBoss != null)
{
long entityHP = 0;
NotifyProcessor.Instance._lastBosses.TryGetValue(currentBoss.Id, out entityHP);
var entityDamaged = currentBoss.Info.HP - entityHP;
entityInfo.TimeLeft = entityDamaged == 0 ? 0 : entityInfo.Interval * entityHP / entityDamaged;
}
Skills skills = null;
if (SendFullDetails)
{
skills = Database.Database.Instance.GetSkills(entityInfo.BeginTime, entityInfo.EndTime);
SendFullDetails = false;
}
var playersInfo = timedEncounter
? Database.Database.Instance.PlayerDamageInformation(entityInfo.BeginTime, entityInfo.EndTime)
: Database.Database.Instance.PlayerDamageInformation(currentBoss);
if (BasicTeraData.Instance.WindowData.MeterUserOnTop)
{
playersInfo = playersInfo.OrderBy(x => MeterPlayers.Contains(x.Source) ? 0 : 1).ThenByDescending(x => x.Amount).ToList();
}
var heals = Database.Database.Instance.PlayerHealInformation(entityInfo.BeginTime, entityInfo.EndTime);
var flash = FlashMessage;
FlashMessage = null;
var statsSummary = new StatsSummary(playersInfo, heals, entityInfo);
var teradpsHistory = BossLink;
var chatbox = Chat.Instance.Get();
var abnormals = AbnormalityStorage.Clone(currentBoss, entityInfo.BeginTime, entityInfo.EndTime);
handler?.Invoke(statsSummary, skills, filteredEntities, timedEncounter, abnormals, teradpsHistory, chatbox, packetsWaiting, flash);
}
/// <summary>
/// Construct server with given port.
/// </summary>
/// <param name="path">Directory path to serve.</param>
/// <param name="port">Port of the server.</param>
public SimpleHTTPServer(string path, int port)
{
packetsServer = new PacketProcessing();
this.Initialize(path, port);
}
public void PacketProcessingTest()
{
PacketProcessing packetProcessing = new PacketProcessing("TD3");
TestTools.RunLocalTest("A8", packetProcessing.Process, "TD3");
}
