Multiple entities kills bug

I checked and I didn't see anything wrong that could make that bug. But I'm a beginner in C# so here's the codes that could be concerned with this. Thanks to the persons that are trying to help me out, I appreciate it.

Attack.cs

Spoiler

Code:

using System;

namespace Conquer_Online_Server.Network.GamePackets
{
    public class Attack : Interfaces.IPacket
    {
        public const uint Melee = 2,
                          MarriageRequest = 8,
                          MarriageAccept = 9,
                          Kill = 14,
                          Magic = 24,
                          Reflect = 26,
                          Dash = 27,
                          Ranged = 28,
                          MonkMelee = 34,
                          MerchantAccept = 40,
                          MerchantRefuse = 41,
                          MerchantProgress = 42,
                          Scapegoat = 43,
                          CounterKillSwitch = 44,
                          FatalStrike = 45,
                          ShowUseSpell = 52,
                          InteractionRequest = 46,
                          InteractionAccept = 47,
                          InteractionRefuse = 48,
                          InteractionEffect = 49,
                          InteractionStopEffect = 50;


        byte[] Buffer;

        public Attack(bool Create)
        {
            if (Create)
            {
                Buffer = new byte[8 + 32];
                Writer.WriteUInt16(32, 0, Buffer);
                Writer.WriteUInt16(1022, 2, Buffer);
            }
        }

        public uint Attacker
        {
            get { return BitConverter.ToUInt32(Buffer, 8); }
            set { Writer.WriteUInt32(value, 8, Buffer); }
        }

        public uint Attacked
        {
            get { return BitConverter.ToUInt32(Buffer, 12); }
            set { Writer.WriteUInt32(value, 12, Buffer); }
        }

        public ushort X
        {
            get { return BitConverter.ToUInt16(Buffer, 16); }
            set { Writer.WriteUInt16(value, 16, Buffer); }
        }

        public ushort Y
        {
            get { return BitConverter.ToUInt16(Buffer, 18); }
            set { Writer.WriteUInt16(value, 18, Buffer); }
        }

        public uint AttackType
        {
            get { return BitConverter.ToUInt32(Buffer, 20); }
            set { Writer.WriteUInt32(value, 20, Buffer); }
        }

        public uint Damage
        {
            get { return BitConverter.ToUInt32(Buffer, 24); }
            set { Writer.WriteUInt32(value, 24, Buffer); }
        }

        public ushort KOCount
        {
            get { return BitConverter.ToUInt16(Buffer, 26); }
            set { Writer.WriteUInt16(value, 26, Buffer); }
        }

        public uint ResponseDamage
        {
            get { return BitConverter.ToUInt32(Buffer, 28); }
            set { Writer.WriteUInt32(value, 28, Buffer); }
        }
        public AttackEffects1 Effect1
        {
            get { return (AttackEffects1)Buffer[32]; }
            set { Buffer[32] = (Byte)value; }
        }

        public AttackEffects2 Effect2
        {
            get { return (AttackEffects2)Buffer[33]; }
            set { Buffer[33] = (Byte)value; }
        }
        [Flags]
        public enum AttackEffects1 : byte
        {
            None = 0x0,
            Block = 0x1,
            Penetration = 0x2,
            CriticalStrike = 0x4,
            MetalResist = 0x10,
            WoodResist = 0x20,
            WaterResist = 0x40,
            FireResist = 0x80,
        }

        [Flags]
        public enum AttackEffects2 : byte
        {
            None = 0x0,
            EarthResist = 0x1,
            StudyPoints = 0x2,
        }
        public bool Decoded = false;

        public void Deserialize(byte[] buffer)
        {
            this.Buffer = buffer;
        }
        public byte[] ToArray()
        {
            return Buffer;
        }
        public void Send(Client.GameState client)
        {
            client.Send(Buffer);
        }
    }
}

Ranged region in Handle.cs

Spoiler

Code:

                    #region Ranged
                    else if (attack.AttackType == Attack.Ranged)
                    {
                        if (attacker.Owner.Screen.TryGetValue(attack.Attacked, out attacked))
                        {
                            CheckForExtraWeaponPowers(attacker.Owner, attacked);
                            if (attacker.Owner.Equipment.TryGetItem(ConquerItem.LeftWeapon) == null)
                                return;
                            if (!CanAttack(attacker, attacked, null, attack.AttackType == Attack.Melee))
                                return;
                            if (!attacker.Owner.Equipment.Free((byte)ConquerItem.LeftWeapon))
                            {
                                Interfaces.IConquerItem arrow = attacker.Owner.Equipment.TryGetItem(ConquerItem.LeftWeapon);
                                arrow.Durability -= 1;
                                ItemUsage usage = new ItemUsage(true) { UID = arrow.UID, dwParam = arrow.Durability, ID = ItemUsage.UpdateDurability };
                                usage.Send(attacker.Owner);
                                if (arrow.Durability <= 0 || arrow.Durability > 5000)
                                {
                                    Network.PacketHandler.ReloadArrows(attacker.Owner.Equipment.TryGetItem(ConquerItem.LeftWeapon), attacker.Owner);
                                }
                            }
                            if (ServerBase.Kernel.GetDistance(attacker.X, attacker.Y, attacked.X, attacked.Y) <= ServerBase.Constants.pScreenDistance)
                            {
                                uint damage = Game.Attacking.Calculate.Ranged(attacker, attacked);
                                attack.Damage = damage;
                                if (attacker.EntityFlag == EntityFlag.Player && attacked.EntityFlag != EntityFlag.Player)
                                    if (damage > attacked.Hitpoints)
                                    {
                                        attacker.Owner.IncreaseProficiencyExperience(Math.Min(damage, attacked.Hitpoints), 500);
                                    }
                                    else
                                    {
                                        attacker.Owner.IncreaseProficiencyExperience(damage, 500);
                                    }
                                    ReceiveAttack(attacker, attacked, attack, damage, null);
                            }
                        }
                        else if (attacker.Owner.Screen.TryGetSob(attack.Attacked, out attackedsob))
                        {
                            if (CanAttack(attacker, attackedsob, null))
                            {
                                if (attacker.Owner.Equipment.TryGetItem(ConquerItem.LeftWeapon) == null)
                                    return;
                                if (attacker.MapID != 1039)
                                {
                                    if (!attacker.Owner.Equipment.Free((byte)ConquerItem.LeftWeapon))
                                    {
                                        Interfaces.IConquerItem arrow = attacker.Owner.Equipment.TryGetItem(ConquerItem.LeftWeapon);
                                        arrow.Durability -= 1;
                                        ItemUsage usage = new ItemUsage(true) { UID = arrow.UID, dwParam = arrow.Durability, ID = ItemUsage.UpdateDurability };
                                        usage.Send(attacker.Owner);
                                        if (arrow.Durability <= 0 || arrow.Durability > 5000)
                                        {
                                            Network.PacketHandler.ReloadArrows(attacker.Owner.Equipment.TryGetItem(ConquerItem.LeftWeapon), attacker.Owner);
                                        }
                                    }
                                }
                                if (ServerBase.Kernel.GetDistance(attacker.X, attacker.Y, attackedsob.X, attackedsob.Y) <= ServerBase.Constants.pScreenDistance)
                                {
                                    uint damage = Game.Attacking.Calculate.Ranged(attacker, attackedsob);
                                    attack.Damage = damage;
                                    ReceiveAttack(attacker, attackedsob, attack, damage, null);
                                    if (damage > attackedsob.Hitpoints)
                                    {
                                        attacker.Owner.IncreaseProficiencyExperience(Math.Min(damage, attackedsob.Hitpoints), 500);
                                    }
                                    else
                                    {
                                        attacker.Owner.IncreaseProficiencyExperience(damage, 500);
                                    }
                                }
                            }
                        }
                        else
                        {
                            attacker.AttackPacket = null;
                        }
                    }
                    #endregion

Scatter code in Handle.cs (For references)

Spoiler

Code:

                                #region Scatter
                                case 8001:
                                    {
                                        if (CanUseSpell(spell, attacker.Owner))
                                        {
                                            PrepareSpell(spell, attacker.Owner);

                                            SpellUse suse = new SpellUse(true);
                                            suse.Attacker = attacker.UID;
                                            suse.SpellID = spell.ID;
                                            suse.SpellLevel = spell.Level;
                                            suse.X = X;
                                            suse.Y = Y;
                                            if (attacker.xx == attacker.X && attacker.yy == attacker.Y)
                                            {
                                                attacker.scatter += 1;
                                                if (attacker.scatter > 50)
                                                {
                                                    attacker.Owner.Disconnect();
                                                }
                                            }
                                            else
                                            {
                                                attacker.xx = attacker.X;
                                                attacker.yy = attacker.Y;
                                                attacker.scatter = 0;
                                            }

                                            Sector sector = new Sector(attacker.X, attacker.Y, X, Y);
                                            sector.Arrange(spell.Sector, spell.Distance);
                                            foreach (Interfaces.IMapObject _obj in attacker.Owner.Screen.Objects)
                                            {
                                                if (_obj == null)
                                                    continue;
                                                if (_obj.MapObjType == MapObjectType.Monster || _obj.MapObjType == MapObjectType.Player)
                                                {
                                                    attacked = _obj as Entity;

                                                    if (sector.Inside(attacked.X, attacked.Y))
                                                    {
                                                        if (CanAttack(attacker, attacked, spell, attack.AttackType == Attack.Melee))
                                                        {
                                                            attack.Effect1 = Attack.AttackEffects1.None;
                                                            uint damage = Game.Attacking.Calculate.Ranged(attacker, attacked, spell);

                                                            ReceiveAttack(attacker, attacked, attack, damage, spell);

                                                            suse.Targets.Add(attacked.UID, damage);
                                                        }
                                                    }
                                                }
                                                else if (_obj.MapObjType == MapObjectType.SobNpc)
                                                {
                                                    attackedsob = _obj as SobNpcSpawn;

                                                    if (sector.Inside(attackedsob.X, attackedsob.Y))
                                                    {
                                                        if (CanAttack(attacker, attackedsob, spell))
                                                        {
                                                            attack.Effect1 = Attack.AttackEffects1.None;
                                                            uint damage = Game.Attacking.Calculate.Ranged(attacker, attackedsob);
                                                            suse.Effect1 = attack.Effect1;
                                                            if (damage == 0)
                                                                damage = 1;
                                                            damage = Game.Attacking.Calculate.Percent((int)damage, spell.PowerPercent);

                                                            ReceiveAttack(attacker, attackedsob, attack, damage, spell);

                                                            suse.Targets.Add(attackedsob.UID, damage);
                                                        }
                                                    }
                                                }
                                            }
                                            attacker.Owner.SendScreen(suse, true);
                                        }
                                        break;
                                    }
                                #endregion

SpellUse.cs

Spoiler

Code:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Conquer_Online_Server.Network.GamePackets
{
    public class SpellUse : Interfaces.IPacket
    {
        public enum EffectValue : uint
        {
            None = 0,
            Block = 1,
            Penetration = 2,
            CriticalStrike = 4,
            CriticalBlock = 5,
            WoodResist = 40,
            MetalResist = 48,
            EarthResist = 1,
            StudyPoints = 2,
        }

        public class DamageClass
        {
            public uint Damage;
            public bool Hit;

            public static implicit operator uint(DamageClass dmg)
            {
                return dmg.Damage;
            }
            public static implicit operator DamageClass(uint dmg)
            {
                return new DamageClass() { Damage = dmg, Hit = true };
            }
        }
        byte[] Buffer;

        public SpellUse(bool Create)
        {
            if (Create)
            {
                Buffer = new byte[8 + 20];
                Writer.WriteUInt16(20, 0, Buffer);
                Writer.WriteUInt16(1105, 2, Buffer);
            }
        }

        public uint Attacker
        {
            get { return BitConverter.ToUInt32(Buffer, 4); }
            set { Writer.WriteUInt32(value, 4, Buffer); }
        }

        public ushort X
        {
            get { return BitConverter.ToUInt16(Buffer, 8); }
            set { Writer.WriteUInt16(value, 8, Buffer); }
        }

        public ushort Y
        {
            get { return BitConverter.ToUInt16(Buffer, 10); }
            set { Writer.WriteUInt16(value, 10, Buffer); }
        }

        public ushort SpellID
        {
            get { return BitConverter.ToUInt16(Buffer, 12); }
            set { Writer.WriteUInt16(value, 12, Buffer); }
        }

        public ushort SpellLevel
        {
            get { return BitConverter.ToUInt16(Buffer, 14); }
            set { Writer.WriteUInt16(value, 14, Buffer); }
        }

        public SafeDictionary<uint, DamageClass> Targets = new SafeDictionary<uint, DamageClass>(40);
        public SafeDictionary<uint, EffectValue> Effect = new SafeDictionary<uint, EffectValue>(40);
        bool constC = false;
        public void MakeConst()
        {
            constC = true;
        }
        public void Deserialize(byte[] buffer)
        {
            this.Buffer = buffer;
        }

        public Attack.AttackEffects1 Effect1
        {
            get;
            set;
        }
        public Attack.AttackEffects2 Effect2
        {
            get;
            set;
        }

        public byte[] ToArray()
        {
            int count = 0;
            byte[] buffer = new byte[8 + 20 + 32 + Math.Min((uint)Targets.Count, (uint)30) * 32];
            Writer.WriteUInt16((ushort)(20 + 32 + Math.Min((uint)Targets.Count, (uint)30) * 32), 0, buffer);
            Writer.WriteUInt16(1105, 2, buffer);
            Writer.WriteUInt32(Attacker, 4, buffer);
            Writer.WriteUInt16(X, 8, buffer);
            Writer.WriteUInt16(Y, 10, buffer);
            Writer.WriteUInt16(SpellID, 12, buffer);
            Writer.WriteUInt16(SpellLevel, 14, buffer);
            Writer.WriteUInt32(Math.Min((uint)Targets.Count, (uint)30), 16, buffer);
            ushort offset = 20;
            uint uid = 0;
            foreach (KeyValuePair<uint, DamageClass> target in Targets.Base)
            {
                count++;
                if (count == 30)
                    break;
                if (constC)
                {
                    if (uid == 0)
                        uid = target.Key;
                    Writer.WriteUInt32(uid, offset, buffer);
                }
                else
                    Writer.WriteUInt32(target.Key, offset, buffer);
                offset += 4;
                Writer.WriteUInt32(target.Value.Damage, offset, buffer); offset += 4;
                Writer.WriteBoolean(target.Value.Hit, offset, buffer); offset += 4;
                if (Effect.ContainsKey(target.Key))
                    Writer.WriteByte((byte)Effect[target.Key], offset, buffer);
                offset += 4;
                offset += 16;
            }
            return buffer;
        }
        private byte[] toArray()
        {
            byte[] buffer = new byte[8 + 20 + 32 + Targets.Count * 32];
            Writer.WriteUInt16((ushort)(20 + 32 + Targets.Count * 32), 0, buffer);
            Writer.WriteUInt16(1105, 2, buffer);
            Writer.WriteUInt32(Attacker, 4, buffer);
            Writer.WriteUInt16(X, 8, buffer);
            Writer.WriteUInt16(Y, 10, buffer);
            Writer.WriteUInt16(SpellID, 12, buffer);
            Writer.WriteUInt16(SpellLevel, 14, buffer);
            Writer.WriteUInt32((uint)Targets.Count, 16, buffer);
            ushort offset = 20;
            uint uid = 0;
            foreach (KeyValuePair<uint, DamageClass> target in Targets.Base)
            {
                if (constC)
                {
                    if (uid == 0)
                        uid = target.Key;
                    Writer.WriteUInt32(uid, offset, buffer);
                }
                else
                    Writer.WriteUInt32(target.Key, offset, buffer);
                offset += 4;
                Writer.WriteUInt32(target.Value.Damage, offset, buffer); offset += 4;
                Writer.WriteBoolean(target.Value.Hit, offset, buffer); offset += 4;
                Writer.WriteBoolean(true, offset, buffer); offset += 4;//critical...
                offset += 16;
            }
            return buffer;
        }

        public void Send(Client.GameState client)
        {
            client.Send(Buffer);
        }
    }
}

I forgot to tell it, My source version is 5530.
If you need any more infos, ask me.

Thanks again :)

Quote:

Originally Posted by elhermanos

Thanks Yuki I didn't know it was that easy xD I still can't figure out why this bug is happening it's getting me crazy..

@Aceking the scatter case is only a reference because every ranged skills have this bug so it's probably deeper than that.

Yes your correct, every range spell will have the same bug if that bug lies within the CANUSE method.
Every spell will call that method, checking to see if they can use that spell.

You can breakpoint it, and follow it through for each attack....
Or a simple way to know if its making it through that section is to add something like write to console, or send a system message right after that call.
If you watch the client kill all the monsters without the effect, and that message isn't sent....then you know thats at least part of the problem and can start to work your way back....
I dont recommend doing it that way, as breakpointing is always the best method.....but its a pretty cheap way of going about it....