/// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog selectedLog = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int selectedIndex = selectedPacket.PacketIndex;
            Packet originalPak = selectedLog[selectedIndex];
            ushort objectId = 0;
            if (originalPak is IObjectIdPacket && (originalPak as IObjectIdPacket).ObjectIds.Length > 0)
                objectId = (originalPak as IObjectIdPacket).ObjectIds[0];
            if (objectId == 0)
                return false;
            // Create log
            PacketLog			log = new PacketLog();
            ICollection<Packet>	packets = SelectPacketContext(context, selectedPacket, objectId);
            log.AddRange(packets);
            log.Version					= selectedLog.Version;
            log.StreamName				= "(context OID:0x" + objectId.ToString("X4") + ") " + selectedLog.StreamName;
            log.IgnoreVersionChanges	= false;

            // Show form in another thread
            Thread t = new Thread(ShowNewForm);
            lock (m_startedThreads)
            {
                m_startedThreads.Add(t);
                t.SetApartmentState(ApartmentState.STA);
                t.Name = "context OID:0x" + objectId.ToString("X4");
                t.Start(log);
            }

            return false;
        }
        /// <summary>
        /// Adds the log.
        /// </summary>
        /// <param name="packetLog">The packet log.</param>
        public void AddLog(PacketLog packetLog)
        {
            // Update logs list
            List<PacketLog> logs = new List<PacketLog>(m_logs);
            logs.Add(packetLog);
            m_logs = logs.AsReadOnly();

            // Fire event
            FirePacketLogsChangedEvent();

            // Add packets change event handler
            packetLog.OnPacketsChanged += packetLog_OnPacketsChanged;
        }
 /// <summary>
 /// Set all log variables from the packet here
 /// </summary>
 /// <param name="log"></param>
 public override void InitLog(PacketLog log)
 {
     // Reinit only on for 190 version and subversion lower 190.1
     if (!log.IgnoreVersionChanges && log.Version >= 199 && log.Version < 199.1f)
     {
         if (Length == 1904)
         {
             log.Version = 199.1f;
             log.SubversionReinit = true;
     //					log.IgnoreVersionChanges = true;
         }
     }
 }
Example #4
0
        public void Send(ref PacketWriter packet)
        {
            if (packet.Opcode == 0)
            {
                return;
            }

            var buffer = packet.ReadDataToSend();

            try
            {
                if (Crypt.IsInitialized)
                {
                    uint totalLength = (uint)packet.Size - 2;
                    totalLength <<= 13;
                    totalLength  |= ((uint)packet.Opcode & 0x1FFF);

                    var header = BitConverter.GetBytes(totalLength);

                    Crypt.Encrypt(header);

                    buffer[0] = header[0];
                    buffer[1] = header[1];
                    buffer[2] = header[2];
                    buffer[3] = header[3];
                }

                clientSocket.Send(buffer, 0, buffer.Length, SocketFlags.None);

                string clientInfo = ((IPEndPoint)clientSocket.RemoteEndPoint).Address + ":" + ((IPEndPoint)clientSocket.RemoteEndPoint).Port;
                PacketLog.WritePacket(clientInfo, packet);

                packet.Flush();
            }
            catch (Exception ex)
            {
                Log.Message(LogType.Error, "{0}", ex.Message);
                Log.Message();

                clientSocket.Close();
            }
        }
Example #5
0
        public void SendPacket(ServerPacket packet)
        {
            if (!IsOpen())
            {
                return;
            }

            packet.LogPacket(_worldSession);
            packet.WritePacketData();

            var           data   = packet.GetData();
            ServerOpcodes opcode = packet.GetOpcode();

            PacketLog.Write(data, (uint)opcode, GetRemoteIpAddress(), GetRemotePort(), _connectType, false);

            uint packetSize = (uint)data.Length;

            if (packetSize > 0x400 && worldCrypt.IsInitialized)
            {
                ByteBuffer buffer = new ByteBuffer();
                buffer.WriteUInt32(packetSize + 2);
                buffer.WriteUInt32(ZLib.adler32(ZLib.adler32(0x9827D8F1, BitConverter.GetBytes((ushort)opcode), 2), data, packetSize));

                uint compressedSize = CompressPacket(data, opcode);
                buffer.WriteUInt32(ZLib.adler32(0x9827D8F1, data, compressedSize));
                buffer.WriteBytes(data, compressedSize);

                packetSize = (ushort)(compressedSize + 12);
                opcode     = ServerOpcodes.CompressedPacket;

                data = buffer.GetData();
            }

            ServerPacketHeader header = new ServerPacketHeader(packetSize, opcode);

            if (worldCrypt.IsInitialized)
            {
                worldCrypt.Encrypt(header.data, 4);
            }

            AsyncWrite(header.data.Combine(data));
        }
Example #6
0
        public override async Task Send(Framework.Network.Packets.ServerPacket packet)
        {
            try
            {
                packet.Write();
                packet.Packet.Finish();

                if (packet.Packet.Header != null)
                {
                    if (packet.Packet.Header.Size > 0x100)
                    {
                        packet = await Compress(packet);
                    }

                    PacketLog.Write <ServerMessage>(packet.Packet.Header.Message, packet.Packet.Data, client.RemoteEndPoint);
                }

                if (Crypt != null && Crypt.IsInitialized)
                {
                    Encrypt(packet.Packet);
                }

                var socketEventargs = new SocketAsyncEventArgs();

                socketEventargs.SetBuffer(packet.Packet.Data, 0, packet.Packet.Data.Length);

                socketEventargs.Completed     += SendCompleted;
                socketEventargs.UserToken      = packet;
                socketEventargs.RemoteEndPoint = client.RemoteEndPoint;
                socketEventargs.SocketFlags    = SocketFlags.None;

                client.SendAsync(socketEventargs);
            }
            catch (Exception ex)
            {
                Dispose();

                ExceptionLog.Write(ex);

                Log.Error(ex.ToString());
            }
        }
Example #7
0
        /// <summary>
        /// Selects the packet context.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="packet">The packet.</param>
        /// <returns>List with packet context.</returns>
        private static ICollection <Packet> SelectPacketContext(IExecutionContext context, PacketLocation packet)
        {
            List <Packet> packets;
            PacketLog     log = context.LogManager.GetPacketLog(packet.LogIndex);

            if (log != null && log.Count > 0)
            {
                // Calculate first/last indices
                int firstPacketIndex = Math.Max(0, packet.PacketIndex - PACKET_CONTEXT_SIZE);
                int lastPacketIndex  = Math.Min(log.Count, packet.PacketIndex + PACKET_CONTEXT_SIZE);

                // Select range
                packets = log.GetRange(firstPacketIndex, lastPacketIndex);
            }
            else
            {
                packets = new List <Packet>(0);
            }

            return(packets);
        }
Example #8
0
        private void OnPacketReceived(object sender, PacketReceivedEventArgs e)
        {
            if (e.Exception == null)
            {
                PacketLog.LogData(e.Packet, PacketDirection.Client);
                var defaultHandler = (PacketHandler)null;
                var handler        = (PacketHandler)null;

                if (DefaultPacketHandlers.TryGetValue(e.Packet.ID, out defaultHandler))
                {
                    defaultHandler(this, e.Packet); // use default handler
                }
                if (PacketHandlers.TryGetValue(e.Packet.ID, out handler))
                {
                    handler(this, e.Packet); // use custom handler
                }
            }
            else
            {
                Console.WriteLine("Failed to read packet: {0}", e.Exception.Message);
            }
        }
Example #9
0
        public CoCClient()
        {
            Fingerprint = new Fingerprint(); // not used

            Home                  = new Village();
            Avatar                = new Avatar();
            Connection            = new Socket(SocketType.Stream, ProtocolType.Tcp);
            DefaultPacketHandlers = new Dictionary <ushort, PacketHandler>();
            PacketHandlers        = new Dictionary <ushort, PacketHandler>();
            KeepAliveManager      = new KeepAliveManager(this);
            PacketLog             = new PacketLog("packets.log")
            {
                AutoSave   = true,
                LogConsole = false
            };
            PluginManager = new PluginManager(this);

            LoginPacketHandlers.RegisterLoginPacketHandlers(this);
            InGamePacketHandlers.RegisterInGamePacketHandler(this);
            PluginManager.LoadPlugins();
            PluginManager.EnablePlugins();
        }
Example #10
0
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog     log     = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            Hashtable     plrInfo = MakeCombatList(selectedPacket.PacketIndex, log);
            StringBuilder str     = new StringBuilder();

            foreach (DictionaryEntry entry in plrInfo)
            {
                PlayerInfo plr = (PlayerInfo)entry.Value;
                if (plr != null)
                {
//					str.AppendFormat("key = {0}\n", entry.Key);
                    int playerAttacks  = plr.hit + plr.miss + plr.fumble + plr.failAttacks;
                    int playerAttacked = plr.block + plr.evade + plr.parry + plr.attacked;
                    if ((playerAttacks + playerAttacked) > 0)
                    {
                        str.AppendFormat("Level:{0} Name:{1} Class:{2} WS:{3} WeaponDamage:{4}\n", plr.level, plr.name, plr.className, plr.weaponSkill, plr.weaponDamage);
                        str.AppendFormat("player->target\tHits:{0} ({8:0.00}%)\t Miss:{1} ({9:0.00}%)\t Fumble:{2} ({10:0.00}%)\t FailAttacks:{3} ({11:0.00}%)\ntarget->player\tParry:{4} ({12:0.00}%)\t Block:{5} ({13:0.00}%)\t Evade:{6} ({14:0.00}%)\t attacked:{7} ({15:0.00}%)\n\n",
                                         plr.hit, plr.miss, plr.fumble, plr.failAttacks, plr.parry, plr.block, plr.evade, plr.attacked,
                                         (plr.hit + plr.miss) > 0 ? 100.0 * plr.hit / (plr.hit + plr.miss) : 0,
                                         (plr.hit + plr.miss) > 0 ? 100.0 * plr.miss / (plr.hit + plr.miss): 0,
                                         playerAttacks > 0 ? 100.0 * plr.fumble / playerAttacks : 0,
                                         playerAttacks > 0 ? 100.0 * plr.failAttacks / playerAttacks : 0,
                                         (playerAttacked - plr.evade) > 0 ? 100.0 * plr.parry / (playerAttacked - plr.evade) : 0,
                                         (playerAttacked - plr.parry - plr.evade) > 0 ? 100.0 * plr.block / (playerAttacked - plr.parry - plr.evade): 0,
                                         playerAttacked > 0 ? 100.0 * plr.evade / playerAttacked: 0,
                                         playerAttacked > 0 ? 100.0 * plr.attacked / playerAttacked: 0);
                    }
                }
            }
            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text  = "Show weapon use statistics (right click to close)";
            infoWindow.Width = 550;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();

            return(false);
        }
Example #11
0
        public override void ReadHandler(int transferredBytes)
        {
            if (!IsOpen())
            {
                return;
            }

            while (transferredBytes > 5)
            {
                if (worldCrypt.IsInitialized)
                {
                    worldCrypt.Decrypt(GetReceiveBuffer(), 4);
                }

                int  size;
                uint opcode;
                if (!ReadHeader(out opcode, out size))
                {
                    CloseSocket();
                    return;
                }

                var data = new byte[size];
                Buffer.BlockCopy(GetReceiveBuffer(), 6, data, 0, size);

                PacketLog.Write(data, opcode, GetRemoteIpAddress(), GetRemotePort(), _connectType, true);
                if (!ProcessPacket(new WorldPacket(data, opcode)))
                {
                    CloseSocket();
                    return;
                }

                transferredBytes -= size + 6;
                Buffer.BlockCopy(GetReceiveBuffer(), size + 6, GetReceiveBuffer(), 0, transferredBytes);
            }

            AsyncRead();
        }
Example #12
0
        /// <summary>
        /// Set all log variables from the packet here
        /// </summary>
        /// <param name="log"></param>
        public override void InitLog(PacketLog log)
        {
            if (log.SubversionReinit)
            {
                return;
            }
            if (log.Version >= 1126)
            {
                return;
            }

            Position = 2;
            int major   = ReadByte();
            int minor   = ReadByte();
            int build   = ReadByte();
            int version = major * 100 + minor * 10 + build;

            if (version >= 200)
            {
                version = version + 900;
            }
            log.Version = (float)version;
        }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog selectedLog   = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int       selectedIndex = selectedPacket.PacketIndex;
            Packet    originalPak   = selectedLog[selectedIndex];
            ushort    objectId      = 0;

            if (originalPak is IObjectIdPacket && (originalPak as IObjectIdPacket).ObjectIds.Length > 0)
            {
                objectId = (originalPak as IObjectIdPacket).ObjectIds[0];
            }
            if (objectId == 0)
            {
                return(false);
            }
            // Create log
            PacketLog            log     = new PacketLog();
            ICollection <Packet> packets = SelectPacketContext(context, selectedPacket, objectId);

            log.AddRange(packets);
            log.Version              = selectedLog.Version;
            log.StreamName           = "(context OID:0x" + objectId.ToString("X4") + ") " + selectedLog.StreamName;
            log.IgnoreVersionChanges = false;

            // Show form in another thread
            Thread t = new Thread(ShowNewForm);

            lock (m_startedThreads)
            {
                m_startedThreads.Add(t);
                t.SetApartmentState(ApartmentState.STA);
                t.Name = "context OID:0x" + objectId.ToString("X4");
                t.Start(log);
            }

            return(false);
        }
Example #14
0
        public void Send(AuthPacket packet)
        {
            try
            {
                packet.Finish();

                if (packet.Header != null)
                {
                    PacketLog.Write <AuthServerMessage>(packet.Header.Message, packet.Data, client.RemoteEndPoint);
                }

                if (Crypt != null && Crypt.IsInitialized)
                {
                    Crypt.Encrypt(packet.Data, packet.Data.Length);
                }

                var socketEventargs = new SocketAsyncEventArgs();

                socketEventargs.SetBuffer(packet.Data, 0, packet.Data.Length);

                socketEventargs.Completed     += SendCompleted;
                socketEventargs.UserToken      = packet;
                socketEventargs.RemoteEndPoint = client.RemoteEndPoint;
                socketEventargs.SocketFlags    = SocketFlags.None;

                client.Send(packet.Data);
            }
            catch (Exception ex)
            {
                Dispose();

                ExceptionLog.Write(ex);

                Log.Error(ex.Message);
            }
        }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            // Create log
            PacketLog			log = new PacketLog();
            ICollection<Packet>	packets = SelectPacketContext(context, selectedPacket);
            savedPacket = context.LogManager.GetPacket(selectedPacket);
            log.AddRange(packets);
            PacketLog selectedLog = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            log.StreamName				= "(packet context) " + selectedLog.StreamName;
            log.IgnoreVersionChanges	= false;
            log.Version					= selectedLog.Version;

            // Show form in another thread
            Thread t = new Thread(ShowNewForm);
            lock (m_startedThreads)
            {
                m_startedThreads.Add(t);
                t.SetApartmentState(ApartmentState.STA);
                t.Name = "Packet context";
                t.Start(log);
            }

            return false;
        }
        private string MakeOidInfo(PacketLog log, int selectedIndex, ushort objectId, ushort sessionId, ushort keepId)
        {
            StringBuilder str = new StringBuilder();
            int maxPacketsLookBackForGetCoords = 100000; // look back in log max 30 packets for find coords after found obejct creation packet
            bool fullInfoFound = false;
            bool flagPacketMove = false;
            bool flagPacketCreationRequest = false;
            bool flagPacketItem = false;
            bool flagPacketRide = false;
            bool flagPacketEquip = false;
            bool flagPacketGuild = false;
            bool flagPacketPet = false;
            bool flagPacketDialog = false;
            bool flagVisualEffect = false;
            bool flagPacketMobCreate = false;
            bool flagPacketCombatAnimation = false;
            bool flagAllowGetFirstSelfCoords = true;
            ushort selfId = 0;
            Hashtable ObjectsOnMount = null;
            BitArray m_packetsBitArrayStoC = new BitArray(255);
            m_packetsBitArrayStoC.SetAll(false);
            BitArray m_packetsBitArrayCtoS = new BitArray(255);
            m_packetsBitArrayCtoS.SetAll(false);
            CtoS_0xA9_PlayerPosition lastSelfCoords = null;
            LocalCoords lastObjectCoords = null;
            LocalCoords regionGlobalCoords = null;
            LocalCoords firstSelfCoords = null;
            //			Packet lastObjectCoords = null;
            string objectType = "";
            for (int i = selectedIndex; i >= 0; i--)
            {
                Packet pak = log[i];
                if (fullInfoFound)
                    maxPacketsLookBackForGetCoords--;
                if (pak is StoC_0x20_PlayerPositionAndObjectID) // stop scanning packets on enter region
                {
                    if ((pak as StoC_0x20_PlayerPositionAndObjectID).PlayerOid == objectId)
                        objectType = " (Self)";
            //					str.Insert(0, pak.ToHumanReadableString(TimeSpan(0), true) + '\n');
                    if (regionGlobalCoords == null) // skip if gloc Jump
                        regionGlobalCoords = new LocalCoords((pak as StoC_0x20_PlayerPositionAndObjectID).X, (pak as StoC_0x20_PlayerPositionAndObjectID).Y, (pak as StoC_0x20_PlayerPositionAndObjectID).Z);
                    flagAllowGetFirstSelfCoords = false;
                    break;
                }
                else if (pak is StoC_0x04_CharacterJump)
                {
            #warning TODO: Rewrite for find self Oid
                    if ((pak as StoC_0x04_CharacterJump).PlayerOid == selfId)
                    {
                        regionGlobalCoords = new LocalCoords((pak as StoC_0x04_CharacterJump).X, (pak as StoC_0x04_CharacterJump).Y, (pak as StoC_0x04_CharacterJump).Z);
                        flagAllowGetFirstSelfCoords = false;
                        if (lastSelfCoords != null)
                        {
                            if (firstSelfCoords == null)
                            {
                                firstSelfCoords = new LocalCoords(lastSelfCoords.CurrentZoneX, lastSelfCoords.CurrentZoneY, lastSelfCoords.CurrentZoneZ, 0xFFFF);
                            }
                            else
                            {
                                firstSelfCoords.CurrentZoneX = lastSelfCoords.CurrentZoneX;
                                firstSelfCoords.CurrentZoneY = lastSelfCoords.CurrentZoneY;
                                firstSelfCoords.CurrentZoneZ = lastSelfCoords.CurrentZoneZ;
                            }
                        }
            //						break;
                    }
                }
                else if (pak is StoC_0xD4_PlayerCreate)
                {
                    if (!fullInfoFound && (pak as StoC_0xD4_PlayerCreate).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (player)";
                        fullInfoFound = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD4_PlayerCreate).ZoneX, (pak as StoC_0xD4_PlayerCreate).ZoneY, (pak as StoC_0xD4_PlayerCreate).ZoneZ, (ushort)(pak as StoC_0xD4_PlayerCreate).ZoneId);
                    }
                }
                else if (pak is StoC_0x4B_PlayerCreate_172)
                {
                    if (!fullInfoFound && (pak as StoC_0x4B_PlayerCreate_172).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (player)";
                        fullInfoFound = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0x4B_PlayerCreate_172).ZoneX, (pak as StoC_0x4B_PlayerCreate_172).ZoneY, (pak as StoC_0x4B_PlayerCreate_172).ZoneZ, (pak as StoC_0x4B_PlayerCreate_172).ZoneId);
                    }
                }
                else if (pak is StoC_0xDA_NpcCreate)
                {
                    if (!fullInfoFound && !flagPacketMobCreate && (pak as StoC_0xDA_NpcCreate).Oid == objectId)
                    {
                        flagPacketMobCreate = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (NPC)";
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xDA_NpcCreate).X, (pak as StoC_0xDA_NpcCreate).Y, (pak as StoC_0xDA_NpcCreate).Z);
            //						fullInfoFound = true; // need find 0x20 for get gloc region
                    }
                }
                else if (pak is StoC_0xD9_ItemDoorCreate)
                {
                    if (!fullInfoFound && !flagPacketItem && (pak as StoC_0xD9_ItemDoorCreate).Oid == objectId)
                    {
                        flagPacketItem = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if ((pak as StoC_0xD9_ItemDoorCreate).ExtraBytes == 4)
                            objectType = " (Door)";
                        else
                            objectType = " (Object)";
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD9_ItemDoorCreate).X, (pak as StoC_0xD9_ItemDoorCreate).Y, (pak as StoC_0xD9_ItemDoorCreate).Z);
            //						fullInfoFound = true; // need find 0x20 for get gloc region
                    }
                }
                else if (pak is StoC_0x12_CreateMovingObject)
                {
                    if (!fullInfoFound && (pak as StoC_0x12_CreateMovingObject).ObjectOid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (MovingObject)";
                        fullInfoFound = true;
                    }
                }
                else if (pak is StoC_0xC8_PlayerRide) // show object if rided
                {
                    if (!fullInfoFound && !flagPacketRide && (pak as StoC_0xC8_PlayerRide).RiderOid == objectId)
                    {
                        flagPacketRide = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                    else if ((pak as StoC_0xC8_PlayerRide).MountOid == objectId)
                    {
                        if (ObjectsOnMount == null)
                            ObjectsOnMount = new Hashtable();
                        if (!ObjectsOnMount.ContainsKey((pak as StoC_0xC8_PlayerRide).Slot))
                        {
                            ObjectsOnMount.Add((pak as StoC_0xC8_PlayerRide).Slot, (ushort)(pak as StoC_0xC8_PlayerRide).RiderOid);
                            str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        }
                    }
                }
                else if (pak is StoC_0x15_EquipmentUpdate)
                {
                    if (!fullInfoFound && !flagPacketEquip && (pak as StoC_0x15_EquipmentUpdate).Oid == objectId)
                    {
                        flagPacketEquip = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xEE_NpcChangeProperties)
                {
                    if (!fullInfoFound && (pak as StoC_0xEE_NpcChangeProperties).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xDE_SetObjectGuildId)
                {
                    if (!fullInfoFound && !flagPacketGuild && (pak as StoC_0xDE_SetObjectGuildId).Oid == objectId)
                    {
                        flagPacketGuild = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xA1_NpcUpdate)
                {
                    if (!fullInfoFound && !flagPacketMove && (pak as StoC_0xA1_NpcUpdate).NpcOid == objectId)
                    {
                        flagPacketMove = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xA1_NpcUpdate).CurrentZoneX, (pak as StoC_0xA1_NpcUpdate).CurrentZoneY, (pak as StoC_0xA1_NpcUpdate).CurrentZoneZ, (pak as StoC_0xA1_NpcUpdate).CurrentZoneId);
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x81_ShowDialog)
                {
                    if (!fullInfoFound && !flagPacketDialog && (pak as StoC_0x81_ShowDialog).ObjectIds != null && (pak as StoC_0x81_ShowDialog).ObjectIds.Length > 0 && (pak as StoC_0x81_ShowDialog).ObjectIds[0] == objectId)
                    {
                        flagPacketDialog = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xA9_PlayerPosition)
                {
                    if (!flagPacketMove && (pak as StoC_0xA9_PlayerPosition).SessionId == sessionId)
                    {
                        if (!fullInfoFound)
                        {
                            flagPacketMove = true;
                            if (lastObjectCoords == null)
                                lastObjectCoords = new LocalCoords((pak as StoC_0xA9_PlayerPosition).CurrentZoneX, (pak as StoC_0xA9_PlayerPosition).CurrentZoneY, (pak as StoC_0xA9_PlayerPosition).CurrentZoneZ, (pak as StoC_0xA9_PlayerPosition).CurrentZoneId);
                        }
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x88_PetWindowUpdate)
                {
                    if (!fullInfoFound && !flagPacketPet && (pak as StoC_0x88_PetWindowUpdate).PetId == objectId)
                    {
                        flagPacketPet = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x4C_VisualEffect)
                {
                    if (!fullInfoFound && !flagVisualEffect && (pak as StoC_0x4C_VisualEffect).Oid == objectId)
                    {
                        flagVisualEffect = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    if (flagAllowGetFirstSelfCoords)
                    {
                        if (firstSelfCoords == null)
                        {
                            firstSelfCoords = new LocalCoords((pak as CtoS_0xA9_PlayerPosition).CurrentZoneX, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ, 0xFFFF);
                        }
                        else
                        {
                            firstSelfCoords.CurrentZoneX = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneX;
                            firstSelfCoords.CurrentZoneY = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY;
                            firstSelfCoords.CurrentZoneZ = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ;
                        }
                    }

                    if (lastSelfCoords == null)
                    {
                        lastSelfCoords = pak as CtoS_0xA9_PlayerPosition;
                    }
                }
                else if (pak is CtoS_0xBE_NpcCreationRequest)
                {
                    if (!flagPacketCreationRequest && (pak as CtoS_0xBE_NpcCreationRequest).NpcOid == objectId)
                    {
                        flagPacketCreationRequest = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x69_KeepOverview)
                {
                    if ((pak as StoC_0x69_KeepOverview).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0x69_KeepOverview).KeepX, (pak as StoC_0x69_KeepOverview).KeepY);
                    }
                }
                else if (pak is StoC_0x61_KeepRepair)
                {
                    if (!fullInfoFound && (pak as StoC_0x61_KeepRepair).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x62_KeepClaim)
                {
                    if (!fullInfoFound && (pak as StoC_0x62_KeepClaim).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x67_KeepUpdate)
                {
                    if (!fullInfoFound && (pak as StoC_0x67_KeepUpdate).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x6C_KeepComponentOverview)
                {
                    if (!fullInfoFound && (pak as StoC_0x6C_KeepComponentOverview).KeepId == keepId)
            //					if (!fullInfoFound && (pak as StoC_0x6C_KeepComponentOverview).Uid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (KeepComponent)";
            //						fullInfoFound = true;
                    }
                }
                else if (pak is StoC_0xBC_CombatAnimation)
                {
                    if (!fullInfoFound && !flagPacketCombatAnimation && ((pak as StoC_0xBC_CombatAnimation).AttackerOid == objectId || (pak as StoC_0xBC_CombatAnimation).DefenderOid == objectId))
                    {
                        flagPacketCombatAnimation = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else
                {
                    if (pak is IObjectIdPacket)  // all other packet's with OID
                    {
                        if (!(fullInfoFound || flagPacketMobCreate || flagPacketItem)) // not show packet's before creation object packet
                        {
                            if ((pak.Direction == ePacketDirection.ServerToClient && !m_packetsBitArrayStoC[pak.Code]) ||
                                (pak.Direction == ePacketDirection.ClientToServer && !m_packetsBitArrayCtoS[pak.Code]))
                            {
                                ushort[] objectIds = (pak as IObjectIdPacket).ObjectIds;
                                if (objectIds != null && objectIds.Length > 0)
                                {
                                    for (int j = 0; j < objectIds.Length; j++)
                                    {
                                        if (objectIds[j] > 0 && objectIds[j] == objectId)
                                        {
                                            str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                                            if (pak.Direction == ePacketDirection.ServerToClient)
                                                m_packetsBitArrayStoC[pak.Code] = true;
                                            else if (pak.Direction == ePacketDirection.ClientToServer)
                                                m_packetsBitArrayCtoS[pak.Code] = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                // if we found object creation packets and both coords (self and object) then break;
                // if we found object creation packets but not find any coords break after maxPacketsLookBackForGetCoords look back
                if (fullInfoFound && ((lastObjectCoords != null && lastSelfCoords != null) || maxPacketsLookBackForGetCoords <= 0))
                    break;
            }
            //			if (!fullInfoFound)
            //				str.Insert(0, "No more info found\n");
            // TODO add zone checks... (mb recalc in global coords if zones is different ?)
            {
                if (regionGlobalCoords != null)
                    str.Insert(0, string.Format("regionGlobalCoords (x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY));
                if (firstSelfCoords != null)
                    str.Insert(0, string.Format("firstSelfCoords (x:{0} y:{1})\n", firstSelfCoords.CurrentZoneX, firstSelfCoords.CurrentZoneY));
                if (lastSelfCoords != null)
                    str.Insert(0, string.Format("lastSelfCoords (x:{0} y:{1})\n", lastSelfCoords.CurrentZoneX, lastSelfCoords.CurrentZoneY));
                if (lastObjectCoords != null)
                    str.Insert(0, string.Format("lastObjectCoords (x:{0} y:{1})\n", lastObjectCoords.CurrentZoneX, lastObjectCoords.CurrentZoneY));
            }
            if (lastSelfCoords != null && lastObjectCoords != null && lastSelfCoords.CurrentZoneId == lastObjectCoords.CurrentZoneId)
            {
                long xdiff = (long)lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc/loc)\n", range));
            }
            else if (lastSelfCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF && regionGlobalCoords != null && firstSelfCoords != null) /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = 0;
                if (lastObjectCoords.CurrentZoneZ != 0xFFFF)
                {
                    zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                }
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc/gloc)\n", range));
                str.Insert(0, string.Format("Your gloc:(x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY));
            }
            else if (regionGlobalCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF) /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = 0;
                if (lastObjectCoords.CurrentZoneZ != 0xFFFF)
                {
                    zdiff = (long)regionGlobalCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                }
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc/gloc)\n", range));
            }
            if (objectId != 0xFFFF)
                str.Insert(0, string.Format("\nobjectId:0x{0:X4}{1}\n", objectId, objectType));
            return str.ToString();
        }
 private string MakeKidInfo(PacketLog log, int selectedIndex, ushort keepId)
 {
     StringBuilder str = new StringBuilder();
     for (int i = selectedIndex; i >= 0; i--)
     {
         Packet pak = log[i];
         if (pak is StoC_0x20_PlayerPositionAndObjectID) // stop scanning packets on enter region
         {
             break;
         }
         else if (pak is StoC_0x69_KeepOverview)
         {
             if ((pak as StoC_0x69_KeepOverview).KeepId == keepId)
             {
                 str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                 break;
             }
         }
         else if (pak is StoC_0x6C_KeepComponentOverview)
         {
             if ((pak as StoC_0x6C_KeepComponentOverview).KeepId == keepId)
             {
                 str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
             }
         }
     }
     str.Insert(0, string.Format("\nkeepId:0x{0:X4}\n", keepId));
     return str.ToString();
 }
 private int FormInfoString(PacketLog log, int selectedIndex, StringBuilder str, ushort icon, string spellName)
 {
     int additionStringCount = 0;
     for (int i = selectedIndex; i < log.Count ; i++)
     {
         Packet pak = log[i];
         if (pak is StoC_0x72_SpellCastAnimation)
         {
             StoC_0x72_SpellCastAnimation animatePak = pak as StoC_0x72_SpellCastAnimation;
             if (animatePak != null && animatePak.SpellId == icon)
             {
                 str.Append('\n');
                 str.Append(pak.ToHumanReadableString(TimeSpan.Zero, true));
                 str.Append('\n');
                 additionStringCount += 3;
                 break;
             }
         }
     }
     for (int i = selectedIndex; i < log.Count ; i++)
     {
         Packet pak = log[i];
         if (pak is StoC_0x1B_SpellEffectAnimation)
         {
             StoC_0x1B_SpellEffectAnimation effectPak = pak as StoC_0x1B_SpellEffectAnimation;
             if (effectPak != null && effectPak.SpellId == icon)
             {
                 str.Append('\n');
                 str.Append(pak.ToHumanReadableString(TimeSpan.Zero, true));
                 str.Append('\n');
                 additionStringCount += 3;
                 break;
             }
         }
     }
     for (int i = 0; i < log.Count ; i++)
     {
         Packet pak = log[i];
         if (pak is StoC_0xC4_CustomTextWindow && (pak as StoC_0xC4_CustomTextWindow).Caption == spellName)
         {
             str.Append('\n');
             str.Append(pak.ToHumanReadableString(TimeSpan.Zero, true));
             additionStringCount += ((pak as StoC_0xC4_CustomTextWindow).Lines.Length + 4);
             break;
         }
     }
     return additionStringCount;
 }
 /// <summary>
 /// Set all log variables from the packet here
 /// </summary>
 /// <param name="log"></param>
 public override void InitLog(PacketLog log)
 {
     // Reinit only on for 190 version and subversion lower 190.2 (not must be in subversion detection on serverside)
     if (!log.IgnoreVersionChanges && log.Version >= 190 && log.Version < 190.2f)
     {
         if (Length == 54)
         {
             log.Version = 190.2f;
             log.SubversionReinit = true;
     //					log.IgnoreVersionChanges = true;
         }
     }
 }
 /// <summary>
 /// Packets the log_ on packets changed.
 /// </summary>
 /// <param name="logManager">The log manager.</param>
 void packetLog_OnPacketsChanged(PacketLog logManager)
 {
     OnPacketsCountChange();
 }
Example #21
0
        ReadDataHandlerResult ReadData()
        {
            PacketHeader header = new PacketHeader();

            header.Read(_headerBuffer.GetData());

            if (!_worldCrypt.Decrypt(_packetBuffer.GetData(), header.Tag))
            {
                Log.outError(LogFilter.Network, $"WorldSocket.ReadData(): client {GetRemoteIpAddress()} failed to decrypt packet (size: {header.Size})");
                return(ReadDataHandlerResult.Error);
            }

            WorldPacket packet = new WorldPacket(_packetBuffer.GetData());

            _packetBuffer.Reset();

            if (packet.GetOpcode() >= (int)ClientOpcodes.Max)
            {
                Log.outError(LogFilter.Network, $"WorldSocket.ReadData(): client {GetRemoteIpAddress()} sent wrong opcode (opcode: {packet.GetOpcode()})");
                return(ReadDataHandlerResult.Error);
            }

            PacketLog.Write(packet.GetData(), packet.GetOpcode(), GetRemoteIpAddress(), _connectType, true);

            ClientOpcodes opcode = (ClientOpcodes)packet.GetOpcode();

            switch (opcode)
            {
            case ClientOpcodes.Ping:
                Ping ping = new Ping(packet);
                ping.Read();
                if (!HandlePing(ping))
                {
                    return(ReadDataHandlerResult.Error);
                }
                break;

            case ClientOpcodes.AuthSession:
                if (_worldSession != null)
                {
                    Log.outError(LogFilter.Network, $"WorldSocket.ReadData(): received duplicate CMSG_AUTH_SESSION from {_worldSession.GetPlayerInfo()}");
                    return(ReadDataHandlerResult.Error);
                }

                AuthSession authSession = new AuthSession(packet);
                authSession.Read();
                HandleAuthSession(authSession);
                return(ReadDataHandlerResult.WaitingForQuery);

            case ClientOpcodes.AuthContinuedSession:
                if (_worldSession != null)
                {
                    Log.outError(LogFilter.Network, $"WorldSocket.ReadData(): received duplicate CMSG_AUTH_CONTINUED_SESSION from {_worldSession.GetPlayerInfo()}");
                    return(ReadDataHandlerResult.Error);
                }

                AuthContinuedSession authContinuedSession = new AuthContinuedSession(packet);
                authContinuedSession.Read();
                HandleAuthContinuedSession(authContinuedSession);
                return(ReadDataHandlerResult.WaitingForQuery);

            case ClientOpcodes.KeepAlive:
                if (_worldSession != null)
                {
                    _worldSession.ResetTimeOutTime(true);
                }
                break;

            case ClientOpcodes.LogDisconnect:
                break;

            case ClientOpcodes.EnableNagle:
                SetNoDelay(false);
                break;

            case ClientOpcodes.ConnectToFailed:
                ConnectToFailed connectToFailed = new ConnectToFailed(packet);
                connectToFailed.Read();
                HandleConnectToFailed(connectToFailed);
                break;

            case ClientOpcodes.EnterEncryptedModeAck:
                HandleEnterEncryptedModeAck();
                break;

            default:
                if (_worldSession == null)
                {
                    Log.outError(LogFilter.Network, $"ProcessIncoming: Client not authed opcode = {opcode}");
                    return(ReadDataHandlerResult.Error);
                }

                if (!PacketManager.ContainsHandler(opcode))
                {
                    Log.outError(LogFilter.Network, $"No defined handler for opcode {opcode} sent by {_worldSession.GetPlayerInfo()}");
                    break;
                }

                // Our Idle timer will reset on any non PING opcodes on login screen, allowing us to catch people idling.
                _worldSession.ResetTimeOutTime(false);

                // Copy the packet to the heap before enqueuing
                _worldSession.QueuePacket(packet);
                break;
            }

            return(ReadDataHandlerResult.Ok);
        }
 /// <summary>
 /// Set all log variables from the packet here
 /// </summary>
 /// <param name="log"></param>
 public override void InitLog(PacketLog log)
 {
     // Partialy detectable only from serverside (this subversion not detectable from client)
     if (!log.IgnoreVersionChanges && log.Version >= 189 && log.Version < 189.1f)
     {
         if (Length == 6)// detectable only if server send empty inventory update
         {
             log.Version = 189.1f;
             log.SubversionReinit = true;
     //					log.IgnoreVersionChanges = true;
         }
     }
 }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog log           = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int       selectedIndex = selectedPacket.PacketIndex;
            string    charName      = "";

            GroupMemberInfo[] groupMembers = new GroupMemberInfo[8];
            for (int i = 0; i <= selectedIndex; i++)
            {
                Packet pak = log[i];
                if (pak is CtoS_0x10_CharacterSelectRequest)
                {
                    CtoS_0x10_CharacterSelectRequest login = (CtoS_0x10_CharacterSelectRequest)pak;
                    charName = login.CharName;
                }
                else if (pak is StoC_0x16_VariousUpdate)
                {
                    StoC_0x16_VariousUpdate groupPak = (StoC_0x16_VariousUpdate)pak;
                    if (groupPak.SubCode == 3)
                    {
                        StoC_0x16_VariousUpdate.PlayerUpdate subData = (StoC_0x16_VariousUpdate.PlayerUpdate)groupPak.SubData;
                        charName = subData.playerName;
                    }
                    else if (groupPak.SubCode == 6)                     // group update
                    {
                        StoC_0x16_VariousUpdate.PlayerGroupUpdate grpUpdate = groupPak.InPlayerGroupUpdate;
                        if (grpUpdate != null)
                        {
                            for (int grpIndex = 0; grpIndex < 8; grpIndex++)
                            {
                                if (grpUpdate.groupMembers.Length > grpIndex)
                                {
                                    if (groupMembers[grpIndex] == null)
                                    {
                                        groupMembers[grpIndex] = new GroupMemberInfo();
                                    }
                                    groupMembers[grpIndex].groupMember            = grpUpdate.groupMembers[grpIndex];
                                    groupMembers[grpIndex].flag_0x16_UpdateIsLast = true;
                                    groupMembers[grpIndex].flagMemberInGroup      = true;
                                }
                                else
                                {
                                    if (groupMembers[grpIndex] != null)
                                    {
                                        groupMembers[grpIndex].flagMemberInGroup = false;
                                    }
                                }
                            }
                        }
                    }
                }
                else if (pak is StoC_0x70_PlayerGroupUpdate)
                {
                    StoC_0x70_PlayerGroupUpdate groupPak = (StoC_0x70_PlayerGroupUpdate)pak;
                    foreach (object o in groupPak.Updates)
                    {
                        if (o is StoC_0x70_PlayerGroupUpdate.PlayerStatusData)
                        {
                            StoC_0x70_PlayerGroupUpdate.PlayerStatusData stat = o as StoC_0x70_PlayerGroupUpdate.PlayerStatusData;
                            if (groupMembers[stat.playerIndex] == null)
                            {
                                groupMembers[stat.playerIndex] = new GroupMemberInfo();
                            }
                            groupMembers[stat.playerIndex].playerStatusData       = stat;
                            groupMembers[stat.playerIndex].flag_0x16_UpdateIsLast = false;
                        }
                        else if (o is StoC_0x70_PlayerGroupUpdate.PlayerBuffsData)
                        {
                            StoC_0x70_PlayerGroupUpdate.PlayerBuffsData buffs = o as StoC_0x70_PlayerGroupUpdate.PlayerBuffsData;
                            if (groupMembers[buffs.playerIndex] == null)
                            {
                                groupMembers[buffs.playerIndex] = new GroupMemberInfo();
                            }
                            groupMembers[buffs.playerIndex].playerBuffsData = buffs;
                        }
                        else if (o is StoC_0x70_PlayerGroupUpdate_173.PlayerMapData)
                        {
                            StoC_0x70_PlayerGroupUpdate_173.PlayerMapData map = o as StoC_0x70_PlayerGroupUpdate_173.PlayerMapData;
                            if (groupMembers[map.player] == null)
                            {
                                groupMembers[map.player] = new GroupMemberInfo();
                            }
                            groupMembers[map.player].playerMapData = map;
                        }
                    }
                }
            }

            StringBuilder str   = new StringBuilder();
            bool          found = false;

            for (int i = 0; i < groupMembers.Length; i++)
            {
                if (groupMembers[i] != null)
                {
                    bool flagMemberInfoPrinted = false;
                    if (!groupMembers[i].flagMemberInGroup)
                    {
                        continue;
                    }
                    found = true;
                    str.AppendFormat("player{0}: level:{1,-2} oid:0x{2:X4} class:\"{3}\"\t name:\"{4}\"", i, groupMembers[i].groupMember.level, groupMembers[i].groupMember.oid, groupMembers[i].groupMember.classname, groupMembers[i].groupMember.name);
                    if (charName == groupMembers[i].groupMember.name)
                    {
                        str.Append(" (YOU)");
                    }
                    str.Append("\n");
                    if (groupMembers[i].flag_0x16_UpdateIsLast)
                    {
                        str.AppendFormat("player{0}: health:{1,3}% mana:{2,3}% endurance:{3,3}% status:0x{4:X2}", i, groupMembers[i].groupMember.health, groupMembers[i].groupMember.mana, groupMembers[i].groupMember.endurance, groupMembers[i].groupMember.status);
                        flagMemberInfoPrinted = true;
                        str.Append("\n");
                    }
                    if (groupMembers[i].playerStatusData != null && !flagMemberInfoPrinted)
                    {
                        str.Append(groupMembers[i].playerStatusData.ToString());
                        str.Append("\n");
                    }
                    if (groupMembers[i].playerMapData != null)
                    {
                        str.Append(groupMembers[i].playerMapData.ToString());
                        str.Append("\n");
                    }
                    if (groupMembers[i].playerBuffsData != null)
                    {
                        str.Append(groupMembers[i].playerBuffsData.ToString());
                        str.Append("\n");
                    }
                    str.Append("\n");
                }
            }
            if (!found)
            {
                str.Append("Group info not found\n");
            }
            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text   = "Player group info (right click to close)";
            infoWindow.Width  = 820;
            infoWindow.Height = 320;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();

            return(false);
        }
Example #24
0
        public ICollection <Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            int       counter              = 0;
            string    line                 = null;
            Packet    pak                  = null;
            PacketLog log                  = new PacketLog();
            int       dataBytesCount       = -1;
            ArrayList ignoredPacketHeaders = new ArrayList();
            string    header               = "";

            using (StreamReader s = new StreamReader(stream, Encoding.ASCII))
            {
                try
                {
                    while ((line = s.ReadLine()) != null)
                    {
                        if (callback != null && (counter++ & 0x1FFF) == 0)                         // update progress every 8k lines
                        {
                            callback((int)(stream.Position >> 10),
                                     (int)(stream.Length >> 10));
                        }

                        if (line.Length < 1)
                        {
                            continue;
                        }

                        if (line[0] == '<')
                        {
                            if (pak != null)
                            {
                                if (pak.Length == dataBytesCount)
                                {
                                    /// Completed packet!



                                    try { pak.InitLog(log); }
                                    catch {}
                                }
                                else
                                {
                                    ignoredPacketHeaders.Add(header);
                                }
                            }

                            header = line;

                            try
                            {
                                int code;
                                ePacketDirection dir;
                                ePacketProtocol  prot;
                                TimeSpan         time;
                                dataBytesCount = DaocLoggerV3TextLogReader.ParseHeader(line, out code, out dir, out prot, out time);

                                if (dataBytesCount < 0)
                                {
                                    pak = null;
                                    ignoredPacketHeaders.Add(header);
                                }
                                else
                                {
                                    // header parsed successfully!
                                    if (code == 0xa9)
                                    {
                                        packetsCount++;                                     // get statistics
                                        pak = null;                                         // ignore the data
                                    }
                                    continue;

/*									pak = PacketManager.CreatePacket(log.Version, code, dir, dataBytesCount);
 *                                                                      pak.Code = code;
 *                                                                      pak.Direction = dir;
 *                                                                      pak.Protocol = prot;
 *                                                                      pak.Time = time;*/
                                }
                            }
                            catch
                            {
                                pak = null;
                                ignoredPacketHeaders.Add(header);
                            }

                            continue;
                        }

                        if (pak == null)
                        {
                            continue;
                        }

                        DaocLoggerV3TextLogReader.ParseDataLine(line, pak);
                    }
                }
                catch (Exception e)
                {
                    Log.Error("reading file", e);
                }

                if (pak != null)
                {
                    if (pak.Length == dataBytesCount)
                    {
                        // last completed packet!
                    }
                    else
                    {
                        ignoredPacketHeaders.Add(header);
                    }
                }
            }

            if (ignoredPacketHeaders.Count > 0)
            {
                StringBuilder ignored = new StringBuilder("Ignored packets: " + ignoredPacketHeaders.Count + "\n\n");
                for (int i = 0; i < ignoredPacketHeaders.Count; i++)
                {
                    string s = (string)ignoredPacketHeaders[i];
                    ignored.Append('\n').Append(s);
                    if (i > 15)
                    {
                        ignored.Append("\n...");
                        break;
                    }
                }
                Log.Info(ignored.ToString());
            }

            return(new List <Packet>(0));
        }
Example #25
0
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog log           = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int       selectedIndex = selectedPacket.PacketIndex;

            Packet[] quests = new Packet[26];
            for (int i = 0; i < selectedIndex; i++)
            {
                Packet pak = log[i];
                if (pak is StoC_0x83_QuestUpdate_186)
                {
                    if ((pak as StoC_0x83_QuestUpdate_186).InNewQuestUpdate != null)
                    {
                        quests[((pak as StoC_0x83_QuestUpdate_186).InNewQuestUpdate).index] = pak;
                    }
                    else if ((pak as StoC_0x83_QuestUpdate).InQuestUpdate != null)
                    {
                        int index = ((pak as StoC_0x83_QuestUpdate).InQuestUpdate).index;
                        if (((pak as StoC_0x83_QuestUpdate).InQuestUpdate).lenName == 0 && ((pak as StoC_0x83_QuestUpdate).InQuestUpdate).lenDesc == 0)
                        {
                            quests[index] = null;
                        }
                        else
                        {
                            quests[index] = pak;
                        }
                    }
                }
                else if (pak is StoC_0x83_QuestUpdate)
                {
                    int index = ((pak as StoC_0x83_QuestUpdate).InQuestUpdate).index;
                    if (((pak as StoC_0x83_QuestUpdate).InQuestUpdate).lenName == 0 && ((pak as StoC_0x83_QuestUpdate).InQuestUpdate).lenDesc == 0)
                    {
                        quests[index] = null;
                    }
                    else
                    {
                        quests[index] = pak;
                    }
                }
            }

            StringBuilder str = new StringBuilder();

            for (int i = 0; i < quests.Length; i++)
            {
                Packet pak = quests[i];
                if (pak != null)
                {
                    str.Append(pak.GetPacketDataString(true));
                    str.Append('\n');
                }
            }
            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text   = "Player quest info (right click to close)";
            infoWindow.Width  = 820;
            infoWindow.Height = 320;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();

            return(false);
        }
        public ICollection <Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            List <Packet> packets = new List <Packet>((int)(stream.Length / 128));

            int           counter        = 0;
            Packet        pak            = null;
            PacketLog     log            = new PacketLog();
            int           dataBytesCount = -1;
            int           ignoredCount   = 0;
            StringBuilder header         = new StringBuilder('<', 64);

            using (BinaryReader s = new BinaryReader(stream, Encoding.ASCII))
            {
                try
                {
                    while (s.BaseStream.Position < s.BaseStream.Length)
                    {
                        if (callback != null && (counter++ & 0xFFF) == 0)                         // update progress every 4096th packet
                        {
                            callback((int)(s.BaseStream.Position >> 10), (int)(s.BaseStream.Length >> 10));
                        }

                        if (s.ReadChar() != '<')
                        {
                            continue;
                        }

                        if (pak != null)
                        {
                            if (pak.Length == dataBytesCount)
                            {
                                packets.Add(pak);
                                try { pak.InitLog(log); }
                                catch {}
                            }
                            else
                            {
                                ignoredCount++;
                            }
                        }

                        // get the header string
                        header.Length = 1;
                        header.Append(s.ReadChars(48));
                        for (;;)
                        {
                            char curChar = s.ReadChar();
                            if (curChar == '<')
                            {
                                s.BaseStream.Seek(-1, SeekOrigin.Current);
                                break;
                            }
                            header.Append(curChar);
                            if (curChar == '>')
                            {
                                s.BaseStream.Seek(2, SeekOrigin.Current);
                                break;
                            }
                            if (header.Length > 128)
                            {
                                break;
                            }
                        }

                        try
                        {
                            int code;
                            ePacketDirection dir;
                            ePacketProtocol  prot;
                            TimeSpan         time;
                            dataBytesCount = DaocLoggerV3TextLogReader.ParseHeader(header.ToString(), out code, out dir, out prot, out time);

                            pak           = PacketManager.CreatePacket(log.Version, (byte)code, dir, dataBytesCount);
                            pak.Code      = (byte)code;
                            pak.Direction = dir;
                            pak.Protocol  = prot;
                            pak.Time      = time;
                        }
                        catch
                        {
                            pak = null;
                            ignoredCount++;
//							MessageBox.Show("parse header failed:\nposition="+s.BaseStream.Position+"\n'"+header.ToString()+"'\n");
                        }

                        if (pak == null)
                        {
                            continue;
                        }

                        byte[] pakData = s.ReadBytes(dataBytesCount);
                        pak.Write(pakData, 0, pakData.Length);
                    }
                }
                catch (Exception e)
                {
                    Log.Error("reading file", e);
                }

                if (pak != null)
                {
                    if (pak.Length == dataBytesCount)
                    {
                        packets.Add(pak);
                    }
                    else
                    {
                        ignoredCount++;
                    }
                }
            }

            if (ignoredCount > 0)
            {
                Log.Info("ignored packets: " + ignoredCount);
            }

            return(packets);
        }
        public ICollection<Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            List<Packet> packets = new List<Packet>();

            float currentVersion = -1;
            int counter = 0;
            string line = null;
            Packet pak = null;
            PacketLog log = new PacketLog();
            ArrayList badLines = new ArrayList();
            byte[] data;

            using(StreamReader s = new StreamReader(stream, Encoding.ASCII))
            {
                int indexOfPacketHandler;
                while ((line = s.ReadLine()) != null)
                {
                    try
                    {
                        if (callback != null && (counter++ & 0x1FFF) == 0) // update progress every 8k lines
                            callback((int)(stream.Position>>10),
                                (int)(stream.Length>>10));

                        if (line.Length < 1) continue;
                        if ((indexOfPacketHandler = line.IndexOf("PacketHandler.PacketProcessor - ")) >= 0)
                        {
                            line = line.Substring(indexOfPacketHandler + 32);
                            if (line.StartsWith("===>"))
                            {
                                int code = line.IndexOf("> Packet 0x");
                                if (code >= 0 && Util.ParseHexFast(line, code + 11, 2, out code))
                                {
                                    data = ReadPacketData(s);
                                    pak = new Packet(data.Length);
                                    pak.Direction = ePacketDirection.ClientToServer;
                                    pak.Protocol = ePacketProtocol.TCP;
                                    pak.Code = (byte)code;
                                    pak.Time = ParseTime(line);
                                    pak.Write(data, 0, data.Length);
                                }
                            }
                            else if (line.StartsWith("Sending packets longer than 2048"))
                            {
                                int code = line.IndexOf("Packet code: 0x");
                                if (code >= 0 && Util.ParseHexFast(line, code + 15, 2, out code))
                                {
                                    data = ReadPacketData(s);
                                    if (data.Length < 3)
                                        continue;
                                    pak = new Packet(data.Length - 3);
                                    pak.Protocol = ePacketProtocol.TCP; // can't detect protocol
                                    pak.Direction = ePacketDirection.ServerToClient;
                                    pak.Code = (byte)code;
                                    pak.Time = ParseTime(line);
                                    pak.Write(data, 3, data.Length - 3);
                                }
                            }
                            else if (line.StartsWith("<==="))
                            {
                                int code = line.IndexOf("> Packet 0x");
                                if (code >= 0 && Util.ParseHexFast(line, code + 11, 2, out code))
                                {
                                    data = ReadPacketData(s);
                                    if (data.Length < 3)
                                        continue;
                                    pak = new Packet(data.Length - 3);
                                    pak.Protocol = ePacketProtocol.TCP; // can't detect protocol
                                    pak.Direction = ePacketDirection.ServerToClient;
                                    pak.Code = (byte)code;
                                    pak.Time = ParseTime(line);
                                    pak.Write(data, 3, data.Length - 3);
                                }
                                else
                                {
                                    badLines.Add("not GSPacketIn?  : " + line);
                                    continue;
                                }
                            }
                        }
                        else
                        {
                            continue;
                        }

                        pak = PacketManager.ChangePacketClass(pak, currentVersion);
            //						pak.AllowClassChange = false;
                        packets.Add(pak);
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.ToString());
                        badLines.Add(e.GetType().FullName + ": " + line);
                    }
                }
            }

            if (badLines.Count > 0)
            {
                StringBuilder str = new StringBuilder("error parsing following lines (" + badLines.Count + "):\n\n");
                int i = 0;
                foreach (string s in badLines)
                {
                    str.Append(s).Append('\n');
                    if (++i > 15)
                    {
                        str.Append("...\n").Append(badLines.Count - i).Append(" lines more.\n");
                        break;
                    }
                }
                Log.Info(str.ToString());
            }

            return packets;
        }
        public static SortedList MakeOidList(int selectedIndex, PacketLog log, out int currentRegion, out int currentZone)
        {
            SortedList oidInfo = new SortedList();
            currentRegion = -1;
            currentZone = -1;
            ushort playerOid = 0;
            string CharName = "UNKNOWN";

            for (int i = 0; i < selectedIndex; ++i)
            {
                Packet pak = log[i];
                if (pak is StoC_0xD4_PlayerCreate)
                {
                    StoC_0xD4_PlayerCreate player = (StoC_0xD4_PlayerCreate)pak;

                    oidInfo[player.Oid] = new LivingInfo(pak.Time, "PLR", player.Name, player.Level, player.GuildName);
                }
                else if (pak is StoC_0x4B_PlayerCreate_172)
                {
                    StoC_0x4B_PlayerCreate_172 player = (StoC_0x4B_PlayerCreate_172)pak;

                    oidInfo[player.Oid] = new LivingInfo(pak.Time, "PLR", player.Name, player.Level, player.GuildName);
                    if (currentZone == -1)
                        currentZone = player.ZoneId;
                }
                else if (pak is StoC_0x12_CreateMovingObject)
                {
                    StoC_0x12_CreateMovingObject obj = (StoC_0x12_CreateMovingObject)pak;

                    oidInfo[obj.ObjectOid] = new ObjectInfo(pak.Time, "MOVE", obj.Name, 0);
                }
                else if (pak is StoC_0x6C_KeepComponentOverview)
                {
                    StoC_0x6C_KeepComponentOverview keep = (StoC_0x6C_KeepComponentOverview)pak;

                    oidInfo[keep.Uid] = new ObjectInfo(pak.Time, "Keep", string.Format("keepId:0x{0:X4} componentId:{1}", keep.KeepId, keep.ComponentId), 0);
                }
                else if (pak is StoC_0xD1_HouseCreate)
                {
                    StoC_0xD1_HouseCreate house = (StoC_0xD1_HouseCreate)pak;

                    oidInfo[house.HouseId] = new ObjectInfo(pak.Time, "HOUS", house.Name, 0);
                }
                else if (pak is StoC_0xDA_NpcCreate)
                {
                    StoC_0xDA_NpcCreate npc = (StoC_0xDA_NpcCreate)pak;

                    oidInfo[npc.Oid] = new LivingInfo(pak.Time, "NPC", npc.Name, npc.Level, npc.GuildName);
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    CtoS_0xA9_PlayerPosition plr = (CtoS_0xA9_PlayerPosition)pak;
                    if (currentZone == -1)
                        currentZone = plr.CurrentZoneId;
                }
                else if (pak is StoC_0xD9_ItemDoorCreate)
                {
                    StoC_0xD9_ItemDoorCreate item = (StoC_0xD9_ItemDoorCreate)pak;
                    string type = "ITEM";
                    if (item.ExtraBytes > 0) type = "DOOR";
                    oidInfo[item.Oid] = new ObjectInfo(pak.Time, type, item.Name, 0);
                }
                else if (pak is StoC_0xB7_RegionChange)
                {
                    StoC_0xB7_RegionChange region = (StoC_0xB7_RegionChange)pak;

            //					if (region.RegionId != currentRegion)
            //					{
                        currentRegion = region.RegionId;
                        currentZone = region.ZoneId;
                        oidInfo.Clear();
            //					}
                }
                else if (pak is StoC_0x20_PlayerPositionAndObjectID_171)
                {
                    StoC_0x20_PlayerPositionAndObjectID_171 region = (StoC_0x20_PlayerPositionAndObjectID_171)pak;

            //					if (region.Region!= currentRegion)
            //					{
                        currentRegion = region.Region;
                        oidInfo.Clear();
            //					}
                    playerOid = region.PlayerOid;
                    oidInfo[region.PlayerOid] = new LivingInfo(pak.Time, "YOU", CharName, 0, "");
                }
                else if (pak is StoC_0x16_VariousUpdate)
                {
                    if (playerOid != 0)
                    {
                        StoC_0x16_VariousUpdate stat = (StoC_0x16_VariousUpdate)pak;
                        if (stat.SubCode == 3)
                        {
                            StoC_0x16_VariousUpdate.PlayerUpdate subData = (StoC_0x16_VariousUpdate.PlayerUpdate)stat.SubData;
                            if (oidInfo[playerOid] != null)
                            {
                                LivingInfo plr = (LivingInfo)oidInfo[playerOid];
                                plr.level = subData.playerLevel;
                                plr.guildName = subData.guildName;
                                oidInfo[playerOid] = plr;
                            }
                        }
                    }
                }
                else if (pak is CtoS_0x10_CharacterSelectRequest)
                {
                    CtoS_0x10_CharacterSelectRequest login = (CtoS_0x10_CharacterSelectRequest)pak;
                    CharName = login.CharName;
                }
            }
            return oidInfo;
        }
 private string MakeSidInfo(PacketLog log, int selectedIndex, ushort sessionId)
 {
     StringBuilder str = new StringBuilder();
     bool fullInfoFound = false;
     //			bool moveFound = false;
     str.AppendFormat("\nsessionId:0x{0:X4}\n", sessionId);
     for (int i = selectedIndex; i >= 0; i--)
     {
         Packet pak = log[i];
         if (pak is StoC_0x20_PlayerPositionAndObjectID) // stop scanning packets on enter region
         {
             break; // Not found player initialize in current region
         }
         else if (pak is StoC_0xD4_PlayerCreate)
         {
             if ((pak as StoC_0xD4_PlayerCreate).SessionId == sessionId)
             {
                 fullInfoFound = true;
                 str.Append(MakeOidInfo(log, selectedIndex, (pak as StoC_0xD4_PlayerCreate).Oid, sessionId, 0));
                 break;
             }
         }
         else if (pak is StoC_0x4B_PlayerCreate_172)
         {
             if ((pak as StoC_0x4B_PlayerCreate_172).SessionId == sessionId)
             {
                 fullInfoFound = true;
                 str.Append(MakeOidInfo(log, selectedIndex, (pak as StoC_0x4B_PlayerCreate_172).Oid, sessionId, 0));
                 break;
             }
         }
     //				else if (pak is CtoS_0xA9_PlayerPosition)
     //				{
     //					if (!moveFound && (pak as CtoS_0xA9_PlayerPosition).SessionId == sessionId)
     //					{
     //						moveFound = true;
     //						str.Append(pak.ToHumanReadableString(zeroTimeSpan, true) + '\n');
     //					}
     //				}
     //				else if (pak is StoC_0xA9_PlayerPosition)
     //				{
     //					if (!moveFound && (pak as StoC_0xA9_PlayerPosition).SessionId == sessionId)
     //					{
     //						moveFound = true;
     //						str.Append(pak.ToHumanReadableString(zeroTimeSpan, true) + '\n');
     //					}
     //				}
     }
     if (!fullInfoFound)
         str.Append("No more info found\n");
     return str.ToString();
 }
Example #30
0
        private void HandleNetwork()
        {
            while (true)
            {
                if (ShuttingDown)
                {
                    return;
                }

                for (int i = 0; i < Clients.Count; i++)
                {
                    //TODO: Kick client due to keep alive timeouts.
                    while (Clients[i].Client.NetworkManager.DataAvailable)
                    {
                        try
                        {
                            /* S <- P <- C
                             * Proxying data from client to server.
                             */

                            var rawPacket       = (byte[])null;                                                                    // raw encrypted packet
                            var decryptedPacket = (byte[])null;
                            var packet          = Clients[i].Client.NetworkManager.ReadPacket(out rawPacket, out decryptedPacket); // receive data from client

                            if (packet != null)
                            {
                                HandlePacket(Clients[i], packet);
                                if (rawPacket != null)
                                {
                                    Clients[i].Server.NetworkManager.CoCStream.Write(rawPacket, 0, rawPacket.Length); // sends data back to server
                                    PacketDumper.LogPacket(packet, PacketDirection.Server, decryptedPacket);
                                    PacketLog.LogData(packet, PacketDirection.Server);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ExceptionLog.LogData(ex);
                            Clients.RemoveAt(i);
                            goto ResetLoop;
                        }
                    }

                    if (Clients[i].Server == null)
                    {
                        continue;
                    }

                    while (Clients[i].Server.NetworkManager.DataAvailable)
                    {
                        try
                        {
                            /* S -> P -> C
                             * Proxying data from server to client.
                             */

                            var rawPacket       = (byte[])null;
                            var decryptedPacket = (byte[])null;
                            var packet          = Clients[i].Server.NetworkManager.ReadPacket(out rawPacket, out decryptedPacket); // receive data from server

                            if (packet != null)
                            {
                                HandlePacket(Clients[i], packet);
                                if (rawPacket != null)
                                {
                                    Clients[i].Client.NetworkManager.CoCStream.Write(rawPacket, 0, rawPacket.Length); // sends data back to client
                                    PacketDumper.LogPacket(packet, PacketDirection.Client, decryptedPacket);
                                    PacketLog.LogData(packet, PacketDirection.Client);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            ExceptionLog.LogData(ex);
                            Clients.RemoveAt(i);
                            goto ResetLoop;
                        }
                    }

                    continue;
ResetLoop:
                    break;
                }
                Thread.Sleep(1);
            }
        }
        private string MakeHidInfo(PacketLog log, int selectedIndex, ushort houseId)
        {
            StringBuilder str = new StringBuilder();
            CtoS_0xA9_PlayerPosition lastSelfCoords = null;
            LocalCoords lastObjectCoords = null;
            LocalCoords regionGlobalCoords = null;
            LocalCoords firstSelfCoords = null;
            bool flagInteriorFound = false;
            bool flagInsideUpdateFound = false;
            bool flagExteriorFound = false;
            bool flagHouseFound = false;
            for (int i = selectedIndex; i >= 0; i--)
            {
                Packet pak = log[i];
                if (pak is StoC_0x20_PlayerPositionAndObjectID) // stop scanning packets on enter region
                {
                    regionGlobalCoords = new LocalCoords((pak as StoC_0x20_PlayerPositionAndObjectID).X, (pak as StoC_0x20_PlayerPositionAndObjectID).Y, (pak as StoC_0x20_PlayerPositionAndObjectID).Z);
                    break;
                }
                else if (pak is StoC_0xD1_HouseCreate)
                {
                    if (!flagHouseFound && (pak as StoC_0xD1_HouseCreate).HouseId == houseId)
                    {
                        flagHouseFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD1_HouseCreate).X, (pak as StoC_0xD1_HouseCreate).Y, (pak as StoC_0xD1_HouseCreate).Z);
                    }
                }
                else if (pak is StoC_0xD2_HouseUpdate)
                {
                    if (!flagExteriorFound && (pak as StoC_0xD2_HouseUpdate).HouseId == houseId && (pak as StoC_0xD2_HouseUpdate).UpdateCode == 0x80)
                    {
                        flagExteriorFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x09_HouseDecorationUpdate)
                {
                    if (!flagInteriorFound && (pak as StoC_0x09_HouseDecorationUpdate).HouseId == houseId && (pak as StoC_0x09_HouseDecorationUpdate).DecorationCode == 0x80)
                    {
                        flagInteriorFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x08_HouseInsideUpdate)
                {
                    if (!flagInsideUpdateFound && (pak as StoC_0x08_HouseInsideUpdate).HouseId == houseId)
                    {
                        flagInsideUpdateFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    if (firstSelfCoords == null)
                    {
                        firstSelfCoords = new LocalCoords((pak as CtoS_0xA9_PlayerPosition).CurrentZoneX, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ, 0xFFFF);
                    }
                    else
                    {
                        firstSelfCoords.CurrentZoneX = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneX;
                        firstSelfCoords.CurrentZoneY = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY;
                        firstSelfCoords.CurrentZoneZ = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ;
                    }

                    if (lastSelfCoords == null)
                    {
                        lastSelfCoords = pak as CtoS_0xA9_PlayerPosition;
                    }
                }
            }
            str.Insert(0, string.Format("\nhouseId:0x{0:X4}\n", houseId));
            if (lastSelfCoords != null && lastObjectCoords != null && lastSelfCoords.CurrentZoneId == lastObjectCoords.CurrentZoneId)
            {
                long xdiff = (long)lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc)\n", range));
            }
            else if (lastSelfCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF && regionGlobalCoords != null && firstSelfCoords != null) /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc)\n", range));
            //				str.Insert(0, string.Format("Your gloc:(x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY));
            }
            else if (regionGlobalCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF) /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)regionGlobalCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc)\n", range));
            }
            return str.ToString();
        }
Example #32
0
        private void HandleMessage(NetIncomingMessage msg)
        {
            switch (msg.MessageType)
            {
            case NetIncomingMessageType.ConnectionApproval:
                string  verStr = msg.ReadString();
                Version ver    = new Version(verStr);

                if (ver == MulTUNG.MulTUNG.Version)
                {
                    msg.SenderConnection.Approve();

                    string username = msg.ReadString().Trim();

                    if (!Players.Any(o => o.Value.Username.Equals(username)))
                    {
                        IGConsole.Log($"{username.Length} {MaxUsernameLength}");
                        if (username.Length < MaxUsernameLength)
                        {
                            msg.SenderConnection.Approve();
                        }
                        else
                        {
                            msg.SenderConnection.Deny($"your username must be shorter than {MaxUsernameLength} characters.");
                        }
                    }
                    else
                    {
                        msg.SenderConnection.Deny("someone is already using that username.");
                    }
                }
                else
                {
                    msg.SenderConnection.Deny($"wrong MulTUNG version, server has v{MulTUNG.MulTUNG.Version}.");
                }

                break;

            case NetIncomingMessageType.Data:
                var packet = PacketDeserializer.DeserializePacket(new MessagePacketReader(msg));

                if (packet.SenderID == Network.ServerPlayerID)
                {
                    break;
                }

                PacketLog.LogReceive(packet);

                if (packet.ShouldBroadcast)
                {
                    Broadcast(packet, packet.ReliableBroadcast ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.UnreliableSequenced);
                }
                else
                {
                    Network.ProcessPacket(packet, Network.ServerPlayerID);
                }

                break;

            case NetIncomingMessageType.StatusChanged:
                var status = (NetConnectionStatus)msg.ReadByte();

                if (status == NetConnectionStatus.Connected)
                {
                    int id = PlayerIdCounter++;

                    msg.SenderConnection.SendMessage(new PlayerWelcomePacket
                    {
                        YourID         = id,
                        ServerUsername = Network.Username,
                        Players        = Players.Select(o => new Tuple <int, string>(o.Key, o.Value.Username)).ToList()
                    }.GetMessage(Server), NetDeliveryMethod.ReliableOrdered, 0);

                    var player = new Player(id, msg.SenderConnection);

                    Log.WriteLine("Connected player " + player.ID);

                    Players.Add(id, player);
                }
                else if (status == NetConnectionStatus.Disconnected)
                {
                    var player = Players.SingleOrDefault(o => o.Value.Connection == msg.SenderConnection);

                    Players.Remove(player.Key);
                    PlayerManager.WaveGoodbye(player.Key);
                }

                break;
            }
        }
        public ICollection <Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            List <Packet> packets = new List <Packet>();

            float     currentVersion = -1;
            int       counter        = 0;
            string    line           = null;
            Packet    pak            = null;
            PacketLog log            = new PacketLog();
            ArrayList badLines       = new ArrayList();

            byte[] data;

            using (StreamReader s = new StreamReader(stream, Encoding.ASCII))
            {
                int indexOfPacketHandler;
                while ((line = s.ReadLine()) != null)
                {
                    try
                    {
                        if (callback != null && (counter++ & 0x1FFF) == 0)                         // update progress every 8k lines
                        {
                            callback((int)(stream.Position >> 10),
                                     (int)(stream.Length >> 10));
                        }

                        if (line.Length < 1)
                        {
                            continue;
                        }
                        if ((indexOfPacketHandler = line.IndexOf("PacketHandler.PacketProcessor - ")) >= 0)
                        {
                            line = line.Substring(indexOfPacketHandler + 32);
                            if (line.StartsWith("===>"))
                            {
                                int code = line.IndexOf("> Packet 0x");
                                if (code >= 0 && Util.ParseHexFast(line, code + 11, 2, out code))
                                {
                                    data          = ReadPacketData(s);
                                    pak           = new Packet(data.Length);
                                    pak.Direction = ePacketDirection.ClientToServer;
                                    pak.Protocol  = ePacketProtocol.TCP;
                                    pak.Code      = (byte)code;
                                    pak.Time      = ParseTime(line);
                                    pak.Write(data, 0, data.Length);
                                }
                            }
                            else if (line.StartsWith("Sending packets longer than 2048"))
                            {
                                int code = line.IndexOf("Packet code: 0x");
                                if (code >= 0 && Util.ParseHexFast(line, code + 15, 2, out code))
                                {
                                    data = ReadPacketData(s);
                                    if (data.Length < 3)
                                    {
                                        continue;
                                    }
                                    pak           = new Packet(data.Length - 3);
                                    pak.Protocol  = ePacketProtocol.TCP;                                    // can't detect protocol
                                    pak.Direction = ePacketDirection.ServerToClient;
                                    pak.Code      = (byte)code;
                                    pak.Time      = ParseTime(line);
                                    pak.Write(data, 3, data.Length - 3);
                                }
                            }
                            else if (line.StartsWith("<==="))
                            {
                                int code = line.IndexOf("> Packet 0x");
                                if (code >= 0 && Util.ParseHexFast(line, code + 11, 2, out code))
                                {
                                    data = ReadPacketData(s);
                                    if (data.Length < 3)
                                    {
                                        continue;
                                    }
                                    pak           = new Packet(data.Length - 3);
                                    pak.Protocol  = ePacketProtocol.TCP;                                    // can't detect protocol
                                    pak.Direction = ePacketDirection.ServerToClient;
                                    pak.Code      = (byte)code;
                                    pak.Time      = ParseTime(line);
                                    pak.Write(data, 3, data.Length - 3);
                                }
                                else
                                {
                                    badLines.Add("not GSPacketIn?  : " + line);
                                    continue;
                                }
                            }
                        }
                        else
                        {
                            continue;
                        }

                        pak = PacketManager.ChangePacketClass(pak, currentVersion);
//						pak.AllowClassChange = false;
                        packets.Add(pak);
                    }
                    catch (Exception e)
                    {
                        MessageBox.Show(e.ToString());
                        badLines.Add(e.GetType().FullName + ": " + line);
                    }
                }
            }

            if (badLines.Count > 0)
            {
                StringBuilder str = new StringBuilder("error parsing following lines (" + badLines.Count + "):\n\n");
                int           i   = 0;
                foreach (string s in badLines)
                {
                    str.Append(s).Append('\n');
                    if (++i > 15)
                    {
                        str.Append("...\n").Append(badLines.Count - i).Append(" lines more.\n");
                        break;
                    }
                }
                Log.Info(str.ToString());
            }

            return(packets);
        }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog log           = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int       selectedIndex = selectedPacket.PacketIndex;

            ushort sessionId = 0;

            ushort[] objectIds = null;
            ushort[] keepIds   = null;
            ushort   houseId   = 0;
            Packet   pak       = log[selectedIndex];

            if (pak is IObjectIdPacket)
            {
                objectIds = (pak as IObjectIdPacket).ObjectIds;
            }
            if (pak is ISessionIdPacket)
            {
                sessionId = (pak as ISessionIdPacket).SessionId;
            }
            if (pak is IHouseIdPacket)
            {
                houseId = (pak as IHouseIdPacket).HouseId;
            }
            if (pak is IKeepIdPacket)
            {
                keepIds = (pak as IKeepIdPacket).KeepIds;
            }

            StringBuilder str = new StringBuilder();

            if (sessionId == 0 && houseId == 0 && (objectIds == null || objectIds.Length == 0) && (keepIds == null || keepIds.Length == 0))
            {
                str.AppendFormat("packet not have any ID\n");
            }

            if (sessionId > 0)
            {
                str.Append(MakeSidInfo(log, selectedIndex, sessionId));
            }
            if (houseId > 0)
            {
                str.Append(MakeHidInfo(log, selectedIndex, houseId));
            }
            if (objectIds != null && objectIds.Length > 0)
            {
                for (int i = 0; i < objectIds.Length; i++)
                {
                    if (objectIds[i] > 0)
                    {
                        str.Append(MakeOidInfo(log, selectedIndex, objectIds[i], 0, 0));
                    }
                }
            }
            if (keepIds != null && keepIds.Length > 0)
            {
                for (int i = 0; i < keepIds.Length; i++)
                {
                    if (keepIds[i] > 0)
                    {
                        str.Append(MakeOidInfo(log, selectedIndex, 0xFFFF, 0, keepIds[i]));
                    }
                }
//						str.Append(MakeKidInfo(log, selectedIndex, keepIds[i]));
            }
            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text  = "Show info about Objects (right click to close)";
            infoWindow.Width = 620;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();

            return(false);
        }
Example #35
0
        public ICollection <Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            List <Packet> packets = new List <Packet>();

            int       index          = 0;
            int       currentVersion = -1;
            int       counter        = 0;
            string    line           = null;
            Packet    pak            = null;
            PacketLog log            = new PacketLog();
            ArrayList badLines       = new ArrayList();

            byte[] data;

            using (StreamReader s = new StreamReader(stream, Encoding.ASCII))
            {
                while ((line = s.ReadLine()) != null)
                {
                    try
                    {
                        if (callback != null && (counter++ & 0x1FFF) == 0)                         // update progress every 8k lines
                        {
                            callback((int)(stream.Position >> 10),
                                     (int)(stream.Length >> 10));
                        }

                        if (line.Length < 1)
                        {
                            continue;
                        }

//						if (line.IndexOf("DOL.GS.PacketHandler.GSUDPPacketOut") >= 0)
                        if (line.IndexOf("GSUDPPacketOut") >= 0)
                        {
                            data = ReadPacketData(s);
                            if (data.Length < 5)
                            {
                                continue;
                            }
                            pak           = new Packet(data.Length - 5);
                            pak.Protocol  = ePacketProtocol.UDP;
                            pak.Code      = (byte)data[4];
                            pak.Direction = ePacketDirection.ServerToClient;
                            pak.Time      = ParseTime(line);
                            pak.Write(data, 5, data.Length - 5);
                        }
//						else if (line.IndexOf("DOL.GS.PacketHandler.GSTCPPacketOut") >= 0)
                        else if (line.IndexOf("GSTCPPacketOut") >= 0)
                        {
                            data = ReadPacketData(s);
                            if (data.Length < 3)
                            {
                                continue;
                            }
                            pak           = new Packet(data.Length - 3);
                            pak.Protocol  = ePacketProtocol.TCP;
                            pak.Code      = (byte)data[2];
                            pak.Direction = ePacketDirection.ServerToClient;
                            pak.Time      = ParseTime(line);
                            pak.Write(data, 3, data.Length - 3);
                        }
//						else if (line.IndexOf("DOL.GS.PacketHandler.GSPacketIn") >= 0)
                        else if (line.IndexOf("GSPacketIn:") >= 0)
                        {
                            int code = line.IndexOf(" ID=0x");
                            if (code >= 0 && Util.ParseHexFast(line, code + 6, 2, out code))
                            {
                                data          = ReadPacketData(s);
                                pak           = new Packet(data.Length);
                                pak.Protocol  = ePacketProtocol.TCP;                                // can't detect protocol
                                pak.Direction = ePacketDirection.ClientToServer;
                                pak.Code      = (byte)code;
                                pak.Time      = ParseTime(line);
                                pak.Write(data, 0, data.Length);
                            }
                            else
                            {
                                badLines.Add("not GSPacketIn?  : " + line);
                                continue;
                            }
                        }
                        else if ((index = line.IndexOf("Client crash (Version")) >= 0)
                        {
                            int len = "Client crash (Version".Length;
                            if (!Util.ParseDecFast(line, index + len, 3, out currentVersion))
                            {
                                currentVersion = -1;
                            }
                            continue;
                        }
                        else if ((index = line.IndexOf("templogger - Version")) >= 0)
                        {
                            int len = "templogger - Version".Length;
                            if (!Util.ParseDecFast(line, index + len, 3, out currentVersion))
                            {
                                currentVersion = -1;
                            }
                            continue;
                        }
                        else
                        {
                            continue;
                        }

                        pak = PacketManager.ChangePacketClass(pak, currentVersion);
                        pak.AllowClassChange = false;
                        packets.Add(pak);
                    }
                    catch (Exception e)
                    {
//						MessageBox.Show(e.ToString());
                        badLines.Add(e.GetType().FullName + ": " + line);
                    }
                }
            }

            if (badLines.Count > 0)
            {
                StringBuilder str = new StringBuilder("error parsing following lines (" + badLines.Count + "):\n\n");
                int           i   = 0;
                foreach (string s in badLines)
                {
                    str.Append(s).Append('\n');
                    if (++i > 15)
                    {
                        str.Append("...\n").Append(badLines.Count - i).Append(" lines more.\n");
                        break;
                    }
                }
                Log.Info(str.ToString());
            }

            return(packets);
        }
        public ICollection<Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            int counter = 0;
            string line = null;
            Packet pak = null;
            PacketLog log = new PacketLog();
            int dataBytesCount = -1;
            ArrayList ignoredPacketHeaders = new ArrayList();
            string header = "";

            using(StreamReader s = new StreamReader(stream, Encoding.ASCII))
            {
                try
                {
                    while ((line = s.ReadLine()) != null)
                    {
                        if (callback != null && (counter++ & 0x1FFF) == 0) // update progress every 8k lines
                            callback((int)(stream.Position>>10),
                                     (int)(stream.Length>>10));

                        if (line.Length < 1) continue;

                        if (line[0] == '<')
                        {
                            if (pak != null)
                            {
                                if (pak.Length == dataBytesCount)
                                {
                                    /// Completed packet!

                                    try { pak.InitLog(log); }
                                    catch {}
                                }
                                else
                                {
                                    ignoredPacketHeaders.Add(header);
                                }
                            }

                            header = line;

                            try
                            {
                                int code;
                                ePacketDirection dir;
                                ePacketProtocol prot;
                                TimeSpan time;
                                dataBytesCount = DaocLoggerV3TextLogReader.ParseHeader(line, out code, out dir, out prot, out time);

                                if (dataBytesCount < 0)
                                {
                                    pak = null;
                                    ignoredPacketHeaders.Add(header);
                                }
                                else
                                {
                                    // header parsed successfully!
                                    if (code == 0xa9)
                                    {
                                        packetsCount++; // get statistics
                                        pak = null; // ignore the data
                                    }
                                    continue;

            /*									pak = PacketManager.CreatePacket(log.Version, code, dir, dataBytesCount);
                                    pak.Code = code;
                                    pak.Direction = dir;
                                    pak.Protocol = prot;
                                    pak.Time = time;*/
                                }
                            }
                            catch
                            {
                                pak = null;
                                ignoredPacketHeaders.Add(header);
                            }

                            continue;
                        }

                        if (pak == null)
                            continue;

                        DaocLoggerV3TextLogReader.ParseDataLine(line, pak);
                    }
                }
                catch (Exception e)
                {
                    Log.Error("reading file", e);
                }

                if (pak != null)
                {
                    if (pak.Length == dataBytesCount)
                    {
                        // last completed packet!

                    }
                    else
                    {
                        ignoredPacketHeaders.Add(header);
                    }
                }
            }

            if (ignoredPacketHeaders.Count > 0)
            {
                StringBuilder ignored = new StringBuilder("Ignored packets: "+ignoredPacketHeaders.Count+"\n\n");
                for (int i = 0; i < ignoredPacketHeaders.Count; i++)
                {
                    string s = (string)ignoredPacketHeaders[i];
                    ignored.Append('\n').Append(s);
                    if (i > 15)
                    {
                        ignored.Append("\n...");
                        break;
                    }
                }
                Log.Info(ignored.ToString());
            }

            return new List<Packet>(0);
        }
        private void CheckItemsHitsBonus(PacketLog log, int selectedIndex, StringBuilder str, ref int bonusHits, ref int bonusHitCap, ref int bonusPower, ref int bonusPowerPool, ref int bonusPowerPoolCap)
        {
            SortedList m_inventoryItems = new SortedList();
            int VisibleSlots = 0xFF;
            for (int i = 0; i <= selectedIndex; i++)
            {
                Packet pak = log[i];
                if (pak is StoC_0x20_PlayerPositionAndObjectID_171)
                {
                    VisibleSlots = 0xFF;
                    m_inventoryItems.Clear();
                }
                else if (pak is StoC_0x02_InventoryUpdate)
                {
                    StoC_0x02_InventoryUpdate invPack = (StoC_0x02_InventoryUpdate)pak;
                    if ((invPack.PreAction >= 0 && invPack.PreAction <= 1) || (invPack.PreAction >= 10 && invPack.PreAction <= 11))
                    {
                        VisibleSlots = invPack.VisibleSlots;
                    }
                    if ((invPack.PreAction >= 0 && invPack.PreAction <= 2) || (invPack.PreAction >= 10 && invPack.PreAction <= 12))
                    {
                        for (int j = 0; j < invPack.SlotsCount; j++)
                        {
                            StoC_0x02_InventoryUpdate.Item item = (StoC_0x02_InventoryUpdate.Item)invPack.Items[j];
                            if (item.slot >= 10 && item.slot < 40) // Only equiped slot
                            {
                                if (item.name == null || item.name == "")
                                {
                                    if (m_inventoryItems.ContainsKey(item.slot))
                                        m_inventoryItems.Remove(item.slot);
                                }
                                else
                                {
                                    m_inventoryItems[item.slot] = new BonusItem(item);
                                }
                            }
                        }
                    }
                }
            }

            for (int i = 0; i < log.Count; i++)
            {
                Packet pak = log[i];
                if (pak is StoC_0xC4_CustomTextWindow)
                {
                    foreach (BonusItem item in m_inventoryItems.Values)
                    {
                        if (item.slot < 40)
                        {
                            if (item.slot >= 10 && item.slot <= 13)
                            {
                                if (!(((item.slot - 10) == (VisibleSlots & 0x0F)) || ((item.slot - 10) == ((VisibleSlots >> 4) & 0x0F))))
                                    continue;
                            }
                            if (item.delvePack == null && item.name == (pak as StoC_0xC4_CustomTextWindow).Caption)
                            {
                                item.delvePack = pak as StoC_0xC4_CustomTextWindow;
                            }
                        }
                    }
                }
            }
            foreach (BonusItem item in m_inventoryItems.Values)
            {
                if (item.slot < 40)
                {
                    if (item.slot >= 10 && item.slot <= 13)
                    {
                        if (!(((item.slot - 10) == (VisibleSlots & 0x0F)) || ((item.slot - 10) == ((VisibleSlots >> 4) & 0x0F))))
                            continue;
                    }
                    str.AppendFormat("\nslot:{0,-3} objectType:0x{1:X2} \"{2}\" ({3})",
                        item.slot, item.objectType, item.name, (StoC_0x02_InventoryUpdate.eObjectType)item.objectType);
                    if (item.delvePack == null)
                        str.Append(" - delve not found");
                    else
                    {
                        int flagDelveShowed = 0;
                        bool flagArtifact = false;
                        for (int i = 0; i < item.delvePack.Lines.Length; i++)
                        {
                            StoC_0xC4_CustomTextWindow.LineEntry line = item.delvePack.Lines[i];
                            string text = line.text;
                            if (flagArtifact)
                            {
                                int artLevelDescBegin = line.text.IndexOf("[L");
                                if (artLevelDescBegin >= 0)
                                {
                                    text = line.text.Substring(0, artLevelDescBegin) + line.text.Substring(line.text.IndexOf("]: ") + 3);
                                }
                            }
                            if (line.text.StartsWith("Artifact (Current level:"))
                            {
                                flagArtifact = true;
                            }
                            else if (text.StartsWith("- Hits: "))
                            {
                                if (flagDelveShowed++ > 0)
                                    str.Append(',');
                                str.Append(' ');
                                str.Append(line.text);
                                bonusHits += int.Parse(text.Substring(8, text.IndexOf(" pts") - 8));
                            }
                            else if (text.StartsWith("Bonus to hit points bonus cap:"))
                            {
                                if (flagDelveShowed++ > 0)
                                    str.Append(',');
                                str.Append(' ');
                                str.Append(line.text);
                                bonusHitCap += int.Parse(text.Substring(31));
                            }
                            else if (text.StartsWith("- Power: "))
                            {
                                if (flagDelveShowed++ > 0)
                                    str.Append(',');
                                str.Append(' ');
                                str.Append(line.text);
                                if (text.IndexOf(" % of power pool") >= 0)
                                    bonusPowerPool += int.Parse(text.Substring(9, text.IndexOf(" % of power pool") - 9));
                                else if (text.IndexOf(" pts") >= 0)
                                    bonusPower += int.Parse(text.Substring(9, text.IndexOf(" pts") - 9));
                            }
                        }
                    }
                }
            }
        }
        private string MakeOidInfo(PacketLog log, int selectedIndex, ushort objectId, ushort sessionId)
        {
            StringBuilder str = new StringBuilder();
            int maxPacketsLookBackForGetCoords = 50; // look back in log max 30 packets for find coords after found obejct creation packet
            bool fullInfoFound = false;
            bool flagPacketMove = false;
            bool flagPacketItem = false;
            bool flagPacketRide = false;
            bool flagPacketEquip = false;
            bool flagPacketGuild = false;
            bool flagPacketPet = false;
            bool flagPacketDialog = false;
            bool flagVisualEffect = false;
            bool flagPacketMobCreate = false;
            CtoS_0xA9_PlayerPosition lastSelfCoords = null;
            LocalCoords lastObjectCoords = null;
            LocalCoords regionGlobalCoords = null;
            LocalCoords firstSelfCoords = null;
            //			Packet lastObjectCoords = null;
            string objectType = "";
            for (int i = selectedIndex; i >= 0; i--)
            {
                Packet pak = log[i];
                if (fullInfoFound)
                    maxPacketsLookBackForGetCoords--;
                if (pak is StoC_0x20_PlayerPositionAndObjectID) // stop scanning packets on enter region
                {
                    if ((pak as StoC_0x20_PlayerPositionAndObjectID).PlayerOid == objectId)
                        objectType = " (Self)";
            //					str.Insert(0, pak.ToHumanReadableString(TimeSpan(0), true) + '\n');
                    regionGlobalCoords = new LocalCoords((pak as StoC_0x20_PlayerPositionAndObjectID).X, (pak as StoC_0x20_PlayerPositionAndObjectID).Y, (pak as StoC_0x20_PlayerPositionAndObjectID).Z);
                    break;
                }
                else if (!fullInfoFound && pak is StoC_0xD4_PlayerCreate)
                {
                    if ((pak as StoC_0xD4_PlayerCreate).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (player)";
                        fullInfoFound = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD4_PlayerCreate).ZoneX, (pak as StoC_0xD4_PlayerCreate).ZoneY, (pak as StoC_0xD4_PlayerCreate).ZoneZ, (ushort)(pak as StoC_0xD4_PlayerCreate).ZoneId);
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x4B_PlayerCreate_172)
                {
                    if ((pak as StoC_0x4B_PlayerCreate_172).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (player)";
                        fullInfoFound = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0x4B_PlayerCreate_172).ZoneX, (pak as StoC_0x4B_PlayerCreate_172).ZoneY, (pak as StoC_0x4B_PlayerCreate_172).ZoneZ, (pak as StoC_0x4B_PlayerCreate_172).ZoneId);
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xDA_NpcCreate)
                {
                    if (!flagPacketMobCreate && (pak as StoC_0xDA_NpcCreate).Oid == objectId)
                    {
                        flagPacketMobCreate = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (NPC)";
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xDA_NpcCreate).X, (pak as StoC_0xDA_NpcCreate).Y, (pak as StoC_0xDA_NpcCreate).Z);
            //						fullInfoFound = true; // need find 0x20 for get gloc region
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x6C_KeepComponentOverview)
                {
                    if ((pak as StoC_0x6C_KeepComponentOverview).Uid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (KeepComponent)";
                        fullInfoFound = true;
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xD9_ItemDoorCreate)
                {
                    if (!flagPacketItem && (pak as StoC_0xD9_ItemDoorCreate).Oid == objectId)
                    {
                        flagPacketItem = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if ((pak as StoC_0xD9_ItemDoorCreate).ExtraBytes == 4)
                            objectType = " (Door)";
                        else
                            objectType = " (Object)";
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD9_ItemDoorCreate).X, (pak as StoC_0xD9_ItemDoorCreate).Y, (pak as StoC_0xD9_ItemDoorCreate).Z);
            //						fullInfoFound = true; // need find 0x20 for get gloc region
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x12_CreateMovingObject)
                {
                    if ((pak as StoC_0x12_CreateMovingObject).ObjectOid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (MovingObject)";
                        fullInfoFound = true;
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xC8_PlayerRide) // show object if rided
                {
                    if (!flagPacketRide && (pak as StoC_0xC8_PlayerRide).RiderOid == objectId)
                    {
                        flagPacketRide = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                    else if ((pak as StoC_0xC8_PlayerRide).MountOid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x15_EquipmentUpdate)
                {
                    if (!flagPacketEquip && (pak as StoC_0x15_EquipmentUpdate).Oid == objectId)
                    {
                        flagPacketEquip = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xEE_NpcChangeProperties)
                {
                    if ((pak as StoC_0xEE_NpcChangeProperties).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xDE_SetObjectGuildId)
                {
                    if (!flagPacketGuild && (pak as StoC_0xDE_SetObjectGuildId).Oid == objectId)
                    {
                        flagPacketGuild = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xA1_NpcUpdate)
                {
                    if (!flagPacketMove && (pak as StoC_0xA1_NpcUpdate).NpcOid == objectId)
                    {
                        flagPacketMove = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xA1_NpcUpdate).CurrentZoneX, (pak as StoC_0xA1_NpcUpdate).CurrentZoneY, (pak as StoC_0xA1_NpcUpdate).CurrentZoneZ, (pak as StoC_0xA1_NpcUpdate).CurrentZoneId);
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x81_ShowDialog)
                {
                    if (!flagPacketDialog && (pak as StoC_0x81_ShowDialog).ObjectIds != null && (pak as StoC_0x81_ShowDialog).ObjectIds.Length > 0 && (pak as StoC_0x81_ShowDialog).ObjectIds[0] == objectId)
                    {
                        flagPacketDialog = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0xA9_PlayerPosition)
                {
                    if (!flagPacketMove && (pak as StoC_0xA9_PlayerPosition).SessionId == sessionId)
                    {
                        flagPacketMove = true;
                        if (lastObjectCoords == null)
                            lastObjectCoords = new LocalCoords((pak as StoC_0xA9_PlayerPosition).CurrentZoneX, (pak as StoC_0xA9_PlayerPosition).CurrentZoneY, (pak as StoC_0xA9_PlayerPosition).CurrentZoneZ, (pak as StoC_0xA9_PlayerPosition).CurrentZoneId);
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x88_PetWindowUpdate)
                {
                    if (!flagPacketPet && (pak as StoC_0x88_PetWindowUpdate).PetId == objectId)
                    {
                        flagPacketPet = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (!fullInfoFound && pak is StoC_0x4C_VisualEffect)
                {
                    if (!flagVisualEffect && (pak as StoC_0x4C_VisualEffect).Oid == objectId)
                    {
                        flagVisualEffect = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    if (firstSelfCoords == null)
                    {
                        firstSelfCoords = new LocalCoords((pak as CtoS_0xA9_PlayerPosition).CurrentZoneX, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ, 0xFFFF);
                    }
                    else
                    {
                        firstSelfCoords.CurrentZoneX = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneX;
                        firstSelfCoords.CurrentZoneY = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY;
                        firstSelfCoords.CurrentZoneZ = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ;
                    }

                    if (lastSelfCoords == null)
                    {
                        lastSelfCoords = pak as CtoS_0xA9_PlayerPosition;
                    }
                }
                // if we found object creation packets and both coords (self and object) then break;
                // if we found object creation packets but not find any coords break after maxPacketsLookBackForGetCoords look back
                if (fullInfoFound && ((lastObjectCoords != null && lastSelfCoords != null) || maxPacketsLookBackForGetCoords <= 0))
                    break;
            }
            if (!fullInfoFound)
                str.Insert(0, "No more info found\n");
            // TODO add zone checks... (mb recalc in global coords if zones is different ?)
            if (lastSelfCoords != null && lastObjectCoords != null && lastSelfCoords.CurrentZoneId == lastObjectCoords.CurrentZoneId)
            {
                long xdiff = (long)lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc)\n", range));
            }
            else if (lastSelfCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF && regionGlobalCoords != null && firstSelfCoords != null) /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc)\n", range));
            //				str.Insert(0, string.Format("Your gloc:(x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY));
            }
            else if (regionGlobalCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF) /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)regionGlobalCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc)\n", range));
            }
            str.Insert(0, string.Format("\nobjectId:0x{0:X4}{1}\n", objectId, objectType));
            return str.ToString();
        }
        private string MakeOidInfo(PacketLog log, int selectedIndex, ushort objectId, ushort sessionId, ushort keepId)
        {
            StringBuilder str = new StringBuilder();
            int           maxPacketsLookBackForGetCoords = 100000;   // look back in log max 30 packets for find coords after found obejct creation packet
            bool          fullInfoFound               = false;
            bool          flagPacketMove              = false;
            bool          flagPacketCreationRequest   = false;
            bool          flagPacketItem              = false;
            bool          flagPacketRide              = false;
            bool          flagPacketEquip             = false;
            bool          flagPacketGuild             = false;
            bool          flagPacketPet               = false;
            bool          flagPacketDialog            = false;
            bool          flagVisualEffect            = false;
            bool          flagPacketMobCreate         = false;
            bool          flagPacketCombatAnimation   = false;
            bool          flagAllowGetFirstSelfCoords = true;
            ushort        selfId                = 0;
            Hashtable     ObjectsOnMount        = null;
            BitArray      m_packetsBitArrayStoC = new BitArray(255);

            m_packetsBitArrayStoC.SetAll(false);
            BitArray m_packetsBitArrayCtoS = new BitArray(255);

            m_packetsBitArrayCtoS.SetAll(false);
            CtoS_0xA9_PlayerPosition lastSelfCoords = null;
            LocalCoords lastObjectCoords            = null;
            LocalCoords regionGlobalCoords          = null;
            LocalCoords firstSelfCoords             = null;
//			Packet lastObjectCoords = null;
            string objectType = "";

            for (int i = selectedIndex; i >= 0; i--)
            {
                Packet pak = log[i];
                if (fullInfoFound)
                {
                    maxPacketsLookBackForGetCoords--;
                }
                if (pak is StoC_0x20_PlayerPositionAndObjectID)                 // stop scanning packets on enter region
                {
                    if ((pak as StoC_0x20_PlayerPositionAndObjectID).PlayerOid == objectId)
                    {
                        objectType = " (Self)";
                    }
//					str.Insert(0, pak.ToHumanReadableString(TimeSpan(0), true) + '\n');
                    if (regionGlobalCoords == null)                     // skip if gloc Jump
                    {
                        regionGlobalCoords = new LocalCoords((pak as StoC_0x20_PlayerPositionAndObjectID).X, (pak as StoC_0x20_PlayerPositionAndObjectID).Y, (pak as StoC_0x20_PlayerPositionAndObjectID).Z);
                    }
                    flagAllowGetFirstSelfCoords = false;
                    break;
                }
                else if (pak is StoC_0x04_CharacterJump)
                {
#warning TODO: Rewrite for find self Oid
                    if ((pak as StoC_0x04_CharacterJump).PlayerOid == selfId)
                    {
                        regionGlobalCoords          = new LocalCoords((pak as StoC_0x04_CharacterJump).X, (pak as StoC_0x04_CharacterJump).Y, (pak as StoC_0x04_CharacterJump).Z);
                        flagAllowGetFirstSelfCoords = false;
                        if (lastSelfCoords != null)
                        {
                            if (firstSelfCoords == null)
                            {
                                firstSelfCoords = new LocalCoords(lastSelfCoords.CurrentZoneX, lastSelfCoords.CurrentZoneY, lastSelfCoords.CurrentZoneZ, 0xFFFF);
                            }
                            else
                            {
                                firstSelfCoords.CurrentZoneX = lastSelfCoords.CurrentZoneX;
                                firstSelfCoords.CurrentZoneY = lastSelfCoords.CurrentZoneY;
                                firstSelfCoords.CurrentZoneZ = lastSelfCoords.CurrentZoneZ;
                            }
                        }
//						break;
                    }
                }
                else if (pak is StoC_0xD4_PlayerCreate)
                {
                    if (!fullInfoFound && (pak as StoC_0xD4_PlayerCreate).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType    = " (player)";
                        fullInfoFound = true;
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD4_PlayerCreate).ZoneX, (pak as StoC_0xD4_PlayerCreate).ZoneY, (pak as StoC_0xD4_PlayerCreate).ZoneZ, (ushort)(pak as StoC_0xD4_PlayerCreate).ZoneId);
                        }
                    }
                }
                else if (pak is StoC_0x4B_PlayerCreate_172)
                {
                    if (!fullInfoFound && (pak as StoC_0x4B_PlayerCreate_172).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType    = " (player)";
                        fullInfoFound = true;
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0x4B_PlayerCreate_172).ZoneX, (pak as StoC_0x4B_PlayerCreate_172).ZoneY, (pak as StoC_0x4B_PlayerCreate_172).ZoneZ, (pak as StoC_0x4B_PlayerCreate_172).ZoneId);
                        }
                    }
                }
                else if (pak is StoC_0xDA_NpcCreate)
                {
                    if (!fullInfoFound && !flagPacketMobCreate && (pak as StoC_0xDA_NpcCreate).Oid == objectId)
                    {
                        flagPacketMobCreate = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (NPC)";
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0xDA_NpcCreate).X, (pak as StoC_0xDA_NpcCreate).Y, (pak as StoC_0xDA_NpcCreate).Z);
                        }
//						fullInfoFound = true; // need find 0x20 for get gloc region
                    }
                }
                else if (pak is StoC_0xD9_ItemDoorCreate)
                {
                    if (!fullInfoFound && !flagPacketItem && (pak as StoC_0xD9_ItemDoorCreate).Oid == objectId)
                    {
                        flagPacketItem = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if ((pak as StoC_0xD9_ItemDoorCreate).ExtraBytes == 4)
                        {
                            objectType = " (Door)";
                        }
                        else
                        {
                            objectType = " (Object)";
                        }
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD9_ItemDoorCreate).X, (pak as StoC_0xD9_ItemDoorCreate).Y, (pak as StoC_0xD9_ItemDoorCreate).Z);
                        }
//						fullInfoFound = true; // need find 0x20 for get gloc region
                    }
                }
                else if (pak is StoC_0x12_CreateMovingObject)
                {
                    if (!fullInfoFound && (pak as StoC_0x12_CreateMovingObject).ObjectOid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType    = " (MovingObject)";
                        fullInfoFound = true;
                    }
                }
                else if (pak is StoC_0xC8_PlayerRide)                 // show object if rided
                {
                    if (!fullInfoFound && !flagPacketRide && (pak as StoC_0xC8_PlayerRide).RiderOid == objectId)
                    {
                        flagPacketRide = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                    else if ((pak as StoC_0xC8_PlayerRide).MountOid == objectId)
                    {
                        if (ObjectsOnMount == null)
                        {
                            ObjectsOnMount = new Hashtable();
                        }
                        if (!ObjectsOnMount.ContainsKey((pak as StoC_0xC8_PlayerRide).Slot))
                        {
                            ObjectsOnMount.Add((pak as StoC_0xC8_PlayerRide).Slot, (ushort)(pak as StoC_0xC8_PlayerRide).RiderOid);
                            str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        }
                    }
                }
                else if (pak is StoC_0x15_EquipmentUpdate)
                {
                    if (!fullInfoFound && !flagPacketEquip && (pak as StoC_0x15_EquipmentUpdate).Oid == objectId)
                    {
                        flagPacketEquip = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xEE_NpcChangeProperties)
                {
                    if (!fullInfoFound && (pak as StoC_0xEE_NpcChangeProperties).Oid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xDE_SetObjectGuildId)
                {
                    if (!fullInfoFound && !flagPacketGuild && (pak as StoC_0xDE_SetObjectGuildId).Oid == objectId)
                    {
                        flagPacketGuild = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xA1_NpcUpdate)
                {
                    if (!fullInfoFound && !flagPacketMove && (pak as StoC_0xA1_NpcUpdate).NpcOid == objectId)
                    {
                        flagPacketMove = true;
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0xA1_NpcUpdate).CurrentZoneX, (pak as StoC_0xA1_NpcUpdate).CurrentZoneY, (pak as StoC_0xA1_NpcUpdate).CurrentZoneZ, (pak as StoC_0xA1_NpcUpdate).CurrentZoneId);
                        }
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x81_ShowDialog)
                {
                    if (!fullInfoFound && !flagPacketDialog && (pak as StoC_0x81_ShowDialog).ObjectIds != null && (pak as StoC_0x81_ShowDialog).ObjectIds.Length > 0 && (pak as StoC_0x81_ShowDialog).ObjectIds[0] == objectId)
                    {
                        flagPacketDialog = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0xA9_PlayerPosition)
                {
                    if (!flagPacketMove && (pak as StoC_0xA9_PlayerPosition).SessionId == sessionId)
                    {
                        if (!fullInfoFound)
                        {
                            flagPacketMove = true;
                            if (lastObjectCoords == null)
                            {
                                lastObjectCoords = new LocalCoords((pak as StoC_0xA9_PlayerPosition).CurrentZoneX, (pak as StoC_0xA9_PlayerPosition).CurrentZoneY, (pak as StoC_0xA9_PlayerPosition).CurrentZoneZ, (pak as StoC_0xA9_PlayerPosition).CurrentZoneId);
                            }
                        }
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x88_PetWindowUpdate)
                {
                    if (!fullInfoFound && !flagPacketPet && (pak as StoC_0x88_PetWindowUpdate).PetId == objectId)
                    {
                        flagPacketPet = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x4C_VisualEffect)
                {
                    if (!fullInfoFound && !flagVisualEffect && (pak as StoC_0x4C_VisualEffect).Oid == objectId)
                    {
                        flagVisualEffect = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    if (flagAllowGetFirstSelfCoords)
                    {
                        if (firstSelfCoords == null)
                        {
                            firstSelfCoords = new LocalCoords((pak as CtoS_0xA9_PlayerPosition).CurrentZoneX, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ, 0xFFFF);
                        }
                        else
                        {
                            firstSelfCoords.CurrentZoneX = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneX;
                            firstSelfCoords.CurrentZoneY = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY;
                            firstSelfCoords.CurrentZoneZ = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ;
                        }
                    }

                    if (lastSelfCoords == null)
                    {
                        lastSelfCoords = pak as CtoS_0xA9_PlayerPosition;
                    }
                }
                else if (pak is CtoS_0xBE_NpcCreationRequest)
                {
                    if (!flagPacketCreationRequest && (pak as CtoS_0xBE_NpcCreationRequest).NpcOid == objectId)
                    {
                        flagPacketCreationRequest = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x69_KeepOverview)
                {
                    if ((pak as StoC_0x69_KeepOverview).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0x69_KeepOverview).KeepX, (pak as StoC_0x69_KeepOverview).KeepY);
                        }
                    }
                }
                else if (pak is StoC_0x61_KeepRepair)
                {
                    if (!fullInfoFound && (pak as StoC_0x61_KeepRepair).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x62_KeepClaim)
                {
                    if (!fullInfoFound && (pak as StoC_0x62_KeepClaim).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x67_KeepUpdate)
                {
                    if (!fullInfoFound && (pak as StoC_0x67_KeepUpdate).KeepId == keepId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x6C_KeepComponentOverview)
                {
                    if (!fullInfoFound && (pak as StoC_0x6C_KeepComponentOverview).KeepId == keepId)
//					if (!fullInfoFound && (pak as StoC_0x6C_KeepComponentOverview).Uid == objectId)
                    {
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        objectType = " (KeepComponent)";
//						fullInfoFound = true;
                    }
                }
                else if (pak is StoC_0xBC_CombatAnimation)
                {
                    if (!fullInfoFound && !flagPacketCombatAnimation && ((pak as StoC_0xBC_CombatAnimation).AttackerOid == objectId || (pak as StoC_0xBC_CombatAnimation).DefenderOid == objectId))
                    {
                        flagPacketCombatAnimation = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else
                {
                    if (pak is IObjectIdPacket)                                        // all other packet's with OID
                    {
                        if (!(fullInfoFound || flagPacketMobCreate || flagPacketItem)) // not show packet's before creation object packet
                        {
                            if ((pak.Direction == ePacketDirection.ServerToClient && !m_packetsBitArrayStoC[pak.Code]) ||
                                (pak.Direction == ePacketDirection.ClientToServer && !m_packetsBitArrayCtoS[pak.Code]))
                            {
                                ushort[] objectIds = (pak as IObjectIdPacket).ObjectIds;
                                if (objectIds != null && objectIds.Length > 0)
                                {
                                    for (int j = 0; j < objectIds.Length; j++)
                                    {
                                        if (objectIds[j] > 0 && objectIds[j] == objectId)
                                        {
                                            str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                                            if (pak.Direction == ePacketDirection.ServerToClient)
                                            {
                                                m_packetsBitArrayStoC[pak.Code] = true;
                                            }
                                            else if (pak.Direction == ePacketDirection.ClientToServer)
                                            {
                                                m_packetsBitArrayCtoS[pak.Code] = true;
                                            }
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                // if we found object creation packets and both coords (self and object) then break;
                // if we found object creation packets but not find any coords break after maxPacketsLookBackForGetCoords look back
                if (fullInfoFound && ((lastObjectCoords != null && lastSelfCoords != null) || maxPacketsLookBackForGetCoords <= 0))
                {
                    break;
                }
            }
//			if (!fullInfoFound)
//				str.Insert(0, "No more info found\n");
            // TODO add zone checks... (mb recalc in global coords if zones is different ?)
            {
                if (regionGlobalCoords != null)
                {
                    str.Insert(0, string.Format("regionGlobalCoords (x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY));
                }
                if (firstSelfCoords != null)
                {
                    str.Insert(0, string.Format("firstSelfCoords (x:{0} y:{1})\n", firstSelfCoords.CurrentZoneX, firstSelfCoords.CurrentZoneY));
                }
                if (lastSelfCoords != null)
                {
                    str.Insert(0, string.Format("lastSelfCoords (x:{0} y:{1})\n", lastSelfCoords.CurrentZoneX, lastSelfCoords.CurrentZoneY));
                }
                if (lastObjectCoords != null)
                {
                    str.Insert(0, string.Format("lastObjectCoords (x:{0} y:{1})\n", lastObjectCoords.CurrentZoneX, lastObjectCoords.CurrentZoneY));
                }
            }
            if (lastSelfCoords != null && lastObjectCoords != null && lastSelfCoords.CurrentZoneId == lastObjectCoords.CurrentZoneId)
            {
                long xdiff = (long)lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int  range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc/loc)\n", range));
            }
            else if (lastSelfCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF && regionGlobalCoords != null && firstSelfCoords != null)             /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = 0;
                if (lastObjectCoords.CurrentZoneZ != 0xFFFF)
                {
                    zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                }
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc/gloc)\n", range));
                str.Insert(0, string.Format("Your gloc:(x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY));
            }
            else if (regionGlobalCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF)             /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = 0;
                if (lastObjectCoords.CurrentZoneZ != 0xFFFF)
                {
                    zdiff = (long)regionGlobalCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                }
                int range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc/gloc)\n", range));
            }
            if (objectId != 0xFFFF)
            {
                str.Insert(0, string.Format("\nobjectId:0x{0:X4}{1}\n", objectId, objectType));
            }
            return(str.ToString());
        }
        /// <summary>
        /// Loads the files.
        /// </summary>
        /// <param name="reader">The log reader.</param>
        /// <param name="logs">The list to add open logs to.</param>
        /// <param name="files">The files too open.</param>
        /// <param name="initialVersion">The initial log version.</param>
        /// <param name="ignoreVersionChanges">If set to <c>true</c> version information in the log is ignored.</param>
        /// <param name="progress">The progress.</param>
        private void LoadFiles(ILogReader reader,
            ICollection<PacketLog> logs,
            string[] files,
            float initialVersion,
            bool ignoreVersionChanges,
            ProgressCallback progress)
        {
            foreach (string fileName in files)
            {
                try
                {
                    // Create new log for each file
                    PacketLog log = new PacketLog();
                    log.Version = initialVersion;
                    log.IgnoreVersionChanges = ignoreVersionChanges;

                    m_progress.SetDescription("Loading file: " + fileName + "...");

                    // Check if file exists
                    FileInfo fileInfo = new FileInfo(fileName);
                    if (!fileInfo.Exists)
                    {
                        Log.Info("File \"" + fileInfo.FullName + "\" doesn't exist, ignored.");
                        continue;
                    }

                    // Add all packets
                    using(FileStream stream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        log.AddRange(reader.ReadLog(new BufferedStream(stream, 64*1024), progress));
                    }

                    // Initialize log
                    m_progress.SetDescription("Initializing log and packets...");
                    log.Init(LogManager, 3, progress);

                    // Set stream name
                    log.StreamName = fileInfo.FullName;

                    AddRecentFile(fileInfo.FullName);
                    logs.Add(log);
                }
                catch (Exception e)
                {
                    Log.Error("loading files", e);
                }
            }
        }
        private string MakeHidInfo(PacketLog log, int selectedIndex, ushort houseId)
        {
            StringBuilder            str            = new StringBuilder();
            CtoS_0xA9_PlayerPosition lastSelfCoords = null;
            LocalCoords lastObjectCoords            = null;
            LocalCoords regionGlobalCoords          = null;
            LocalCoords firstSelfCoords             = null;
            bool        flagInteriorFound           = false;
            bool        flagInsideUpdateFound       = false;
            bool        flagExteriorFound           = false;
            bool        flagHouseFound = false;

            for (int i = selectedIndex; i >= 0; i--)
            {
                Packet pak = log[i];
                if (pak is StoC_0x20_PlayerPositionAndObjectID)                 // stop scanning packets on enter region
                {
                    regionGlobalCoords = new LocalCoords((pak as StoC_0x20_PlayerPositionAndObjectID).X, (pak as StoC_0x20_PlayerPositionAndObjectID).Y, (pak as StoC_0x20_PlayerPositionAndObjectID).Z);
                    break;
                }
                else if (pak is StoC_0xD1_HouseCreate)
                {
                    if (!flagHouseFound && (pak as StoC_0xD1_HouseCreate).HouseId == houseId)
                    {
                        flagHouseFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                        if (lastObjectCoords == null)
                        {
                            lastObjectCoords = new LocalCoords((pak as StoC_0xD1_HouseCreate).X, (pak as StoC_0xD1_HouseCreate).Y, (pak as StoC_0xD1_HouseCreate).Z);
                        }
                    }
                }
                else if (pak is StoC_0xD2_HouseUpdate)
                {
                    if (!flagExteriorFound && (pak as StoC_0xD2_HouseUpdate).HouseId == houseId && (pak as StoC_0xD2_HouseUpdate).UpdateCode == 0x80)
                    {
                        flagExteriorFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x09_HouseDecorationUpdate)
                {
                    if (!flagInteriorFound && (pak as StoC_0x09_HouseDecorationUpdate).HouseId == houseId && (pak as StoC_0x09_HouseDecorationUpdate).DecorationCode == 0x80)
                    {
                        flagInteriorFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is StoC_0x08_HouseInsideUpdate)
                {
                    if (!flagInsideUpdateFound && (pak as StoC_0x08_HouseInsideUpdate).HouseId == houseId)
                    {
                        flagInsideUpdateFound = true;
                        str.Insert(0, pak.ToHumanReadableString(TimeSpan.Zero, true) + '\n');
                    }
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    if (firstSelfCoords == null)
                    {
                        firstSelfCoords = new LocalCoords((pak as CtoS_0xA9_PlayerPosition).CurrentZoneX, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY, (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ, 0xFFFF);
                    }
                    else
                    {
                        firstSelfCoords.CurrentZoneX = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneX;
                        firstSelfCoords.CurrentZoneY = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneY;
                        firstSelfCoords.CurrentZoneZ = (pak as CtoS_0xA9_PlayerPosition).CurrentZoneZ;
                    }

                    if (lastSelfCoords == null)
                    {
                        lastSelfCoords = pak as CtoS_0xA9_PlayerPosition;
                    }
                }
            }
            str.Insert(0, string.Format("\nhouseId:0x{0:X4}\n", houseId));
            if (lastSelfCoords != null && lastObjectCoords != null && lastSelfCoords.CurrentZoneId == lastObjectCoords.CurrentZoneId)
            {
                long xdiff = (long)lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int  range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (loc)\n", range));
            }
            else if (lastSelfCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF && regionGlobalCoords != null && firstSelfCoords != null)             /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)lastSelfCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int  range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc)\n", range));
//				str.Insert(0, string.Format("Your gloc:(x:{0} y:{1})\n", regionGlobalCoords.CurrentZoneX - firstSelfCoords.CurrentZoneX + lastSelfCoords.CurrentZoneX, regionGlobalCoords.CurrentZoneY - firstSelfCoords.CurrentZoneY + lastSelfCoords.CurrentZoneY));
            }
            else if (regionGlobalCoords != null && lastObjectCoords != null && lastObjectCoords.CurrentZoneId == 0xFFFF)             /* gloc Object */
            {
                long xdiff = (long)regionGlobalCoords.CurrentZoneX - lastObjectCoords.CurrentZoneX;
                long ydiff = (long)regionGlobalCoords.CurrentZoneY - lastObjectCoords.CurrentZoneY;
                long zdiff = (long)regionGlobalCoords.CurrentZoneZ - lastObjectCoords.CurrentZoneZ;
                int  range = (int)Math.Sqrt(xdiff * xdiff + ydiff * ydiff + zdiff * zdiff);
                str.Insert(0, string.Format("range from you:{0} (gloc)\n", range));
            }
            return(str.ToString());
        }
		/// <summary>
		/// Set all log variables from the packet here
		/// </summary>
		/// <param name="log"></param>
		public virtual void InitLog(PacketLog log)
		{
		}
        public ICollection<Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            List<Packet> packets = new List<Packet>((int)(stream.Length / 128));

            int counter = 0;
            Packet pak = null;
            PacketLog log = new PacketLog();
            int dataBytesCount = -1;
            int ignoredCount = 0;
            StringBuilder header = new StringBuilder('<', 64);

            using(BinaryReader s = new BinaryReader(stream, Encoding.ASCII))
            {
                try
                {
                    while (s.BaseStream.Position < s.BaseStream.Length)
                    {
                        if (callback != null && (counter++ & 0xFFF) == 0) // update progress every 4096th packet
                            callback((int)(s.BaseStream.Position>>10), (int)(s.BaseStream.Length>>10));

                        if (s.ReadChar() != '<')
                            continue;

                        if (pak != null)
                        {
                            if (pak.Length == dataBytesCount)
                            {
                                packets.Add(pak);
                                try { pak.InitLog(log); }
                                catch {}
                            }
                            else
                            {
                                ignoredCount++;
                            }
                        }

                        // get the header string
                        header.Length = 1;
                        header.Append(s.ReadChars(48));
                        for(;;)
                        {
                            char curChar = s.ReadChar();
                            if (curChar == '<')
                            {
                                s.BaseStream.Seek(-1, SeekOrigin.Current);
                                break;
                            }
                            header.Append(curChar);
                            if (curChar == '>')
                            {
                                s.BaseStream.Seek(2, SeekOrigin.Current);
                                break;
                            }
                            if (header.Length > 128)
                            {
                                break;
                            }
                        }

                        try
                        {
                            int code;
                            ePacketDirection dir;
                            ePacketProtocol prot;
                            TimeSpan time;
                            dataBytesCount = DaocLoggerV3TextLogReader.ParseHeader(header.ToString(), out code, out dir, out prot, out time);

                            pak = PacketManager.CreatePacket(log.Version, (byte)code, dir, dataBytesCount);
                            pak.Code = (byte)code;
                            pak.Direction = dir;
                            pak.Protocol = prot;
                            pak.Time = time;
                        }
                        catch
                        {
                            pak = null;
                            ignoredCount++;
            //							MessageBox.Show("parse header failed:\nposition="+s.BaseStream.Position+"\n'"+header.ToString()+"'\n");
                        }

                        if (pak == null)
                            continue;

                        byte[] pakData = s.ReadBytes(dataBytesCount);
                        pak.Write(pakData, 0, pakData.Length);
                    }
                }
                catch (Exception e)
                {
                    Log.Error("reading file", e);
                }

                if (pak != null)
                {
                    if (pak.Length == dataBytesCount)
                    {
                        packets.Add(pak);
                    }
                    else
                    {
                        ignoredCount++;
                    }
                }
            }

            if (ignoredCount > 0)
                Log.Info("ignored packets: " + ignoredCount);

            return packets;
        }
        /// <summary>
        /// Clears the log.
        /// </summary>
        /// <param name="packetLog">The packet log.</param>
        public void ClearLog(PacketLog packetLog)
        {
            List<PacketLog> logs = new List<PacketLog>(m_logs);
            packetLog.OnPacketsChanged -= packetLog_OnPacketsChanged;
            logs.Remove(packetLog);
            m_logs = logs.AsReadOnly();

            FirePacketLogsChangedEvent();
        }
 /// <summary>
 /// Set all log variables from the packet here
 /// </summary>
 /// <param name="log"></param>
 public override void InitLog(PacketLog log)
 {
     if (log.SubversionReinit)
         return;
     Position = 2;
     int major = ReadByte();
     int minor = ReadByte();
     int build = ReadByte();
     int version = major*100 + minor*10 + build;
     if (version >= 200)
         version = version + 900;
     log.Version = (float)version;
 }
Example #46
0
        public static SortedList MakeOidList(int selectedIndex, PacketLog log, out int currentRegion, out int currentZone)
        {
            SortedList oidInfo = new SortedList();

            currentRegion = -1;
            currentZone   = -1;
            ushort playerOid = 0;
            string CharName  = "UNKNOWN";

            for (int i = 0; i < selectedIndex; ++i)
            {
                Packet pak = log[i];
                if (pak is StoC_0xD4_PlayerCreate)
                {
                    StoC_0xD4_PlayerCreate player = (StoC_0xD4_PlayerCreate)pak;

                    oidInfo[player.Oid] = new LivingInfo(pak.Time, "PLR", player.Name, player.Level, player.GuildName);
                }
                else if (pak is StoC_0x4B_PlayerCreate_172)
                {
                    StoC_0x4B_PlayerCreate_172 player = (StoC_0x4B_PlayerCreate_172)pak;

                    oidInfo[player.Oid] = new LivingInfo(pak.Time, "PLR", player.Name, player.Level, player.GuildName);
                    if (currentZone == -1)
                    {
                        currentZone = player.ZoneId;
                    }
                }
                else if (pak is StoC_0x12_CreateMovingObject)
                {
                    StoC_0x12_CreateMovingObject obj = (StoC_0x12_CreateMovingObject)pak;

                    oidInfo[obj.ObjectOid] = new ObjectInfo(pak.Time, "MOVE", obj.Name, 0);
                }
                else if (pak is StoC_0x6C_KeepComponentOverview)
                {
                    StoC_0x6C_KeepComponentOverview keep = (StoC_0x6C_KeepComponentOverview)pak;

                    oidInfo[keep.Uid] = new ObjectInfo(pak.Time, "Keep", string.Format("keepId:0x{0:X4} componentId:{1}", keep.KeepId, keep.ComponentId), 0);
                }
                else if (pak is StoC_0xD1_HouseCreate)
                {
                    StoC_0xD1_HouseCreate house = (StoC_0xD1_HouseCreate)pak;

                    oidInfo[house.HouseId] = new ObjectInfo(pak.Time, "HOUS", house.Name, 0);
                }
                else if (pak is StoC_0xDA_NpcCreate)
                {
                    StoC_0xDA_NpcCreate npc = (StoC_0xDA_NpcCreate)pak;

                    oidInfo[npc.Oid] = new LivingInfo(pak.Time, "NPC", npc.Name, npc.Level, npc.GuildName);
                }
                else if (pak is CtoS_0xA9_PlayerPosition)
                {
                    CtoS_0xA9_PlayerPosition plr = (CtoS_0xA9_PlayerPosition)pak;
                    if (currentZone == -1)
                    {
                        currentZone = plr.CurrentZoneId;
                    }
                }
                else if (pak is StoC_0xD9_ItemDoorCreate)
                {
                    StoC_0xD9_ItemDoorCreate item = (StoC_0xD9_ItemDoorCreate)pak;
                    string type = "ITEM";
                    if (item.ExtraBytes > 0)
                    {
                        type = "DOOR";
                    }
                    oidInfo[item.Oid] = new ObjectInfo(pak.Time, type, item.Name, 0);
                }
                else if (pak is StoC_0xB7_RegionChange)
                {
                    StoC_0xB7_RegionChange region = (StoC_0xB7_RegionChange)pak;

//					if (region.RegionId != currentRegion)
//					{
                    currentRegion = region.RegionId;
                    currentZone   = region.ZoneId;
                    oidInfo.Clear();
//					}
                }
                else if (pak is StoC_0x20_PlayerPositionAndObjectID_171)
                {
                    StoC_0x20_PlayerPositionAndObjectID_171 region = (StoC_0x20_PlayerPositionAndObjectID_171)pak;

//					if (region.Region!= currentRegion)
//					{
                    currentRegion = region.Region;
                    oidInfo.Clear();
//					}
                    playerOid = region.PlayerOid;
                    oidInfo[region.PlayerOid] = new LivingInfo(pak.Time, "YOU", CharName, 0, "");
                }
                else if (pak is StoC_0x16_VariousUpdate)
                {
                    if (playerOid != 0)
                    {
                        StoC_0x16_VariousUpdate stat = (StoC_0x16_VariousUpdate)pak;
                        if (stat.SubCode == 3)
                        {
                            StoC_0x16_VariousUpdate.PlayerUpdate subData = (StoC_0x16_VariousUpdate.PlayerUpdate)stat.SubData;
                            if (oidInfo[playerOid] != null)
                            {
                                LivingInfo plr = (LivingInfo)oidInfo[playerOid];
                                plr.level          = subData.playerLevel;
                                plr.guildName      = subData.guildName;
                                oidInfo[playerOid] = plr;
                            }
                        }
                    }
                }
                else if (pak is CtoS_0x10_CharacterSelectRequest)
                {
                    CtoS_0x10_CharacterSelectRequest login = (CtoS_0x10_CharacterSelectRequest)pak;
                    CharName = login.CharName;
                }
            }
            return(oidInfo);
        }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog log           = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int       selectedIndex = selectedPacket.PacketIndex;

            string    serverName          = "UNKNOWN";
            int       serverId            = -1;
            int       serverColorHandling = -1;
            int       sessionId           = -1;
            int       objectId            = -1;
            int       petId                = -1;
            int       healthPercent        = -1;
            int       endurancePercent     = -1;
            int       manaPercent          = -1;
            int       concentrationPercent = -1;
            int       speed                = -1;
            int       maxspeed             = -1;
            int       clientTargetOid      = -1;
            int       serverTargetOid      = -1;
            int       regionXOffset        = 0;
            int       regionYOffset        = 0;
            int       glocX                = -1;
            int       glocY                = -1;
            int       glocRegion           = -1;
            string    loc             = "UNKNOWN";
            string    gloc            = "UNKNOWN";
            string    state           = "";
            string    charName        = "UNKNOWN";
            string    lastName        = "";
            int       playersInGroup  = -1;
            int       indexInGroup    = -1;
            int       mountId         = -1;
            int       mountSlot       = -1;
            int       level           = -1;
            int       mana            = -1;
            int       manaMax         = -1;
            int       health          = -1;
            int       healthMax       = -1;
            int       conc            = -1;
            int       concMax         = -1;
            string    className       = "UNKNOWN";
            string    raceName        = "";
            int       realm_level     = -1;
            string    realm_title     = "";
            int       champ_level     = -1;
            string    champ_title     = "";
            int       ml_level        = -1;
            int       houseLot        = -1;
            string    ml_title        = "";
            int       guildID         = -1;
            string    guildName       = "None";
            string    guildRank       = "";
            string    enterRegionName = "";
            string    petInfo         = "";
            int       insideHouseId   = 0;
            Hashtable enterSubRegion  = new Hashtable();

            bool flagAwait0xA9 = false;

            for (int i = 0; i <= selectedIndex; i++)
            {
                Packet pak = log[i];
                if (pak is CtoS_0xA9_PlayerPosition)
                {
                    CtoS_0xA9_PlayerPosition pos = (CtoS_0xA9_PlayerPosition)pak;
                    speed = pos.Status & 0x1FF;
                    byte plrState = (byte)((pos.Status >> 10) & 7);
                    state = plrState > 0 ? ((StoC_0xA9_PlayerPosition.PlrState)plrState).ToString() : "";
                    if ((pos.Status & 0x200) == 0x200)
                    {
                        state += ",Backward";
                    }
                    if ((pos.Status & 0x8000) == 0x8000)
                    {
                        state += ",StrafeRight";
                    }
                    if ((pos.Status & 0x4000) == 0x4000)
                    {
                        state += ",StrafeLeft";
                    }
                    if ((pos.Status & 0x2000) == 0x2000)
                    {
                        state += "Move";
                    }
                    if ((pos.Flag & 0x01) == 0x01)
                    {
                        state += ",CtoS_0xA9_Flagx01";
                    }
                    if ((pos.Flag & 0x02) == 0x02)
                    {
                        state += ",Underwater";
                    }
                    if ((pos.Flag & 0x04) == 0x04)
                    {
                        state += ",PetInView";
                    }
                    if ((pos.Flag & 0x08) == 0x08)
                    {
                        state += ",GT";
                    }
                    if ((pos.Flag & 0x10) == 0x10)
                    {
                        state += ",CheckTargetInView";
                    }
                    if ((pos.Flag & 0x20) == 0x20)
                    {
                        state += ",TargetInView";
                    }
                    if ((pos.Flag & 0x40) == 0x40)
                    {
                        state += ",MoveTo";
                    }
                    if ((pos.Health & 0x80) == 0x80)
                    {
                        state += ",Combat";
                    }
                    if ((pos.Speed & 0x8000) == 0x8000)
                    {
                        state += ",FallDown";
                    }
                    loc = string.Format("({0,-3}): ({1,-6} {2,-6} {3,-5})", pos.CurrentZoneId, pos.CurrentZoneX, pos.CurrentZoneY, pos.CurrentZoneZ);
                    if (flagAwait0xA9)
                    {
                        if (glocX != -1 && glocY != -1)
                        {
                            regionXOffset = glocX - pos.CurrentZoneX;
                            regionYOffset = glocY - pos.CurrentZoneY;
                        }
                        flagAwait0xA9 = false;
                    }
                    gloc = string.Format("({0,-3}): ({1,-6} {2,-6} {3,-5})", glocRegion, regionXOffset + pos.CurrentZoneX, regionYOffset + pos.CurrentZoneY, pos.CurrentZoneZ);
                }
                else if (pak is StoC_0x16_VariousUpdate)
                {
                    StoC_0x16_VariousUpdate stat = (StoC_0x16_VariousUpdate)pak;
                    if (stat.SubCode == 3)
                    {
                        StoC_0x16_VariousUpdate.PlayerUpdate subData = (StoC_0x16_VariousUpdate.PlayerUpdate)stat.SubData;
                        level       = subData.playerLevel;
                        className   = subData.className;
                        raceName    = subData.raceName;
                        healthMax   = (ushort)(((subData.maxHealthHigh & 0xFF) << 8) | (subData.maxHealthLow & 0xFF));
                        realm_level = subData.realmLevel;
                        realm_title = subData.realmTitle;
                        ml_level    = subData.mlLevel;
                        ml_title    = subData.mlTitle;
                        houseLot    = subData.personalHouse;
                        guildName   = subData.guildName;
                        guildRank   = subData.guildRank;
                        lastName    = subData.lastName;
                        charName    = subData.playerName;
                        if (subData is StoC_0x16_VariousUpdate_179.PlayerUpdate_179)
                        {
                            champ_level = (subData as StoC_0x16_VariousUpdate_179.PlayerUpdate_179).championLevel;
                            champ_title = (subData as StoC_0x16_VariousUpdate_179.PlayerUpdate_179).championTitle;
                        }
                    }
                    else if (stat.SubCode == 6)
                    {
                        StoC_0x16_VariousUpdate.PlayerGroupUpdate subData = (StoC_0x16_VariousUpdate.PlayerGroupUpdate)stat.SubData;
                        playersInGroup = stat.SubCount;
                        for (int j = 0; j < stat.SubCount; j++)
                        {
                            StoC_0x16_VariousUpdate.GroupMember member = subData.groupMembers[j];
                            if (objectId >= 0 && objectId == member.oid)
                            {
                                indexInGroup = j;
                            }
                        }
                    }
                }
                else if (pak is CtoS_0x10_CharacterSelectRequest)
                {
                    CtoS_0x10_CharacterSelectRequest login = (CtoS_0x10_CharacterSelectRequest)pak;
                    charName = login.CharName;
                }
                else if (pak is CtoS_0xB0_TargetChange)
                {
                    CtoS_0xB0_TargetChange trg = (CtoS_0xB0_TargetChange)pak;
                    clientTargetOid = trg.Oid;
                }
                else if (pak is StoC_0xAF_Message)
                {
                    StoC_0xAF_Message msg = (StoC_0xAF_Message)pak;
                    if (msg.Text.StartsWith("You have entered "))
                    {
                        enterRegionName = regionNameFromMessage(msg.Text.Substring(17));
                    }
                    else if (msg.Text.StartsWith("(Region) You have entered "))
                    {
                        string enterSubRegionName = regionNameFromMessage(msg.Text.Substring(26));
                        if (!enterSubRegion.ContainsKey(enterSubRegionName))
                        {
                            enterSubRegion.Add(enterSubRegionName, enterSubRegionName);
                        }
                    }
                    else if (msg.Text.StartsWith("(Region) You have left "))
                    {
                        string enterSubRegionName = regionNameFromMessage(msg.Text.Substring(23));
                        enterSubRegion.Remove(enterSubRegionName);
                    }
                }
                else if (pak is StoC_0xF6_ChangeTarget)
                {
                    StoC_0xF6_ChangeTarget trg = (StoC_0xF6_ChangeTarget)pak;
                    serverTargetOid = trg.Oid;
                }
                else if (pak is StoC_0xB6_UpdateMaxSpeed)
                {
                    StoC_0xB6_UpdateMaxSpeed spd = (StoC_0xB6_UpdateMaxSpeed)pak;
                    maxspeed = spd.MaxSpeedPercent;
                }
                else if (pak is StoC_0xAD_StatusUpdate)
                {
                    StoC_0xAD_StatusUpdate status = (StoC_0xAD_StatusUpdate)pak;
                    healthPercent        = status.HealthPercent;
                    endurancePercent     = status.EndurancePercent;
                    manaPercent          = status.ManaPercent;
                    concentrationPercent = status.ConcentrationPercent;
                    if (pak is StoC_0xAD_StatusUpdate_190)
                    {
                        health    = (pak as StoC_0xAD_StatusUpdate_190).Health;
                        healthMax = (pak as StoC_0xAD_StatusUpdate_190).MaxHealth;
                        mana      = (pak as StoC_0xAD_StatusUpdate_190).Power;
                        manaMax   = (pak as StoC_0xAD_StatusUpdate_190).MaxPower;
                        conc      = (pak as StoC_0xAD_StatusUpdate_190).Concentration;
                        concMax   = (pak as StoC_0xAD_StatusUpdate_190).MaxConcentration;
                    }
                }
                else if (pak is StoC_0x28_SetSessionId)
                {
                    StoC_0x28_SetSessionId session = (StoC_0x28_SetSessionId)pak;
                    sessionId = session.SessionId;
                }
                else if (pak is StoC_0x20_PlayerPositionAndObjectID)
                {
                    StoC_0x20_PlayerPositionAndObjectID posAndOid = (StoC_0x20_PlayerPositionAndObjectID)pak;
                    objectId = posAndOid.PlayerOid;
                    glocX    = (int)posAndOid.X;
                    glocY    = (int)posAndOid.Y;
                    if ((pak as StoC_0x20_PlayerPositionAndObjectID_171) != null)
                    {
                        glocRegion = (pak as StoC_0x20_PlayerPositionAndObjectID_171).Region;
                    }
                    loc           = "UNKNOWN";
                    gloc          = string.Format("({0,-3}): ({1,-6} {2,-6} {3,-5})", glocRegion, posAndOid.X, posAndOid.Y, posAndOid.Z);
                    flagAwait0xA9 = true;
                    enterSubRegion.Clear();
                    enterRegionName = "";
                    insideHouseId   = 0;
                }
                else if (pak is StoC_0xDE_SetObjectGuildId)
                {
                    StoC_0xDE_SetObjectGuildId guildId = (StoC_0xDE_SetObjectGuildId)pak;
                    if (objectId == guildId.Oid)
                    {
                        guildID = guildId.GuildId;
                    }
                    if (guildId.ServerId == 0xFF)                     // set ObjectID for old logs (1.70-)
                    {
                        objectId = guildId.Oid;
                    }
                }
                else if (pak is StoC_0x04_CharacterJump)
                {
                    StoC_0x04_CharacterJump plrJump = (StoC_0x04_CharacterJump)pak;
                    if (plrJump.X == 0 && plrJump.Y == 0 && plrJump.Z == 0)                     // skip /faceloc
                    {
                        continue;
                    }
                    objectId      = plrJump.PlayerOid;
                    glocX         = (int)plrJump.X;
                    glocY         = (int)plrJump.Y;
                    insideHouseId = plrJump.HouseId;
                    loc           = "UNKNOWN";
                    gloc          = string.Format("({0,-3}): ({1,-6} {2,-6} {3,-5})", glocRegion, plrJump.X, plrJump.Y, plrJump.Z);
                    flagAwait0xA9 = true;
                }
                else if (pak is StoC_0x88_PetWindowUpdate)
                {
                    StoC_0x88_PetWindowUpdate pet = (StoC_0x88_PetWindowUpdate)pak;
                    petId = pet.PetId;
                }
                else if (pak is StoC_0xDA_NpcCreate)
                {
                    if (petId == -1)
                    {
                        continue;
                    }
                    StoC_0xDA_NpcCreate npc = (StoC_0xDA_NpcCreate)pak;
                    if (npc.Oid != petId)
                    {
                        continue;
                    }
                    petInfo = string.Format(" \"{0}\" level:{1} model:0x{2:X4}", npc.Name, npc.Level, npc.Model);
                }
                else if (pak is StoC_0xC8_PlayerRide)
                {
                    StoC_0xC8_PlayerRide ride = (StoC_0xC8_PlayerRide)pak;
                    if (objectId >= 0 && objectId == ride.RiderOid)
                    {
                        if (ride.Flag == 0)
                        {
                            mountId   = -1;
                            mountSlot = -1;
                        }
                        else
                        {
                            mountId   = ride.MountOid;
                            mountSlot = ride.Slot;
                        }
                    }
                }
                else if (pak is StoC_0xFB_CharStatsUpdate_175)
                {
                    if ((pak as StoC_0xFB_CharStatsUpdate_175).Flag != 0xFF)
                    {
                        healthMax = (pak as StoC_0xFB_CharStatsUpdate_175).MaxHealth;
                    }
                }
                else if (pak is StoC_0xFB_CharStatsUpdate)
                {
                    healthMax = (pak as StoC_0xFB_CharStatsUpdate).MaxHealth;
                }
                else if (pak is StoC_0x2A_LoginGranted)
                {
                    StoC_0x2A_LoginGranted server = (StoC_0x2A_LoginGranted)pak;
                    serverName          = server.ServerName;
                    serverId            = server.ServerId;
                    serverColorHandling = server.ColorHandling;
                }
            }

            int           additionStrings = 0;
            StringBuilder str             = new StringBuilder();

            if (serverId > 0)
            {
                str.AppendFormat("    server: \"{0}\" id:0x{1:X2} color:{2}\n", serverName, serverId, serverColorHandling);
                additionStrings++;
            }
            str.AppendFormat("session id: 0x{0}\n", ValueToString(sessionId, "X4"));
            str.AppendFormat(" object id: 0x{0}\n", ValueToString(objectId, "X4"));
            str.AppendFormat("    pet id: 0x{0}{1}\n", ValueToString(petId, "X4"), petInfo);
            str.AppendFormat(" char name: {0}{1}\n", charName, lastName != "None" ? string.Format(" \"{0}\"", lastName) : "");
            str.AppendFormat("     level: {0} {1}{2}\n", ValueToString(level), className, (raceName != "" ? " (" + raceName + ")" : ""));
            if (guildName != "None")
            {
                str.AppendFormat("     guild: {0}", guildName);
                str.AppendFormat(" rank:{0}", guildRank);
                if (guildID != -1)
                {
                    str.AppendFormat(" guildId:0x{0:X4}", guildID);
                }
                str.AppendFormat("\n");
                additionStrings++;
            }
            if (realm_level > 0)
            {
                str.AppendFormat("RealmLevel: {0} \"{1}\"\n", ValueToString(realm_level), realm_title);
                additionStrings++;
            }
            if (ml_level > 0)
            {
                str.AppendFormat("  ML level: {0} \"{1}\"\n", ValueToString(ml_level), ml_title);
                additionStrings++;
            }
            if (champ_level > 0)
            {
                str.AppendFormat("ChampLevel: {0} \"{1}\"\n", ValueToString(champ_level), champ_title);
                additionStrings++;
            }
            str.AppendFormat("\n");
            if (houseLot > 0)
            {
                str.AppendFormat("     HouseLot: 0x{0}\n", ValueToString(houseLot, "X4"));
                additionStrings++;
            }
            if (mountId > 0)
            {
                str.AppendFormat("     mount id: 0x{0} (slot:{1})\n", ValueToString(mountId, "X4"), ValueToString(mountSlot));
                additionStrings++;
            }
            if (playersInGroup > 0)
            {
                str.AppendFormat("        group: {0}[{1}]\n", ValueToString(indexInGroup), ValueToString(playersInGroup));
                additionStrings++;
            }
            str.AppendFormat("        speed: {0,3}\n", ValueToString(speed));
            str.AppendFormat("     maxSpeed: {0,3}%\n", ValueToString(maxspeed));
            str.AppendFormat("       health: {0,3}%", ValueToString(healthPercent));
            if (health != -1)
            {
                str.AppendFormat(" ({0}/{1})", health, healthMax);
            }
            else if (healthMax != -1)
            {
                str.AppendFormat(" (maxHealth:{0})", healthMax);
            }
            str.Append('\n');
            str.AppendFormat("         mana: {0,3}%", ValueToString(manaPercent));
            if (mana != -1)
            {
                str.AppendFormat(" ({0}/{1})", mana, manaMax);
            }
            str.Append('\n');
            str.AppendFormat("    endurance: {0,3}%\n", ValueToString(endurancePercent));
            str.AppendFormat("concentration: {0,3}%", ValueToString(concentrationPercent));
            if (conc != -1)
            {
                str.AppendFormat(" ({0}/{1})", conc, concMax);
            }
            str.Append('\n');
            str.AppendFormat(" clientTarget: 0x{0}\n", ValueToString(clientTargetOid, "X4"));
            str.AppendFormat("  checkTarget: 0x{0}\n", ValueToString(serverTargetOid, "X4"));
            str.AppendFormat(" current zone: {0}{1}\n", loc, enterRegionName == "" ? "" : " (" + enterRegionName + ")");
            str.AppendFormat("  calced gloc: {0}\n", gloc);
            int subReg = 0;

            foreach (string subRegionName in enterSubRegion.Values)
            {
                str.AppendFormat(" subRegion[{0}]: {1}\n", subReg++, subRegionName);
                additionStrings++;
            }
            if (insideHouseId != 0)
            {
                str.AppendFormat(" inside House: {0}\n", insideHouseId);
                additionStrings++;
            }
            str.AppendFormat("        flags: {0}\n", state);
            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text   = "Player info (right click to close)";
            infoWindow.Width  = 500;
            infoWindow.Height = 310 + 15 * additionStrings;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();

            return(false);
        }
Example #48
0
        public override void AC_OnPacketInbound(Packet packet)
        {
            ClientMessages header = 0;

            try
            {
                header = (ClientMessages)packet.ReadByte();

                if (!Loaded || Player?.Character == null)
                {
                    switch (header)
                    {
                    case ClientMessages.MIGRATE_IN:
                        OnPlayerLoad(packet);
                        break;     //updated
                    }
                }
                // Block packets as we are migrating
                else if (Server.Instance.InMigration == false || Server.Instance.IsNewServerInMigration)
                {
                    var character = Player.Character;

                    if (logPackets.Contains(header))
                    {
                        PacketLog.ReceivedPacket(packet, (byte)header, Server.Instance.Name, IP);
                    }

                    switch (header)
                    {
                    case ClientMessages.ENTER_PORTAL:
                        MapPacket.OnEnterPortal(packet, character);
                        break;

                    case ClientMessages.CHANGE_CHANNEL:
                        OnChangeChannel(character, packet);
                        break;

                    case ClientMessages.ENTER_CASH_SHOP:
                        OnEnterCashShop(character);
                        break;

                    case ClientMessages.MOVE_PLAYER:
                        MapPacket.HandleMove(character, packet);
                        break;

                    case ClientMessages.SIT_REQUEST:
                        MapPacket.HandleSitChair(character, packet);
                        break;

                    case ClientMessages.ENTER_TOWN_PORTAL:
                        MapPacket.HandleDoorUse(character, packet);
                        break;

                    case ClientMessages.CLOSE_RANGE_ATTACK:
                        AttackPacket.HandleMeleeAttack(character, packet);
                        break;

                    case ClientMessages.RANGED_ATTACK:
                        AttackPacket.HandleRangedAttack(character, packet);
                        break;

                    case ClientMessages.MAGIC_ATTACK:
                        AttackPacket.HandleMagicAttack(character, packet);
                        break;

                    case ClientMessages.TAKE_DAMAGE:
                        CharacterStatsPacket.HandleCharacterDamage(character, packet);
                        break;

                    case ClientMessages.CHAT:
                        MessagePacket.HandleChat(character, packet);
                        break;

                    case ClientMessages.GROUP_MESSAGE:
                        MessagePacket.HandleSpecialChat(character, packet);
                        break;

                    case ClientMessages.WHISPER:
                        MessagePacket.HandleCommand(character, packet);
                        break;

                    case ClientMessages.EMOTE:
                        MapPacket.SendEmotion(character, packet.ReadInt());
                        break;

                    case ClientMessages.NPC_TALK:
                        MapPacket.HandleNPCChat(character, packet);
                        break;

                    case ClientMessages.NPC_TALK_MORE:
                        NpcPacket.HandleNPCChat(character, packet);
                        break;

                    case ClientMessages.SHOP_ACTION:
                        NpcPacket.HandleNPCShop(character, packet);
                        break;

                    case ClientMessages.STORAGE_ACTION:
                        StoragePacket.HandleStorage(character, packet);
                        break;

                    case ClientMessages.ITEM_MOVE:
                        InventoryPacket.HandleInventoryPacket(character, packet);
                        break;

                    case ClientMessages.ITEM_USE:
                        InventoryPacket.HandleUseItemPacket(character, packet);
                        break;

                    case ClientMessages.SUMMON_BAG_USE:
                        InventoryPacket.HandleUseSummonSack(character, packet);
                        break;

                    case ClientMessages.CASH_ITEM_USE:
                        CashPacket.HandleCashItem(character, packet);
                        break;

                    case ClientMessages.RETURN_SCROLL_USE:
                        InventoryPacket.HandleUseReturnScroll(character, packet);
                        break;

                    case ClientMessages.SCROLL_USE:
                        InventoryPacket.HandleScrollItem(character, packet);
                        break;

                    case ClientMessages.DISTRIBUTE_AP:
                        CharacterStatsPacket.HandleStats(character, packet);
                        break;

                    case ClientMessages.HEAL_OVER_TIME:
                        CharacterStatsPacket.HandleHeal(character, packet);
                        break;

                    case ClientMessages.DISTRIBUTE_SP:
                        SkillPacket.HandleAddSkillLevel(character, packet);
                        break;

                    case ClientMessages.PREPARE_SKILL:
                        SkillPacket.HandlePrepareSkill(character, packet);
                        break;

                    case ClientMessages.GIVE_BUFF:
                        SkillPacket.HandleUseSkill(character, packet);
                        break;

                    case ClientMessages.CANCEL_BUFF:
                        SkillPacket.HandleStopSkill(character, packet);
                        break;

                    case ClientMessages.DROP_MESOS:
                        DropPacket.HandleDropMesos(character, packet.ReadInt());
                        break;

                    case ClientMessages.GIVE_FAME:
                        FamePacket.HandleFame(character, packet);
                        break;

                    case ClientMessages.CHAR_INFO_REQUEST:
                        MapPacket.SendPlayerInfo(character, packet);
                        break;

                    case ClientMessages.SPAWN_PET:
                        PetsPacket.HandleSpawnPet(character, packet.ReadShort());
                        break;

                    case ClientMessages.SUMMON_MOVE:
                        MapPacket.HandleSummonMove(character, packet);
                        break;

                    case ClientMessages.SUMMON_ATTACK:
                        AttackPacket.HandleSummonAttack(character, packet);
                        break;

                    case ClientMessages.SUMMON_DAMAGED:
                        MapPacket.HandleSummonDamage(character, packet);
                        break;

                    case ClientMessages.MOB_MOVE:
                        MobPacket.HandleMobControl(character, packet);
                        break;

                    case ClientMessages.NPC_ANIMATE:
                        MapPacket.HandleNPCAnimation(character, packet);
                        break;

                    case ClientMessages.PET_MOVE: PetsPacket.HandleMovePet(character, packet); break;

                    case ClientMessages.PET_INTERACTION: PetsPacket.HandleInteraction(character, packet); break;

                    case ClientMessages.PET_ACTION: PetsPacket.HandlePetAction(character, packet); break;

                    case ClientMessages.FIELD_CONTIMOVE_STATE:
                        MapPacket.OnContiMoveState(character, packet);
                        break;

                    case ClientMessages.DROP_PICK_UP:
                        DropPacket.HandlePickupDrop(character, packet);
                        break;

                    case ClientMessages.MESSENGER:
                        MessengerHandler.HandleMessenger(character, packet);
                        break;

                    case ClientMessages.MINI_ROOM_OPERATION:
                        MiniRoomPacket.HandlePacket(character, packet);
                        break;

                    case ClientMessages.FRIEND_OPERATION:
                        BuddyHandler.HandleBuddy(character, packet);
                        break;

                    case ClientMessages.PARTY_OPERATION:
                        PartyHandler.HandleParty(character, packet);
                        break;

                    case ClientMessages.DENY_PARTY_REQUEST:
                        PartyHandler.HandleDecline(character, packet);
                        break;

                    case ClientMessages.REACTOR_HIT:
                        ReactorPacket.HandleReactorHit(character, packet);
                        break;

                    case ClientMessages.REPORT_USER:
                        MiscPacket.ReportPlayer(character, packet);
                        break;


                    //this is a garbage opcode that i use when doing janky client packet workarounds. This is where packets go to die.
                    case ClientMessages.JUNK:
                        Program.MainForm.LogDebug("received junk packet");
                        break;

                    // eh.. ignore?
                    // Happens when one of the following buffs are set:
                    // Stun, Poison, Seal, Darkness, Weakness, Curse
                    // Maybe patch out of the client
                    case ClientMessages.CHARACTER_IS_DEBUFFED: break;

                    // TODO: Implement???
                    case ClientMessages.MOB_APPLY_CONTROL: break;

                    case ClientMessages.CLIENT_HASH: break;

                    case ClientMessages.PONG:
                        // Make sure we update the player online thing
                        RedisBackend.Instance.SetPlayerOnline(
                            character.UserID,
                            Server.Instance.GetOnlineId()
                            );

                        // Cleanup expired items
                        character.Inventory.CheckExpired();
                        break;

                    default:
                        if (character.Field.HandlePacket(character, packet, header) == false)
                        {
                            Program.MainForm.LogAppend(
                                "[{0}] Unknown packet received! " + packet,
                                header
                                );
                        }

                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Program.MainForm.LogAppend($"---- ERROR ----\r\n{ex}");
                Program.MainForm.LogAppend($"Packet: {packet}");
                FileWriter.WriteLine(@"etclog\ExceptionCatcher.log", "[Game Server " + Server.Instance.ID + "][" + DateTime.Now + "] Exception caught: " + ex, true);
                //Disconnect();
            }


#if DEBUG
            if (packet.Length != packet.Position)
            {
                var packetStr = packet.ToString();
                packetStr = packetStr.Substring(0, packet.Position * 3 - 1) + "-x-" + packetStr.Substring(packet.Position * 3);

                log.Debug($"Did not read full message in packet: {header} {packetStr}");
            }
#endif
        }
Example #49
0
        public static Hashtable MakeCombatList(int selectedIndex, PacketLog log)
        {
            Hashtable  plrInfo    = new Hashtable();
            PlayerInfo playerInfo = null;            // = new PlayerInfo();
            int        playerOid  = -1;
            string     nameKey    = "";
            string     statKey    = "";
            string     plrName    = "";
            string     plrClass   = "";
            int        plrLevel   = 0;

            for (int i = 0; i < selectedIndex; ++i)
            {
                Packet pak = log[i];
                if (pak is StoC_0x20_PlayerPositionAndObjectID)
                {
                    StoC_0x20_PlayerPositionAndObjectID plr = (StoC_0x20_PlayerPositionAndObjectID)pak;
                    playerOid = plr.PlayerOid;
                }
                else if (pak is StoC_0x16_VariousUpdate)
                {
                    StoC_0x16_VariousUpdate stat = (StoC_0x16_VariousUpdate)pak;
                    if (stat.SubCode == 3)
                    {
                        StoC_0x16_VariousUpdate.PlayerUpdate subData = (StoC_0x16_VariousUpdate.PlayerUpdate)stat.SubData;
                        nameKey  = "N:" + subData.playerName + "L:" + subData.playerLevel;
                        statKey  = "";
                        plrName  = subData.playerName;
                        plrLevel = subData.playerLevel;
                        plrClass = subData.className;
                    }
                    else if (stat.SubCode == 5)
                    {
                        StoC_0x16_VariousUpdate.PlayerStateUpdate subData = (StoC_0x16_VariousUpdate.PlayerStateUpdate)stat.SubData;
                        string key = string.Format("WD:{0}.{1}WS:{2}", subData.weaponDamageHigh, subData.weaponDamageLow, (subData.weaponSkillHigh << 8) + subData.weaponSkillLow);
                        if (nameKey != "")
                        {
                            if (plrInfo.ContainsKey(nameKey + key))
                            {
                                playerInfo = (PlayerInfo)plrInfo[nameKey + key];
                            }
                            else
                            {
                                playerInfo              = new PlayerInfo();
                                playerInfo.name         = plrName;
                                playerInfo.level        = plrLevel;
                                playerInfo.className    = plrClass;
                                playerInfo.weaponDamage = string.Format("{0,2}.{1,-3}", subData.weaponDamageHigh, subData.weaponDamageLow);
                                playerInfo.weaponSkill  = (subData.weaponSkillHigh << 8) + subData.weaponSkillLow;
                                plrInfo.Add(nameKey + key, playerInfo);
                            }
                            plrInfo[nameKey + key] = playerInfo;
                        }
                        statKey = key;
                    }
                }
                else if (pak is StoC_0xBC_CombatAnimation && (playerInfo != null))
                {
                    StoC_0xBC_CombatAnimation combat = (StoC_0xBC_CombatAnimation)pak;
                    if (combat.Stance == 0 && combat.AttackerOid == playerOid && combat.DefenderOid != 0)
                    {
                        switch (combat.Result & 0x7F)
                        {
                        case 0:
                            playerInfo.miss++;
                            break;

                        case 1:
                        case 2:
                        case 3:
                            playerInfo.failAttacks++;
                            break;

                        case 4:
                            playerInfo.fumble++;
                            break;

                        case 0xA:
                        case 0xB:
                            playerInfo.hit++;
                            break;

                        default:
                            break;
                        }
                    }
                    else if (combat.AttackerOid != 0 && combat.DefenderOid == playerOid)
                    {
                        switch (combat.Result & 0x7F)
                        {
                        case 1:
                            playerInfo.parry++;
                            break;

                        case 2:
                            playerInfo.block++;
                            break;

                        case 3:
                            playerInfo.evade++;
                            break;

                        case 0x0:
                        case 0xA:
                        case 0xB:
                            playerInfo.attacked++;
                            break;

                        default:
                            break;
                        }
                    }
                }

/*				else if (pak is StoC_0xAF_Message)
 *                              {
 *                                      StoC_0xAF_Message msg = (StoC_0xAF_Message)pak;
 *                                      switch (msg.Type)
 *                                      {
 *                                              case 0x10: // Your cast combat
 *                                              case 0x11: // Your Melee combat
 *                                              case 0x1B: // resist
 *                                              case 0x1D: // X hits you
 *                                              case 0x1E: // X miss you
 *                                                      break;
 *                                              default:
 *                                                      break;
 *                                      }
 *                              }*/
            }
            if (nameKey != "" && statKey != "")
            {
                plrInfo[nameKey + statKey] = playerInfo;
            }
            return(plrInfo);
        }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog log           = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int       selectedIndex = selectedPacket.PacketIndex;

            int           currentRegion        = 0;
            int           currentZone          = 0;
            Hashtable     keepComponentsByOids = new Hashtable();
            Hashtable     keepComponents       = new Hashtable();
            Hashtable     keeps = new Hashtable();
            StringBuilder str   = new StringBuilder();

            for (int i = 0; i < selectedIndex; i++)
            {
                Packet pak = log[i];
                if (pak is StoC_0x6C_KeepComponentOverview)
                {
                    StoC_0x6C_KeepComponentOverview keep = (StoC_0x6C_KeepComponentOverview)pak;
                    string    key = keep.KeepId + "C:" + keep.ComponentId;
                    Component kc;
                    if (!keepComponents.ContainsKey(key))
                    {
                        kc                  = new Component();
                        kc.KeepId           = keep.KeepId;
                        kc.ComponentId      = keep.ComponentId;
                        kc.Oid              = keep.Uid;
                        kc.Skin             = keep.Skin;
                        kc.addX             = (sbyte)keep.X;
                        kc.addY             = (sbyte)keep.Y;
                        kc.Rotate           = keep.Heading;
                        kc.Height           = keep.Height;
                        kc.Health           = keep.Health;
                        kc.Status           = keep.Status;
                        kc.Flag             = keep.Flag;
                        kc.Zone             = 0;
                        keepComponents[key] = kc;
                    }
                    else
                    {
                        kc = (Component)keepComponents[key];
                    }
                    keepComponentsByOids[keep.Uid] = kc;
                }
                else if (pak is StoC_0x69_KeepOverview)
                {
                    StoC_0x69_KeepOverview keep = (StoC_0x69_KeepOverview)pak;
                    if (!keeps.ContainsKey(keep.KeepId))
                    {
                        Keep k = new Keep();
                        k.KeepId           = keep.KeepId;
                        k.Angle            = keep.Heading;
                        k.X                = keep.KeepX;
                        k.Y                = keep.KeepY;
                        keeps[keep.KeepId] = k;
                    }
                }
                else if (pak is StoC_0xA1_NpcUpdate)
                {
                    StoC_0xA1_NpcUpdate obj = (StoC_0xA1_NpcUpdate)pak;
                    if (keepComponentsByOids.ContainsKey(obj.NpcOid))
                    {
                        Component kc  = (Component)keepComponentsByOids[obj.NpcOid];
                        string    key = kc.KeepId + "C:" + kc.ComponentId;
                        kc.Zone    = obj.CurrentZoneId;
                        kc.Heading = (ushort)(obj.Heading & 0xFFF);
                        kc.X       = obj.CurrentZoneX;
                        kc.Y       = obj.CurrentZoneY;
                        kc.Z       = obj.CurrentZoneZ;
                        keepComponentsByOids[obj.NpcOid] = kc;
                        keepComponents[key] = kc;
                    }
                }
                else if (pak is StoC_0xB7_RegionChange)
                {
                    StoC_0xB7_RegionChange region = (StoC_0xB7_RegionChange)pak;

                    if (region.RegionId != currentRegion)
                    {
                        currentRegion = region.RegionId;
                        currentZone   = region.ZoneId;
                        keepComponentsByOids.Clear();
                    }
                }
                else if (pak is StoC_0x20_PlayerPositionAndObjectID_171)
                {
                    StoC_0x20_PlayerPositionAndObjectID_171 region = (StoC_0x20_PlayerPositionAndObjectID_171)pak;

                    if (region.Region != currentRegion)
                    {
                        currentRegion = region.Region;
                        keepComponentsByOids.Clear();
                    }
                }
            }
            foreach (Component kc in keepComponents.Values)
            {
                if (kc.Zone != 0)
                {
                    Keep k = (Keep)keeps[kc.KeepId];
                    str.AppendFormat("keepId:{0,-4} keepX:{1,-6} keepY:{2,-6} angle:{3,-3} ", k.KeepId, k.X, k.Y, k.Angle);
                    str.AppendFormat("componentId:{0,-2} oid:{1,-5} Skin:{2,-2} X:{3,-4} Y:{4,-4} Rotate:{5} ", kc.ComponentId, kc.Oid, kc.Skin, kc.addX, kc.addY, kc.Rotate);
                    str.AppendFormat("Heading:{0,-4} Zone:{1,-3} @X:{2,-5} @Y:{3,-5} Z:{4}\n", kc.Heading, kc.Zone, kc.X, kc.Y, kc.Z);
                }
            }
            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text  = "Show keep components info (right click to close)";
            infoWindow.Width = 650;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();
            return(false);
        }
        /// <summary>
        /// Activates a log action.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="selectedPacket">The selected packet.</param>
        /// <returns><c>true</c> if log data tab should be updated.</returns>
        public override bool Activate(IExecutionContext context, PacketLocation selectedPacket)
        {
            PacketLog  log              = context.LogManager.GetPacketLog(selectedPacket.LogIndex);
            int        selectedIndex    = selectedPacket.PacketIndex;
            SortedList m_inventoryItems = new SortedList();

            int preAction          = 0;
            int lastVaultPreAction = -1;
            int vaultNumber        = -1;
            int VisibleSlots       = 0xFF;

            for (int i = 0; i <= selectedIndex; i++)
            {
                Packet pak = log[i];
                if (pak is StoC_0x20_PlayerPositionAndObjectID_171)
                {
                    VisibleSlots = 0xFF;
                    m_inventoryItems.Clear();
                }
                else if (pak is StoC_0x02_InventoryUpdate)
                {
                    StoC_0x02_InventoryUpdate invPack = (StoC_0x02_InventoryUpdate)pak;
                    if (invPack.PreAction != 0 && invPack.PreAction != 10)
                    {
                        preAction = invPack.PreAction;                         // rememer last opened inventory action, if it not update
                    }
                    if (preAction > 10)
                    {
                        preAction -= 10;
                    }
                    if (invPack.PreAction == 1 || invPack.PreAction == 0 || invPack.PreAction == 11 || invPack.PreAction == 10)
                    {
                        VisibleSlots = invPack.VisibleSlots;
                    }
                    if (invPack.PreAction == 2)
                    {
                        for (byte j = 40; j < 80; j++)
                        {
                            if (m_inventoryItems.ContainsKey(j))
                            {
                                m_inventoryItems.Remove(j);
                            }
                        }
                    }
                    else if (invPack.PreAction == 7)
                    {
                        for (byte j = 80; j <= 95; j++)
                        {
                            if (m_inventoryItems.ContainsKey(j))
                            {
                                m_inventoryItems.Remove(j);
                            }
                        }
                    }
                    else if (invPack.PreAction == 3)
                    {
                        for (byte j = 110; j < 150; j++)
                        {
                            if (m_inventoryItems.ContainsKey(j))
                            {
                                m_inventoryItems.Remove(j);
                            }
                        }
                    }
                    else if (invPack.PreAction == 4 || invPack.PreAction == 5 || invPack.PreAction == 6)
                    {
                        lastVaultPreAction = invPack.PreAction;
                        vaultNumber        = invPack.VisibleSlots;
                        for (byte j = 150; j < 250; j++)
                        {
                            if (m_inventoryItems.ContainsKey(j))
                            {
                                m_inventoryItems.Remove(j);
                            }
                        }
                    }
                    for (int j = 0; j < invPack.SlotsCount; j++)
                    {
                        StoC_0x02_InventoryUpdate.Item item = (StoC_0x02_InventoryUpdate.Item)invPack.Items[j];
                        if (item.name == null || item.name == "")
                        {
                            if (m_inventoryItems.ContainsKey(item.slot))
                            {
                                m_inventoryItems.Remove(item.slot);
                            }
                        }
                        else
                        {
                            if (m_inventoryItems.ContainsKey(item.slot))
                            {
                                m_inventoryItems[item.slot] = item;
                            }
                            else
                            {
                                m_inventoryItems.Add(item.slot, item);
                            }
                        }
                    }
                }
            }
            StringBuilder str = new StringBuilder();

            str.AppendFormat("VisibleSlots:0x{0:X2} last initialized preAction:{1}({2})\n", VisibleSlots, preAction, (StoC_0x02_InventoryUpdate.ePreActionType)preAction);
            eWindowType prevWindowType = eWindowType.Unknown;
            eWindowType windowType     = eWindowType.Unknown;

            foreach (StoC_0x02_InventoryUpdate.Item item in m_inventoryItems.Values)
            {
//				if (item.slot > 95 /*&& item.slot < 1000*/)
                {
                    string selected = " ";
                    if (item.slot >= 7 && item.slot <= 9)
                    {
                        windowType = eWindowType.Horse;
                    }
                    else if (item.slot >= 10 && item.slot <= 13)
                    {
                        windowType = eWindowType.Weapon;
                        if (((item.slot - 10) == (VisibleSlots & 0x0F)) || ((item.slot - 10) == ((VisibleSlots >> 4) & 0x0F)))
                        {
                            selected = "*";
                        }
                    }
                    else if (item.slot >= 14 && item.slot <= 17)
                    {
                        windowType = eWindowType.Quiver;
                    }
                    else if (item.slot >= 21 && item.slot <= 37)
                    {
                        windowType = eWindowType.Doll;
                    }
                    else if (item.slot >= 40 && item.slot <= 79)
                    {
                        windowType = eWindowType.Backpack;
                    }
                    else if (item.slot >= 80 && item.slot <= 95)
                    {
                        windowType = eWindowType.Horsebag;
                    }
                    else if (item.slot >= 110 && item.slot <= 149)
                    {
                        windowType = eWindowType.Vault;
                    }
                    else if (item.slot >= 150 && item.slot <= 249)
                    {
                        windowType = eWindowType.HouseVault;
                    }
                    if (windowType != prevWindowType)
                    {
                        str.Append('\n');
                        str.Append(windowType);
                        if (windowType == eWindowType.HouseVault)
                        {
                            if (lastVaultPreAction == 4 && vaultNumber != -1)
                            {
                                str.Append(' ');
                                str.Append(vaultNumber);
                            }
                            str.AppendFormat(" ({0})", (StoC_0x02_InventoryUpdate.ePreActionType)lastVaultPreAction);
                        }
                    }
                    str.AppendFormat("\n{16}slot:{0,-3} level:{1,-2} value1:0x{2:X2} value2:0x{3:X2} hand:0x{4:X2} damageType:0x{5:X2} objectType:0x{6:X2} weight:{7,-4} con:{8,-3} dur:{9,-3} qual:{10,-3} bonus:{11,-2} model:0x{12:X4} color:0x{13:X4} effect:0x{14:X2} \"{15}\"",
                                     item.slot, item.level, item.value1, item.value2, item.hand, item.damageType, item.objectType, item.weight, item.condition, item.durability, item.quality, item.bonus, item.model, item.color, item.effect, item.name, selected);
                    if (item.name != null && item.name != "")
                    {
                        str.AppendFormat(" ({0})", (StoC_0x02_InventoryUpdate.eObjectType)item.objectType);
                    }
                    prevWindowType = windowType;
                }
            }

            InfoWindowForm infoWindow = new InfoWindowForm();

            infoWindow.Text   = "Player inventory info (right click to close)";
            infoWindow.Width  = 800;
            infoWindow.Height = 400;
            infoWindow.InfoRichTextBox.Text = str.ToString();
            infoWindow.StartWindowThread();

            return(false);
        }
        public ICollection<Packet> ReadLog(Stream stream, ProgressCallback callback)
        {
            List<Packet> packets = new List<Packet>((int)(stream.Length / 128));

            int counter = 0;
            string line = null;
            Packet pak = null;
            PacketLog log = new PacketLog();
            int dataBytesCount = -1;
            ArrayList ignoredPacketHeaders = new ArrayList();
            string header = "";

            using(StreamReader s = new StreamReader(stream, Encoding.ASCII))
            //			using(BufferedStringReader strings = new BufferedStringReader(stream, 16)) // precache 65k strings
            {
                try
                {
                    while ((line = s.ReadLine()) != null)
                    {
                        if (callback != null && (counter++ & 0x1FFF) == 0) // update progress every 8k lines
                            callback((int)(stream.Position>>10),
                                     (int)(stream.Length>>10));

                        if (line.Length < 1) continue;

                        if (line[0] == '<')
                        {
                            if (pak != null)
                            {
                                if (pak.Length == dataBytesCount)
                                {
                                    packets.Add(pak);
                                    try { pak.InitLog(log); }
                                    catch {}
                                }
                                else
                                {
                                    ignoredPacketHeaders.Add(header);
                                }
                            }

                            header = line;

                            try
                            {
                                int code;
                                ePacketDirection dir;
                                ePacketProtocol prot;
                                TimeSpan time;
                                dataBytesCount = ParseHeader(line, out code, out dir, out prot, out time);

                                if (dataBytesCount < 0)
                                {
                                    pak = null;
                                    ignoredPacketHeaders.Add(header);
                                }
                                else
                                {
                                    pak = PacketManager.CreatePacket(log.Version, (byte)code, dir, dataBytesCount);
                                    pak.Code = (byte)code;
                                    pak.Direction = dir;
                                    pak.Protocol = prot;
                                    pak.Time = time;
                                }
                            }
                            catch
                            {
                                pak = null;
                                ignoredPacketHeaders.Add(header);
                            }

                            continue;
                        }

                        if (pak == null)
                            continue;

                        ParseDataLine(line, pak);
                    }
                }
                catch (Exception e)
                {
                    Log.Error("reading file", e);
                }

                if (pak != null)
                {
                    if (pak.Length == dataBytesCount)
                    {
                        packets.Add(pak);
                    }
                    else
                    {
                        ignoredPacketHeaders.Add(header);
                    }
                }
            }

            if (ignoredPacketHeaders.Count > 0)
            {
                StringBuilder ignored = new StringBuilder("Ignored packets: "+ignoredPacketHeaders.Count+"\n\n");
                for (int i = 0; i < ignoredPacketHeaders.Count; i++)
                {
                    string s = (string)ignoredPacketHeaders[i];
                    ignored.Append('\n').Append(s);
                    if (i > 15)
                    {
                        ignored.Append("\n...");
                        break;
                    }
                }
                Log.Info(ignored.ToString());
            }

            return packets;
        }
Example #53
0
        bool ProcessPacket(WorldPacket packet)
        {
            ClientOpcodes opcode = (ClientOpcodes)packet.GetOpcode();

            PacketLog.Write(packet.GetData(), opcode, GetRemoteIpAddress(), GetRemotePort(), _connectType);

            try
            {
                switch (opcode)
                {
                case ClientOpcodes.Ping:
                    Ping ping = new Ping(packet);
                    ping.Read();
                    return(HandlePing(ping));

                case ClientOpcodes.AuthSession:
                    if (_worldSession != null)
                    {
                        Log.outError(LogFilter.Network, "WorldSocket.ProcessPacket: received duplicate CMSG_AUTH_SESSION from {0}", _worldSession.GetPlayerInfo());
                        return(false);
                    }

                    AuthSession authSession = new AuthSession(packet);
                    authSession.Read();
                    HandleAuthSession(authSession);
                    break;

                case ClientOpcodes.AuthContinuedSession:
                    if (_worldSession != null)
                    {
                        Log.outError(LogFilter.Network, "WorldSocket.ProcessPacket: received duplicate CMSG_AUTH_CONTINUED_SESSION from {0}", _worldSession.GetPlayerInfo());
                        return(false);
                    }

                    AuthContinuedSession authContinuedSession = new AuthContinuedSession(packet);
                    authContinuedSession.Read();
                    HandleAuthContinuedSession(authContinuedSession);
                    break;

                case ClientOpcodes.LogDisconnect:
                    break;

                case ClientOpcodes.EnableNagle:
                    Log.outDebug(LogFilter.Network, "Client {0} requested enabling nagle algorithm", GetRemoteIpAddress().ToString());
                    SetNoDelay(false);
                    break;

                case ClientOpcodes.ConnectToFailed:
                    ConnectToFailed connectToFailed = new ConnectToFailed(packet);
                    connectToFailed.Read();
                    HandleConnectToFailed(connectToFailed);
                    break;

                case ClientOpcodes.EnableEncryptionAck:
                    HandleEnableEncryptionAck();
                    break;

                default:
                    if (_worldSession == null)
                    {
                        Log.outError(LogFilter.Network, "ProcessIncoming: Client not authed opcode = {0}", opcode);
                        return(false);
                    }

                    if (!PacketManager.ContainsHandler(opcode))
                    {
                        Log.outError(LogFilter.Network, "No defined handler for opcode {0} sent by {1}", opcode, _worldSession.GetPlayerInfo());
                        break;
                    }

                    // Our Idle timer will reset on any non PING opcodes.
                    // Catches people idling on the login screen and any lingering ingame connections.
                    _worldSession.ResetTimeOutTime();
                    _worldSession.QueuePacket(packet);
                    break;
                }
            }
            catch (IOException)
            {
                Log.outError(LogFilter.Network, "WorldSocket.ProcessPacket(): client {0} sent malformed {1}", GetRemoteIpAddress().ToString(), opcode);
                return(false);
            }

            return(true);
        }
 public static Hashtable MakeCombatList(int selectedIndex, PacketLog log)
 {
     Hashtable plrInfo = new Hashtable();
     PlayerInfo playerInfo = null;// = new PlayerInfo();
     int playerOid = -1;
     string nameKey = "";
     string statKey = "";
     string plrName = "";
     string plrClass = "";
     int plrLevel = 0;
     for (int i = 0; i < selectedIndex; ++i)
     {
         Packet pak = log[i];
         if (pak is StoC_0x20_PlayerPositionAndObjectID)
         {
             StoC_0x20_PlayerPositionAndObjectID plr = (StoC_0x20_PlayerPositionAndObjectID)pak;
             playerOid = plr.PlayerOid;
         }
         else if (pak is StoC_0x16_VariousUpdate)
         {
             StoC_0x16_VariousUpdate stat = (StoC_0x16_VariousUpdate)pak;
             if (stat.SubCode == 3)
             {
                 StoC_0x16_VariousUpdate.PlayerUpdate subData = (StoC_0x16_VariousUpdate.PlayerUpdate)stat.SubData;
                 nameKey = "N:" + subData.playerName + "L:" + subData.playerLevel;
                 statKey = "";
                 plrName = subData.playerName;
                 plrLevel = subData.playerLevel;
                 plrClass = subData.className;
             }
             else if (stat.SubCode == 5)
             {
                 StoC_0x16_VariousUpdate.PlayerStateUpdate subData = (StoC_0x16_VariousUpdate.PlayerStateUpdate)stat.SubData;
                 string key = string.Format("WD:{0}.{1}WS:{2}", subData.weaponDamageHigh, subData.weaponDamageLow, (subData.weaponSkillHigh << 8) + subData.weaponSkillLow);
                 if (nameKey != "")
                 {
                     if(plrInfo.ContainsKey(nameKey + key))
                     {
                         playerInfo = (PlayerInfo)plrInfo[nameKey + key];
                     }
                     else
                     {
                         playerInfo = new PlayerInfo();
                         playerInfo.name = plrName;
                         playerInfo.level = plrLevel;
                         playerInfo.className = plrClass;
                         playerInfo.weaponDamage = string.Format("{0,2}.{1,-3}", subData.weaponDamageHigh, subData.weaponDamageLow);
                         playerInfo.weaponSkill = (subData.weaponSkillHigh << 8) + subData.weaponSkillLow;
                         plrInfo.Add(nameKey + key, playerInfo);
                     }
                     plrInfo[nameKey + key] = playerInfo;
                 }
                 statKey = key;
             }
         }
         else if (pak is StoC_0xBC_CombatAnimation && (playerInfo != null))
         {
             StoC_0xBC_CombatAnimation combat = (StoC_0xBC_CombatAnimation)pak;
             if (combat.Stance == 0 && combat.AttackerOid == playerOid && combat.DefenderOid != 0)
             {
                 switch (combat.Result & 0x7F)
                 {
                     case 0:
                         playerInfo.miss++;
                         break;
                     case 1:
                     case 2:
                     case 3:
                         playerInfo.failAttacks++;
                         break;
                     case 4:
                         playerInfo.fumble++;
                         break;
                     case 0xA:
                     case 0xB:
                         playerInfo.hit++;
                         break;
                     default:
                     break;
                 }
             }
             else if (combat.AttackerOid != 0 && combat.DefenderOid == playerOid)
             {
                 switch (combat.Result & 0x7F)
                 {
                     case 1:
                         playerInfo.parry++;
                         break;
                     case 2:
                         playerInfo.block++;
                         break;
                     case 3:
                         playerInfo.evade++;
                         break;
                     case 0x0:
                     case 0xA:
                     case 0xB:
                         playerInfo.attacked++;
                         break;
                     default:
                     break;
                 }
             }
         }
     /*				else if (pak is StoC_0xAF_Message)
         {
             StoC_0xAF_Message msg = (StoC_0xAF_Message)pak;
             switch (msg.Type)
             {
                 case 0x10: // Your cast combat
                 case 0x11: // Your Melee combat
                 case 0x1B: // resist
                 case 0x1D: // X hits you
                 case 0x1E: // X miss you
                     break;
                 default:
                     break;
             }
         }*/
     }
     if (nameKey != "" && statKey != "")
         plrInfo[nameKey + statKey] = playerInfo;
     return plrInfo;
 }