public void Run()
{
var registerer = new MessageRegisterer();
registerer.AddMessageTypes(typeof(IPerformSingleTaskOnComputersMessage), typeof(IInstallAssemblyMessage));
var implementations = new MessageInterfaceImplementations(new DefaultMessageInterfaceImplementationFactory(), registerer);
var factory = new MessageFactory(implementations, new MessageDefinitionFactory());
var assembly = factory.Create<IInstallAssemblyMessage>(m =>
{
m.ArtifactId = Guid.Empty;
m.AssemblyFilename = "Jacob.exe";
});
var message = factory.Create<IPerformSingleTaskOnComputersMessage>(m =>
{
m.OperationId = Guid.NewGuid();
m.Title = "Nothing";
m.Message = assembly;
m.ComputerNames = new string[0];
m.Birthday = DateTime.UtcNow;
});
var formatter = new XmlTransportMessageBodyFormatter(registerer, new MtaMessageMapper(implementations, factory, registerer));
formatter.Initialize();
using (var stream = new MemoryStream())
{
formatter.Serialize(new IMessage[] { message }, stream);
Console.WriteLine(Encoding.ASCII.GetString(stream.ToArray()));
using (var reading = new MemoryStream(stream.ToArray()))
{
var read = formatter.Deserialize(reading);
}
}
}
public void SendOneWay(object requestDto)
{
Publish(MessageFactory.Create(requestDto));
}
private void PacketAnalysisLoop()
{
try { Database.Database.Instance.DeleteAll(); }
catch (Exception ex)
{
BasicTeraData.LogError(ex.Message + "\r\n" + ex.StackTrace + "\r\n" + ex.Source + "\r\n" + ex + "\r\n" + ex.Data + "\r\n" + ex.InnerException + "\r\n" + ex.TargetSite, true);
MessageBox.Show(LP.MainWindow_Fatal_error);
Exit();
}
while (true)
{
if (NeedToCopy != null)
{
var currentBoss = Encounter;
var timedEncounter = TimedEncounter;
var entityInfo = Database.Database.Instance.GlobalInformationEntity(currentBoss, timedEncounter);
var skills = Database.Database.Instance.GetSkills(entityInfo.BeginTime, entityInfo.EndTime);
var playersInfo = timedEncounter
? Database.Database.Instance.PlayerDamageInformation(entityInfo.BeginTime, entityInfo.EndTime)
: Database.Database.Instance.PlayerDamageInformation(currentBoss);
var heals = Database.Database.Instance.PlayerHealInformation(entityInfo.BeginTime,
entityInfo.EndTime);
var statsSummary = new StatsSummary(playersInfo, heals, entityInfo);
var tmpcopy = NeedToCopy;
var abnormals = _abnormalityStorage.Clone(currentBoss, entityInfo.BeginTime, entityInfo.EndTime);
var pasteThread =
new Thread(() => CopyThread(statsSummary, skills, abnormals, timedEncounter, tmpcopy))
{
Priority = ThreadPriority.Highest
};
pasteThread.SetApartmentState(ApartmentState.STA);
pasteThread.Start();
NeedToCopy = null;
}
if (NeedToReset)
{
Reset();
NeedToReset = false;
}
if (NeedToResetCurrent)
{
ResetCurrent();
NeedToResetCurrent = false;
}
if (NeedToExport)
{
DataExporter.Export(Encounter, _abnormalityStorage);
NeedToExport = false;
}
Encounter = NewEncounter;
var packetsWaiting = TeraSniffer.Instance.Packets.Count;
if (packetsWaiting > 3000)
{
MessageBox.Show(
LP.Your_computer_is_too_slow);
Exit();
}
if (_forceUiUpdate)
{
UpdateUi(packetsWaiting);
_forceUiUpdate = false;
}
CheckUpdateUi(packetsWaiting);
Message obj;
var successDequeue = TeraSniffer.Instance.Packets.TryDequeue(out obj);
if (!successDequeue)
{
Thread.Sleep(1);
continue;
}
var message = _messageFactory.Create(obj);
var cVersion = message as C_CHECK_VERSION;
if (cVersion != null)
{
Console.WriteLine("VERSION0 = " + cVersion.Versions[0]);
Console.WriteLine("VERSION1 = " + cVersion.Versions[1]);
var opCodeNamer =
new OpCodeNamer(Path.Combine(BasicTeraData.Instance.ResourceDirectory,
$"data/opcodes/{cVersion.Versions[0]}.txt"));
_messageFactory = new MessageFactory(opCodeNamer, Server.Region);
continue;
}
var sLogin = message as LoginServerMessage;
if (sLogin != null)
{
if (_needInit)
{
Connected(BasicTeraData.Instance.Servers.GetServerName(sLogin.ServerId, Server));
bool trackerreset = true;
if (EntityTracker != null)
{
try
{
var oldregion = BasicTeraData.Instance.Servers.GetServer(EntityTracker.MeterUser.ServerId).Region;
trackerreset = Server.Region != oldregion;
}
catch (Exception e)
{
BasicTeraData.LogError("New server:" + Server + ";Old server Id:" + EntityTracker.MeterUser.ServerId, false, true);
throw;
}
}
Server = BasicTeraData.Instance.Servers.GetServer(sLogin.ServerId, Server);
_messageFactory.Version = Server.Region;
if (trackerreset)
{
TeraData = BasicTeraData.Instance.DataForRegion(Server.Region);
BasicTeraData.Instance.HotDotDatabase.Get(8888888).Name = LP.Enrage;
BasicTeraData.Instance.HotDotDatabase.Get(8888889).Name = LP.Slaying;
BasicTeraData.Instance.HotDotDatabase.Get(8888889).Tooltip = LP.SlayingTooltip;
EntityTracker = new EntityTracker(BasicTeraData.Instance.MonsterDatabase);
PlayerTracker = new PlayerTracker(EntityTracker, BasicTeraData.Instance.Servers);
Database.Database.Instance.DeleteAll();
}
_needInit = false;
}
_abnormalityStorage.EndAll(message.Time.Ticks);
_abnormalityTracker = new AbnormalityTracker(EntityTracker, PlayerTracker,
BasicTeraData.Instance.HotDotDatabase, _abnormalityStorage, DamageTracker.Instance.Update);
_charmTracker = new CharmTracker(_abnormalityTracker);
OnGuildIconAction(UserLogoTracker.GetLogo(sLogin.PlayerId));
}
if (_needInit)
{
//Wait for initialization
continue;
}
EntityTracker.Update(message);
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage != null)
{
var skillResult = new SkillResult(skillResultMessage, EntityTracker, PlayerTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.PetSkillDatabase);
DamageTracker.Instance.Update(skillResult);
continue;
}
var changeHp = message as SCreatureChangeHp;
if (changeHp != null)
{
_abnormalityTracker.Update(changeHp);
continue;
}
var pchangeHp = message as SPartyMemberChangeHp;
if (pchangeHp != null)
{
var user = PlayerTracker.GetOrNull(pchangeHp.ServerId, pchangeHp.PlayerId);
if (user == null)
{
continue;
}
_abnormalityTracker.RegisterSlaying(user.User, pchangeHp.Slaying, pchangeHp.Time.Ticks);
continue;
}
var pmstatupd = message as S_PARTY_MEMBER_STAT_UPDATE;
if (pmstatupd != null)
{
var user = PlayerTracker.GetOrNull(pmstatupd.ServerId, pmstatupd.PlayerId);
if (user == null)
{
continue;
}
_abnormalityTracker.RegisterSlaying(user.User, pmstatupd.Slaying, pmstatupd.Time.Ticks);
continue;
}
var pstatupd = message as S_PLAYER_STAT_UPDATE;
if (pstatupd != null)
{
_abnormalityTracker.RegisterSlaying(EntityTracker.MeterUser, pstatupd.Slaying, pstatupd.Time.Ticks);
continue;
}
var changeMp = message as SPlayerChangeMp;
if (changeMp != null)
{
if (changeMp.SourceId != EntityTracker.MeterUser.Id &&
changeMp.TargetId != EntityTracker.MeterUser.Id &&
EntityTracker.GetOrPlaceholder(changeHp.TargetId).RootOwner != EntityTracker.MeterUser)
{
var source = EntityTracker.GetOrPlaceholder(changeMp.SourceId);
BasicTeraData.LogError("SPlayerChangeMp need rootowner update2:" + (source as NpcEntity)?.Info.Name ?? source.GetType() + ": " + source, false, true);
}
_abnormalityTracker.Update(changeMp);
continue;
}
var npcStatus = message as SNpcStatus;
if (npcStatus != null)
{
_abnormalityTracker.RegisterNpcStatus(npcStatus);
continue;
}
var dead = message as SCreatureLife;
if (dead != null)
{
_abnormalityTracker.RegisterDead(dead);
continue;
}
var abnormalityBegin = message as SAbnormalityBegin;
if (abnormalityBegin != null)
{
_abnormalityTracker.AddAbnormality(abnormalityBegin);
continue;
}
var abnormalityEnd = message as SAbnormalityEnd;
if (abnormalityEnd != null)
{
_abnormalityTracker.DeleteAbnormality(abnormalityEnd);
continue;
}
var abnormalityRefresh = message as SAbnormalityRefresh;
if (abnormalityRefresh != null)
{
_abnormalityTracker.RefreshAbnormality(abnormalityRefresh);
continue;
}
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
DamageTracker.Instance.UpdateEntities(new NpcOccupierResult(npcOccupier), npcOccupier.Time.Ticks);
continue;
}
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
_abnormalityTracker.StopAggro(despawnNpc);
_abnormalityTracker.DeleteAbnormality(despawnNpc);
DataExporter.Export(despawnNpc, _abnormalityStorage);
continue;
}
var despawnUser = message as SDespawnUser;
if (despawnUser != null)
{
_charmTracker.CharmReset(despawnUser.User, new List <CharmStatus>(), despawnUser.Time.Ticks);
_abnormalityTracker.DeleteAbnormality(despawnUser);
continue;
}
var charmEnable = message as SEnableCharmStatus;
if (charmEnable != null)
{
_charmTracker.CharmEnable(EntityTracker.MeterUser.Id, charmEnable.CharmId, charmEnable.Time.Ticks);
continue;
}
var pcharmEnable = message as SPartyMemberCharmEnable;
if (pcharmEnable != null)
{
var player = PlayerTracker.GetOrNull(pcharmEnable.ServerId, pcharmEnable.PlayerId);
if (player == null)
{
continue;
}
_charmTracker.CharmEnable(player.User.Id, pcharmEnable.CharmId, pcharmEnable.Time.Ticks);
continue;
}
var charmReset = message as SResetCharmStatus;
if (charmReset != null)
{
_charmTracker.CharmReset(charmReset.TargetId, charmReset.Charms, charmReset.Time.Ticks);
continue;
}
var pcharmReset = message as SPartyMemberCharmReset;
if (pcharmReset != null)
{
var player = PlayerTracker.GetOrNull(pcharmReset.ServerId, pcharmReset.PlayerId);
if (player == null)
{
continue;
}
_charmTracker.CharmReset(player.User.Id, pcharmReset.Charms, pcharmReset.Time.Ticks);
continue;
}
var charmDel = message as SRemoveCharmStatus;
if (charmDel != null)
{
_charmTracker.CharmDel(EntityTracker.MeterUser.Id, charmDel.CharmId, charmDel.Time.Ticks);
continue;
}
var pcharmDel = message as SPartyMemberCharmDel;
if (pcharmDel != null)
{
var player = PlayerTracker.GetOrNull(pcharmDel.ServerId, pcharmDel.PlayerId);
if (player == null)
{
continue;
}
_charmTracker.CharmDel(player.User.Id, pcharmDel.CharmId, pcharmDel.Time.Ticks);
continue;
}
var charmAdd = message as SAddCharmStatus;
if (charmAdd != null)
{
_charmTracker.CharmAdd(charmAdd.TargetId, charmAdd.CharmId, charmAdd.Status, charmAdd.Time.Ticks);
continue;
}
var pcharmAdd = message as SPartyMemberCharmAdd;
if (pcharmAdd != null)
{
var player = PlayerTracker.GetOrNull(pcharmAdd.ServerId, pcharmAdd.PlayerId);
if (player == null)
{
continue;
}
_charmTracker.CharmAdd(player.User.Id, pcharmAdd.CharmId, pcharmAdd.Status, pcharmAdd.Time.Ticks);
continue;
}
PlayerTracker.UpdateParty(message);
var sSpawnUser = message as SpawnUserServerMessage;
if (sSpawnUser != null)
{
_abnormalityTracker.RegisterDead(sSpawnUser.Id, sSpawnUser.Time.Ticks, sSpawnUser.Dead);
//Debug.WriteLine(sSpawnUser.Name + " : " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.Id.Id)) + " : " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.ServerId)) + " " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.PlayerId)));
continue;
}
if (BasicTeraData.Instance.WindowData.EnableChat)
{
var chatMessage = message as S_CHAT;
if (chatMessage != null)
{
Chat.Instance.Add(chatMessage);
continue;
}
var whisperMessage = message as S_WHISPER;
if (whisperMessage != null)
{
Chat.Instance.Add(whisperMessage);
continue;
}
var privateChatMessage = message as S_PRIVATE_CHAT;
if (privateChatMessage != null)
{
Chat.Instance.Add(privateChatMessage);
continue;
}
var trading = message as S_TRADE_BROKER_DEAL_SUGGESTED;
if (trading != null)
{
if (!TeraWindow.IsTeraActive())
{
FlashMessage = new Tuple <string, string>(
LP.Trading + ": " + trading.PlayerName,
LP.SellerPrice + ": " + S_TRADE_BROKER_DEAL_SUGGESTED.Gold(trading.SellerPrice) +
Environment.NewLine +
LP.OfferedPrice + ": " + S_TRADE_BROKER_DEAL_SUGGESTED.Gold(trading.OfferedPrice)
);
}
continue;
}
var userApply = message as S_OTHER_USER_APPLY_PARTY;
if (userApply != null)
{
if (!TeraWindow.IsTeraActive())
{
FlashMessage = new Tuple <string, string>(
userApply.PlayerName + " " + LP.ApplyToYourParty,
LP.Class + ": " +
LP.ResourceManager.GetString(userApply.PlayerClass.ToString(), LP.Culture) +
Environment.NewLine +
LP.Lvl + ": " + userApply.Lvl + Environment.NewLine
);
}
for (var i = 0; i < 3; i++)
{
try
{
Clipboard.SetDataObject("/inspect " + userApply.PlayerName);
break;
}
catch
{
Thread.Sleep(100);
//Ignore
}
}
continue;
}
var contact = message as S_REQUEST_CONTRACT;
if (contact != null)
{
if (!TeraWindow.IsTeraActive())
{
if (contact.Type == S_REQUEST_CONTRACT.RequestType.PartyInvite)
{
FlashMessage = new Tuple <string, string>(
LP.PartyInvite + ": " + contact.Sender,
contact.Sender
);
}
else if (contact.Type == S_REQUEST_CONTRACT.RequestType.TradeRequest)
{
FlashMessage = new Tuple <string, string>(
LP.Trading + ": " + contact.Sender,
contact.Sender
);
}
else
{
FlashMessage = new Tuple <string, string>(
LP.ContactTry,
LP.ContactTry
);
}
}
continue;
}
var partyMatch = message as S_FIN_INTER_PARTY_MATCH;
var bgMatch = message as S_BATTLE_FIELD_ENTRANCE_INFO;
if (partyMatch != null || bgMatch != null)
{
if (!TeraWindow.IsTeraActive())
{
FlashMessage = new Tuple <string, string>(
LP.PartyMatchingSuccess,
LP.PartyMatchingSuccess
);
}
continue;
}
}
var spawnMe = message as SpawnMeServerMessage;
if (spawnMe != null)
{
_abnormalityStorage.EndAll(message.Time.Ticks);
_abnormalityTracker = new AbnormalityTracker(EntityTracker, PlayerTracker,
BasicTeraData.Instance.HotDotDatabase, _abnormalityStorage, DamageTracker.Instance.Update);
_charmTracker = new CharmTracker(_abnormalityTracker);
_abnormalityTracker.RegisterDead(spawnMe.Id, spawnMe.Time.Ticks, spawnMe.Dead);
continue;
}
var guildIcon = message as S_GET_USER_GUILD_LOGO;
if (guildIcon != null)
{
UserLogoTracker.AddLogo(guildIcon);
continue;
}
var user_list = message as S_GET_USER_LIST;
if (user_list != null)
{
UserLogoTracker.SetUserList(user_list);
continue;
}
//Debug.WriteLine(sLogin.Name + " : " + BitConverter.ToString(BitConverter.GetBytes(sLogin.Id.Id)));
}
}
private ChatUsersMessage CreateChatUserMessage()
{
ChatUsersMessage msg = MessageFactory.Create(MessageType.ChatUsers) as ChatUsersMessage;
return(msg);
}
private void PacketAnalysisLoop()
{
try { Database.Database.Instance.DeleteAll(); }
catch (Exception ex)
{
BasicTeraData.LogError(
ex.Message + "\r\n" + ex.StackTrace + "\r\n" + ex.Source + "\r\n" + ex + "\r\n" + ex.Data + "\r\n" + ex.InnerException + "\r\n" + ex.TargetSite,
true);
MessageBox.Show(LP.MainWindow_Fatal_error);
Exit();
}
while (_keepAlive)
{
if (NeedToCopy != null)
{
var currentBoss = Encounter;
var timedEncounter = TimedEncounter;
var entityInfo = Database.Database.Instance.GlobalInformationEntity(currentBoss, timedEncounter, BasicTeraData.Instance.WindowData.DisplayTimerBasedOnAggro);
var skills = Database.Database.Instance.GetSkills(entityInfo.BeginTime, entityInfo.EndTime);
var playersInfo = timedEncounter
? Database.Database.Instance.PlayerDamageInformation(entityInfo.BeginTime, entityInfo.EndTime)
: Database.Database.Instance.PlayerDamageInformation(currentBoss);
var heals = Database.Database.Instance.PlayerHealInformation(entityInfo.BeginTime, entityInfo.EndTime);
var statsSummary = new StatsSummary(playersInfo, heals, entityInfo);
var tmpcopy = NeedToCopy;
var abnormals = AbnormalityStorage.Clone(currentBoss, entityInfo.BeginTime, entityInfo.EndTime);
var pasteThread = new Thread(() => CopyThread(statsSummary, skills, abnormals, timedEncounter, tmpcopy))
{
Priority = ThreadPriority.Highest
};
pasteThread.SetApartmentState(ApartmentState.STA);
pasteThread.Start();
NeedToCopy = null;
}
if (NeedToReset)
{
Reset();
NeedToReset = false;
}
if (NeedToResetCurrent)
{
ResetCurrent();
NeedToResetCurrent = false;
}
if (!NeedToExport.HasFlag(DataExporter.Dest.None))
{
DataExporter.ManualExport(Encounter, AbnormalityStorage, NeedToExport);
NeedToExport = DataExporter.Dest.None;
}
Encounter = NewEncounter;
var packetsWaiting = TeraSniffer.Instance.Packets.Count;
if (packetsWaiting > 5000)
{
PacketProcessing.Pause();
Database.Database.Instance.DeleteAll();
AbnormalityStorage = new AbnormalityStorage();
AbnormalityTracker = new AbnormalityTracker(EntityTracker, PlayerTracker, BasicTeraData.Instance.HotDotDatabase, AbnormalityStorage, DamageTracker.Instance.Update);
HudManager.Instance.CurrentBosses.DisposeAll();
TeraSniffer.Instance.Packets = new ConcurrentQueue <Message>();
NotifyProcessor.Instance.S_LOAD_TOPO(null);
RaisePause(true);
}
if (_forceUiUpdate)
{
UpdateUi(packetsWaiting);
_forceUiUpdate = false;
}
CheckUpdateUi(packetsWaiting);
var successDequeue = TeraSniffer.Instance.Packets.TryDequeue(out Message obj);
if (!successDequeue)
{
Thread.Sleep(1);
continue;
}
var message = MessageFactory.Create(obj);
if (message.GetType() == typeof(UnknownMessage))
{
continue;
}
if (!PacketProcessing.Process(message))
{
//Unprocessed packet
}
}
}
public override Message ProcessIncoming(MessageHeader header, BufferStream stream, ref byte[] raw, ref byte[] plaintext)
{
var messageDirection = Message.GetMessageDirection(header.Id);
// Message instance that we will return to the caller.
var message = MessageFactory.Create(header.Id);
var chiper = new byte[header.Length];
stream.Read(chiper, 0, header.Length);
// Unencrypted byte array.
plaintext = null;
lock (_lock)
{
// Handshaking.
if (_state <= 1)
{
// Handshakes are sent unencrypted.
// First message by both ends is always sent unencrypted.
plaintext = (byte[])chiper.Clone();
// Use the first message direction to configure the processor.
if (_state == 0)
{
_clientCrypto = new Crypto8(GetOppositeDirection(messageDirection), _keyPair);
}
if (_state == 1)
{
_serverCrypto = new Crypto8(GetOppositeDirection(messageDirection), Crypto8.GenerateKeyPair());
}
}
if (_state == 4)
{
_clientCrypto.UpdateNonce((byte[])_serverNonce.Clone(), UpdateNonceType.Encrypt);
_clientCrypto.UpdateNonce((byte[])_clientNonce.Clone(), UpdateNonceType.Decrypt);
_clientCrypto.UpdateSharedKey(_serverCrypto.SharedKey);
}
// _state == 1 means we are the server.
// Usually processing 10101 - LoginRequestMessage.
if (_state == 2)
{
_serverCrypto.UpdateSharedKey(Crypto8.SupercellPublicKey);
// -> Pre-Encryption.
// Copies the public key appended to the beginning of the message.
var publicKey = new byte[KeyPair.KeyLength];
Buffer.BlockCopy(chiper, 0, publicKey, 0, KeyPair.KeyLength);
Debug.WriteLine($"Public-Key from {header.Id}: {ToHexString(publicKey)}");
// Copies the remaining bytes into the plaintext buffer
var plaintextLen = header.Length - KeyPair.KeyLength;
plaintext = new byte[plaintextLen];
Buffer.BlockCopy(chiper, KeyPair.KeyLength, plaintext, 0, plaintextLen);
// Crypto8 will take publicKey & _keyPair.PublicKey and generate a blake2b nonce
_clientCrypto.UpdateSharedKey(publicKey);
// Then use _keyPair.PrivateKey, publicKey and nonce to decrypt.
_clientCrypto.Decrypt(ref plaintext);
// -> Post-Encryption.
_sessionKey = new byte[KeyPair.NonceLength];
_clientNonce = new byte[KeyPair.NonceLength];
// Copy the SessionKey and the ClientNonce.
Buffer.BlockCopy(plaintext, 0, _sessionKey, 0, KeyPair.NonceLength);
Buffer.BlockCopy(plaintext, KeyPair.NonceLength, _clientNonce, 0, KeyPair.NonceLength);
Debug.WriteLine($"Session-key from {header.Id}: {ToHexString(_sessionKey)}");
Debug.WriteLine($"Client-nonce from {header.Id}: {ToHexString(_clientNonce)}");
var actualMessage = new byte[plaintext.Length - (KeyPair.NonceLength * 2)];
Buffer.BlockCopy(plaintext, KeyPair.NonceLength * 2, actualMessage, 0, actualMessage.Length);
plaintext = actualMessage;
}
else if (_state == 3)
{
_clientCrypto.UpdateNonce(_clientNonce, UpdateNonceType.Blake);
_serverCrypto.UpdateNonce(_clientNonce, UpdateNonceType.Blake);
_serverCrypto.Decrypt(ref chiper);
// Post-Encryption
// Copies the public key appended to the beginning of the message.
_serverNonce = new byte[KeyPair.NonceLength];
Buffer.BlockCopy(chiper, 0, _serverNonce, 0, KeyPair.NonceLength);
var publicKey = new byte[KeyPair.KeyLength];
Buffer.BlockCopy(chiper, KeyPair.NonceLength, publicKey, 0, KeyPair.KeyLength);
_serverCrypto.UpdateNonce((byte[])_serverNonce.Clone(), UpdateNonceType.Decrypt);
_serverCrypto.UpdateNonce((byte[])_clientNonce.Clone(), UpdateNonceType.Encrypt);
_serverCrypto.UpdateSharedKey(publicKey);
Debug.WriteLine($"Server-Nonce from {header.Id}: {ToHexString(_serverNonce)}");
Debug.WriteLine($"New Public-Key from {header.Id}: {ToHexString(publicKey)}");
// Copies the remaining bytes into the plaintext buffer.
var plaintextLen = chiper.Length - KeyPair.KeyLength - KeyPair.NonceLength;
plaintext = new byte[plaintextLen];
Buffer.BlockCopy(chiper, KeyPair.KeyLength + KeyPair.NonceLength, plaintext, 0, plaintextLen);
}
else if (_state > 3)
{
if (messageDirection == MessageDirection.Client)
{
_serverCrypto.Decrypt(ref chiper);
}
if (messageDirection == MessageDirection.Server)
{
_clientCrypto.Decrypt(ref chiper);
}
plaintext = chiper;
}
_state++;
}
try
{
using (var reader = new MessageReader(new MemoryStream(plaintext)))
message.ReadMessage(reader);
}
catch (Exception ex)
{
Console.WriteLine("Ex: " + ex);
}
return(message);
}
public async Task GetStatus()
{
var getStatusMessage = MessageFactory.Create <GetStatus>(this);
await this.SubscribedClient.SendMessage(getStatusMessage);
}
public HeartbeatProtocol() : base("urn:x-cast:com.google.cast.tp.heartbeat", CastConstants.DestinationId)
{
this.HeartbeatIntervalMilliseconds = 5000;
pingMessage = MessageFactory.Create <Ping>(this);
}
public BasicRequest(object requestDto,
RequestAttributes requestAttributes = RequestAttributes.LocalSubnet | RequestAttributes.MessageQueue)
: this(MessageFactory.Create(requestDto), requestAttributes)
{
}
private void PacketAnalysisLoop()
{
while (true)
{
if (NeedToCopy != null)
{
var stats = DamageTracker.Instance.GetPlayerStats();
var currentBoss = Encounter;
var timedEncounter = TimedEncounter;
var totaldamage = DamageTracker.Instance.TotalDamage(currentBoss, timedEncounter);
var firstHit = DamageTracker.Instance.FirstHit(currentBoss);
var lastHit = DamageTracker.Instance.LastHit(currentBoss);
var info = currentBoss == null ? new EntityInfo {
FirstHit = firstHit * TimeSpan.TicksPerSecond, LastHit = (lastHit + 1) * TimeSpan.TicksPerSecond - 1
} : DamageTracker.Instance.GetEntityStats()[currentBoss];
var tmpcopy = NeedToCopy;
var abnormals = _abnormalityStorage.Clone(currentBoss?.NpcE, info.FirstHit, info.LastHit);
var pasteThread = new Thread(() => CopyThread(info, stats, abnormals, totaldamage, currentBoss, timedEncounter, tmpcopy));
pasteThread.Priority = ThreadPriority.Highest;
pasteThread.Start();
NeedToCopy = null;
}
if (NeedToReset)
{
Reset();
NeedToReset = false;
}
if (NeedToResetCurrent)
{
ResetCurrent();
NeedToResetCurrent = false;
}
Encounter = NewEncounter;
if (_forceUiUpdate)
{
UpdateUi();
_forceUiUpdate = false;
}
CheckUpdateUi();
Message obj;
var successDequeue = TeraSniffer.Instance.Packets.TryDequeue(out obj);
if (!successDequeue)
{
Thread.Sleep(1);
continue;
}
if (TeraSniffer.Instance.Packets.Count > 3000)
{
MessageBox.Show(
"Your computer is too slow to use this DPS meter. Can't analyse all those packet in decent amount of time. Shutting down now.");
Exit();
}
var message = _messageFactory.Create(obj);
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage != null)
{
var skillResult = new SkillResult(skillResultMessage, EntityTracker, PlayerTracker, BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.PetSkillDatabase);
DamageTracker.Instance.Update(skillResult);
continue;
}
var changeHp = message as SCreatureChangeHp;
if (changeHp != null)
{
AbnormalityTracker.Update(changeHp);
continue;
}
var pchangeHp = message as SPartyMemberChangeHp;
if (pchangeHp != null)
{
var user = PlayerTracker.GetOrNull(pchangeHp.ServerId, pchangeHp.PlayerId);
if (user == null)
{
continue;
}
AbnormalityTracker.RegisterSlaying(user.User, pchangeHp.Slaying, pchangeHp.Time.Ticks);
continue;
}
var pmstatupd = message as S_PARTY_MEMBER_STAT_UPDATE;
if (pmstatupd != null)
{
var user = PlayerTracker.GetOrNull(pmstatupd.ServerId, pmstatupd.PlayerId);
if (user == null)
{
continue;
}
AbnormalityTracker.RegisterSlaying(user.User, pmstatupd.Slaying, pmstatupd.Time.Ticks);
continue;
}
var pstatupd = message as S_PLAYER_STAT_UPDATE;
if (pstatupd != null)
{
AbnormalityTracker.RegisterSlaying(EntityTracker.MeterUser, pstatupd.Slaying, pstatupd.Time.Ticks);
continue;
}
var changeMp = message as SPlayerChangeMp;
if (changeMp != null)
{
AbnormalityTracker.Update(changeMp);
continue;
}
var npcStatus = message as SNpcStatus;
if (npcStatus != null)
{
AbnormalityTracker.RegisterNpcStatus(npcStatus);
continue;
}
var dead = message as SCreatureLife;
if (dead != null)
{
AbnormalityTracker.RegisterDead(dead);
continue;
}
var abnormalityBegin = message as SAbnormalityBegin;
if (abnormalityBegin != null)
{
AbnormalityTracker.AddAbnormality(abnormalityBegin);
continue;
}
var abnormalityEnd = message as SAbnormalityEnd;
if (abnormalityEnd != null)
{
AbnormalityTracker.DeleteAbnormality(abnormalityEnd);
continue;
}
var abnormalityRefresh = message as SAbnormalityRefresh;
if (abnormalityRefresh != null)
{
AbnormalityTracker.RefreshAbnormality(abnormalityRefresh);
continue;
}
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
DamageTracker.Instance.UpdateEntities(new NpcOccupierResult(npcOccupier), npcOccupier.Time.Ticks);
continue;
}
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
AbnormalityTracker.StopAggro(despawnNpc);
AbnormalityTracker.DeleteAbnormality(despawnNpc);
DataExporter.Export(despawnNpc, _abnormalityStorage);
continue;
}
var chatMessage = message as S_CHAT;
if (chatMessage != null)
{
Chat.Instance.Add(chatMessage);
continue;
}
var whisperMessage = message as S_WHISPER;
if (whisperMessage != null)
{
Chat.Instance.Add(whisperMessage);
continue;
}
var despawnUser = message as SDespawnUser;
if (despawnUser != null)
{
CharmTracker.CharmReset(despawnUser.User, new List <CharmStatus>(), despawnUser.Time.Ticks);
AbnormalityTracker.DeleteAbnormality(despawnUser);
continue;
}
var charmEnable = message as SEnableCharmStatus;
if (charmEnable != null)
{
CharmTracker.CharmEnable(EntityTracker.MeterUser.Id, charmEnable.CharmId, charmEnable.Time.Ticks);
continue;
}
var pcharmEnable = message as SPartyMemberCharmEnable;
if (pcharmEnable != null)
{
var player = PlayerTracker.GetOrNull(pcharmEnable.ServerId, pcharmEnable.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.CharmEnable(player.User.Id, pcharmEnable.CharmId, pcharmEnable.Time.Ticks);
continue;
}
var charmReset = message as SResetCharmStatus;
if (charmReset != null)
{
CharmTracker.CharmReset(charmReset.TargetId, charmReset.Charms, charmReset.Time.Ticks);
continue;
}
var pcharmReset = message as SPartyMemberCharmReset;
if (pcharmReset != null)
{
var player = PlayerTracker.GetOrNull(pcharmReset.ServerId, pcharmReset.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.CharmReset(player.User.Id, pcharmReset.Charms, pcharmReset.Time.Ticks);
continue;
}
var charmDel = message as SRemoveCharmStatus;
if (charmDel != null)
{
CharmTracker.CharmDel(EntityTracker.MeterUser.Id, charmDel.CharmId, charmDel.Time.Ticks);
continue;
}
var pcharmDel = message as SPartyMemberCharmDel;
if (pcharmDel != null)
{
var player = PlayerTracker.GetOrNull(pcharmDel.ServerId, pcharmDel.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.CharmDel(player.User.Id, pcharmDel.CharmId, pcharmDel.Time.Ticks);
continue;
}
var charmAdd = message as SAddCharmStatus;
if (charmAdd != null)
{
CharmTracker.CharmAdd(charmAdd.TargetId, charmAdd.CharmId, charmAdd.Status, charmAdd.Time.Ticks);
continue;
}
var pcharmAdd = message as SPartyMemberCharmAdd;
if (pcharmAdd != null)
{
var player = PlayerTracker.GetOrNull(pcharmAdd.ServerId, pcharmAdd.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.CharmAdd(player.User.Id, pcharmAdd.CharmId, pcharmAdd.Status, pcharmAdd.Time.Ticks);
continue;
}
EntityTracker.Update(message);
PlayerTracker.UpdateParty(message);
//var sSpawnUser = message as SpawnUserServerMessage;
//if (sSpawnUser != null)
//{
// Console.WriteLine(sSpawnUser.Name + " : " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.Id.Id))+" : " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.ServerId)) + " " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.PlayerId)));
// continue;
//}
var spawnMe = message as SpawnMeServerMessage;
if (spawnMe != null)
{
_abnormalityStorage.EndAll(message.Time.Ticks);
AbnormalityTracker = new AbnormalityTracker(EntityTracker, PlayerTracker, BasicTeraData.Instance.HotDotDatabase, _abnormalityStorage, DamageTracker.Instance.Update);
CharmTracker = new CharmTracker(AbnormalityTracker);
continue;
}
var sLogin = message as LoginServerMessage;
if (sLogin != null)
{
_abnormalityStorage.EndAll(message.Time.Ticks);
AbnormalityTracker = new AbnormalityTracker(EntityTracker, PlayerTracker, BasicTeraData.Instance.HotDotDatabase, _abnormalityStorage, DamageTracker.Instance.Update);
CharmTracker = new CharmTracker(AbnormalityTracker);
Connected(BasicTeraData.Instance.Servers.GetServerName(sLogin.ServerId, Server));
//Console.WriteLine(sLogin.Name + " : " + BitConverter.ToString(BitConverter.GetBytes(sLogin.Id.Id)));
continue;
}
}
}
protected void FireMessage(V4Message message)
{
var eventArgs = new MessageEventArgs(MessageFactory.Create(message));
InvokeEventHandlers(_onMessage, eventArgs);
}
public Validator(LanguageCodes code)
{
Errors = new List <ValidationError>();
MessageContainer = MessageFactory.Create(code);
}
/// <summary>
/// Validate properties and types using this class
/// </summary>
public Validator()
{
Errors = new List <ValidationError>();
MessageContainer = MessageFactory.Create();
}
private void PacketAnalysisLoop()
{
while (true)
{
if (ForceUpdate)
{
ForceUpdate = false;
UpdateUi();
}
CheckUpdateUi();
Message obj;
var successDequeue = TeraSniffer.Instance.Packets.TryDequeue(out obj);
if (!successDequeue)
{
Thread.Sleep(10);
continue;
}
if (TeraSniffer.Instance.Packets.Count > 3000)
{
MessageBox.Show(
"Your computer is too slow to use this DPS meter. Can't analyse all those packet in decent amount of time. Shutting down now.");
Exit();
}
var message = _messageFactory.Create(obj);
EntityTracker.Update(message);
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
DamageTracker.Instance.UpdateEntities(new NpcOccupierResult(npcOccupier), npcOccupier.Time.Ticks);
continue;
}
var changeHp = message as SCreatureChangeHp;
if (changeHp != null)
{
AbnormalityTracker.Instance.Update(changeHp);
continue;
}
var changeMp = message as SPlayerChangeMp;
if (changeMp != null)
{
AbnormalityTracker.Instance.Update(changeMp);
continue;
}
var abnormalityBegin = message as SAbnormalityBegin;
if (abnormalityBegin != null)
{
AbnormalityTracker.Instance.AddAbnormality(abnormalityBegin);
continue;
}
var abnormalityEnd = message as SAbnormalityEnd;
if (abnormalityEnd != null)
{
AbnormalityTracker.Instance.DeleteAbnormality(abnormalityEnd);
continue;
}
var abnormalityRefresh = message as SAbnormalityRefresh;
if (abnormalityRefresh != null)
{
AbnormalityTracker.Instance.RefreshAbnormality(abnormalityRefresh);
continue;
}
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
AbnormalityTracker.Instance.DeleteAbnormality(despawnNpc);
continue;
}
var despawnUser = message as SDespawnUser;
if (despawnUser != null)
{
AbnormalityTracker.Instance.DeleteAbnormality(despawnUser);
continue;
}
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage == null)
{
continue;
}
var amount = skillResultMessage.Amount;
if (!skillResultMessage.IsHeal && skillResultMessage.IsHp && amount > 0)
{
amount *= -1;
}
var skillResult = ForgeSkillResult(
false,
amount,
skillResultMessage.IsCritical,
skillResultMessage.IsHp,
skillResultMessage.SkillId,
skillResultMessage.Source,
skillResultMessage.Target);
DamageTracker.Instance.Update(skillResult, skillResultMessage.Time.Ticks);
}
}
public void SendOneWay(string queueName, object requestDto)
{
Publish(queueName, MessageFactory.Create(requestDto));
}
private void HandleMessageReceived(Message obj)
{
var message = _messageFactory.Create(obj);
if (DamageTracker.IsArchived)
{
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
Entity ent = _entityTracker.GetOrPlaceholder(npcOccupier.NPC);
if (ent is NpcEntity)
{
var npce = ent as NpcEntity;
if (npce.Info.Boss && npcOccupier.Target != EntityId.Empty)
{
CasualMessenger.Instance.ResetPlayerStats(true); //Stop viewing saved encounter on boss aggro
}
}
return;
}
}
_entityTracker?.Update(message);
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage != null)
{
if (skillResultMessage.IsValid(DamageTracker))
{
var skillResult = new SkillResult(skillResultMessage, _entityTracker, _playerTracker, _teraData.SkillDatabase, null, _abnormalityTracker);
CheckUpdate(skillResult);
}
return;
}
_playerTracker?.UpdateParty(message);
_abnormalityTracker?.Update(message);
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
Entity ent = _entityTracker.GetOrPlaceholder(despawnNpc.Npc);
if (ent is NpcEntity)
{
var npce = ent as NpcEntity;
if (npce.Info.Boss && despawnNpc.Dead && !DamageTracker.IsArchived)
{ //no need to do something if we didn't count any skill against this boss
if (DamageTracker.StatsByUser.SelectMany(x => x.SkillLog).Any(x => x.Target == npce))
{
DamageTracker.PrimaryTarget = npce; //Name encounter with the last dead boss
DamageTracker.IsPrimaryTargetDead = despawnNpc.Dead;
//determine type
ExportType exportType = ExportType.None;
if (SettingsHelper.Instance.Settings.ExcelExport)
{
exportType = exportType | ExportType.Excel;
}
if (SettingsHelper.Instance.Settings.SiteExport)
{
exportType = exportType | ExportType.Upload;
}
if (exportType != ExportType.None)
{
DataExporter.ToTeraDpsApi(exportType, DamageTracker, _teraData);
}
if (AutosaveEncounters)
{
ResetDamageTracker(new ResetPlayerStatsMessage {
ShouldSaveCurrent = true
});
}
}
}
}
return;
}
var sLogin = message as LoginServerMessage;
if (sLogin != null)
{
if (_needInit)
{
Server = BasicTeraData.Servers.GetServer(sLogin.ServerId, Server);
_messageFactory.Version = Server.Region;
Logger.Info($"Logged in to server {Server.Name}.");
_teraData = BasicTeraData.DataForRegion(Server.Region);
_entityTracker = new EntityTracker(_teraData.NpcDatabase);
_playerTracker = new PlayerTracker(_entityTracker, BasicTeraData.Servers);
_abnormalityTracker = new AbnormalityTracker(_entityTracker, _playerTracker, _teraData.HotDotDatabase, _abnormalityStorage, CheckUpdate);
_entityTracker.Update(message);
_needInit = false;
}
_abnormalityStorage.EndAll(message.Time.Ticks);
_abnormalityTracker = new AbnormalityTracker(_entityTracker, _playerTracker, _teraData.HotDotDatabase, _abnormalityStorage, CheckUpdate);
return;
}
var cVersion = message as C_CHECK_VERSION;
if (cVersion != null)
{
var opCodeNamer =
new OpCodeNamer(Path.Combine(BasicTeraData.ResourceDirectory,
$"opcodes/{cVersion.Versions[0]}.txt"));
_messageFactory = new MessageFactory(opCodeNamer, Server.Region);
return;
}
}
private void PacketAnalysisLoop()
{
while (true)
{
if (NeedToReset)
{
Reset();
NeedToReset = false;
}
if (NeedToResetCurrent)
{
ResetCurrent();
NeedToResetCurrent = false;
}
if (NeedToCopy != null)
{
var stats = DamageTracker.Instance.GetPlayerStats();
var currentBoss = Encounter;
var timedEncounter = TimedEncounter;
var totaldamage = DamageTracker.Instance.TotalDamage(currentBoss, timedEncounter);
var firstHit = DamageTracker.Instance.FirstHit(currentBoss);
var lastHit = DamageTracker.Instance.LastHit(currentBoss);
var partyDps = DamageTracker.Instance.PartyDps(currentBoss, timedEncounter);
var tmpcopy = NeedToCopy;
var pasteThread = new Thread(() => CopyThread(stats, totaldamage, partyDps, firstHit, lastHit, currentBoss, timedEncounter, tmpcopy));
pasteThread.Priority = ThreadPriority.Highest;
pasteThread.Start();
NeedToCopy = null;
}
Encounter = NewEncounter;
if (_forceUiUpdate)
{
UpdateUi();
_forceUiUpdate = false;
}
CheckUpdateUi();
Message obj;
var successDequeue = TeraSniffer.Instance.Packets.TryDequeue(out obj);
if (!successDequeue)
{
Thread.Sleep(10);
continue;
}
if (TeraSniffer.Instance.Packets.Count > 3000)
{
MessageBox.Show(
"Your computer is too slow to use this DPS meter. Can't analyse all those packet in decent amount of time. Shutting down now.");
Exit();
}
var message = _messageFactory.Create(obj);
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage != null)
{
var amount = skillResultMessage.Amount;
if (!skillResultMessage.IsHeal && skillResultMessage.IsHp && amount > 0)
{
amount *= -1;
}
var skillResult = ForgeSkillResult(
false,
amount,
skillResultMessage.IsCritical,
skillResultMessage.IsHp,
skillResultMessage.SkillId,
skillResultMessage.Source,
skillResultMessage.Target);
DamageTracker.Instance.Update(skillResult, skillResultMessage.Time.Ticks);
continue;
}
var changeHp = message as SCreatureChangeHp;
if (changeHp != null)
{
AbnormalityTracker.Instance.Update(changeHp);
var user = EntityTracker.GetOrPlaceholder(changeHp.TargetId);
if (user is UserEntity)
{
if (changeHp.Slaying)
{
AbnormalityTracker.Instance.AddAbnormality(changeHp.TargetId, changeHp.TargetId, 0, 0, 8888889, changeHp.Time.Ticks);
}
else
{
AbnormalityTracker.Instance.DeleteAbnormality(changeHp);
}
}
continue;
}
var pchangeHp = message as SPartyMemberChangeHp;
if (pchangeHp != null)
{
var user = PlayerTracker.GetOrNull(pchangeHp.PlayerId);
if (user == null)
{
continue; //have not seen user yet, cause he is far away, but in party.
}
if (pchangeHp.Slaying)
{
AbnormalityTracker.Instance.AddAbnormality(user.User.Id, user.User.Id, 0, 0, 8888889, pchangeHp.Time.Ticks);
}
else
{
AbnormalityTracker.Instance.DeleteAbnormality(user.User.Id, 8888889, message.Time.Ticks);
}
continue;
}
var changeMp = message as SPlayerChangeMp;
if (changeMp != null)
{
AbnormalityTracker.Instance.Update(changeMp);
continue;
}
var NpcStatus = message as SNpcStatus;
if (NpcStatus != null)
{
if (NpcStatus.Enraged)
{
AbnormalityTracker.Instance.AddAbnormality(NpcStatus.Npc, NpcStatus.Target, 0, 0, 8888888, NpcStatus.Time.Ticks);
continue;
}
else
{
AbnormalityTracker.Instance.DeleteAbnormality(NpcStatus);
continue;
}
}
var abnormalityBegin = message as SAbnormalityBegin;
if (abnormalityBegin != null)
{
AbnormalityTracker.Instance.AddAbnormality(abnormalityBegin);
continue;
}
var abnormalityEnd = message as SAbnormalityEnd;
if (abnormalityEnd != null)
{
AbnormalityTracker.Instance.DeleteAbnormality(abnormalityEnd);
continue;
}
var abnormalityRefresh = message as SAbnormalityRefresh;
if (abnormalityRefresh != null)
{
AbnormalityTracker.Instance.RefreshAbnormality(abnormalityRefresh);
continue;
}
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
DamageTracker.Instance.UpdateEntities(new NpcOccupierResult(npcOccupier), npcOccupier.Time.Ticks);
continue;
}
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
AbnormalityTracker.Instance.DeleteAbnormality(despawnNpc);
DataExporter.ToTeraDpsApi(despawnNpc);
continue;
}
var chatMessage = message as S_CHAT;
if (chatMessage != null)
{
Chat.Instance.Add(chatMessage);
continue;
}
var whisperMessage = message as S_WHISPER;
if (whisperMessage != null)
{
Chat.Instance.Add(whisperMessage);
continue;
}
var despawnUser = message as SDespawnUser;
if (despawnUser != null)
{
AbnormalityTracker.Instance.DeleteAbnormality(despawnUser);
CharmTracker.Instance.CharmReset(despawnUser.User, new List <CharmStatus>(), despawnUser.Time.Ticks);
continue;
}
var dead = message as SCreatureLife;
if (dead != null)
{
DamageTracker.Instance.RegisterDead(dead);
continue;
}
var charmEnable = message as SEnableCharmStatus;
if (charmEnable != null)
{
CharmTracker.Instance.CharmEnable(EntityTracker.MeterUser.Id, charmEnable.CharmId, charmEnable.Time.Ticks);
continue;
}
var pcharmEnable = message as SPartyMemberCharmEnable;
if (pcharmEnable != null)
{
var player = PlayerTracker.GetOrNull(pcharmEnable.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.Instance.CharmEnable(player.User.Id, pcharmEnable.CharmId, pcharmEnable.Time.Ticks);
continue;
}
var charmReset = message as SResetCharmStatus;
if (charmReset != null)
{
CharmTracker.Instance.CharmReset(charmReset.TargetId, charmReset.Charms, charmReset.Time.Ticks);
continue;
}
var pcharmReset = message as SPartyMemberCharmReset;
if (pcharmReset != null)
{
var player = PlayerTracker.GetOrNull(pcharmReset.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.Instance.CharmReset(player.User.Id, pcharmReset.Charms, pcharmReset.Time.Ticks);
continue;
}
var charmDel = message as SRemoveCharmStatus;
if (charmDel != null)
{
CharmTracker.Instance.CharmDel(EntityTracker.MeterUser.Id, charmDel.CharmId, charmDel.Time.Ticks);
continue;
}
var pcharmDel = message as SPartyMemberCharmDel;
if (pcharmDel != null)
{
var player = PlayerTracker.GetOrNull(pcharmDel.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.Instance.CharmDel(player.User.Id, pcharmDel.CharmId, pcharmDel.Time.Ticks);
continue;
}
var charmAdd = message as SAddCharmStatus;
if (charmAdd != null)
{
CharmTracker.Instance.CharmAdd(charmAdd.TargetId, charmAdd.CharmId, charmAdd.Status, charmAdd.Time.Ticks);
continue;
}
var pcharmAdd = message as SPartyMemberCharmAdd;
if (pcharmAdd != null)
{
var player = PlayerTracker.GetOrNull(pcharmAdd.PlayerId);
if (player == null)
{
continue;
}
CharmTracker.Instance.CharmAdd(player.User.Id, pcharmAdd.CharmId, pcharmAdd.Status, pcharmAdd.Time.Ticks);
continue;
}
EntityTracker.Update(message);
//var sSpawnUser = message as SpawnUserServerMessage;
//if (sSpawnUser != null)
//{
// Console.WriteLine(sSpawnUser.Name + " : " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.Id.Id))+" : " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.ServerId)) + " " + BitConverter.ToString(BitConverter.GetBytes(sSpawnUser.PlayerId)));
// continue;
//}
var sLogin = message as LoginServerMessage;
if (sLogin != null)
{
AbnormalityTracker.Instance.Renew();
Connected(BasicTeraData.Instance.Servers.GetServerName(sLogin.ServerId, Server));
//Console.WriteLine(sLogin.Name + " : " + BitConverter.ToString(BitConverter.GetBytes(sLogin.Id.Id)));
continue;
}
}
}
