Criando um Conquer
Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Scripts e SQLs, Versões 5095, 5165, 5375, 5530, 5700, 5800, 5900, 6000 - Criando um Conquer Tutoriais


Como fixar o triple attack do monk!

Criando um Conquer :: Solução de Problemas

Ir para baixo

Como fixar o triple attack do monk! Empty Como fixar o triple attack do monk!

Mensagem por FelipeXP Seg Set 07, 2015 8:52 pm

Abra a SpellUse.Cs e apague todo o código dela Shocked.
E cole esse no lugar !

Código:
using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;

namespace HarryPotter.Network.GamePackets
{
    public class Attacked { public ushort X, Y; public HarryPotter.Game.Enums.ConquerAngle Facing;}
    public class TryTrip : Interfaces.IPacket
    {
        public class DamageClass
        {
            public uint Damage;
            public bool Hit;
            public Attack.AttackEffects1 Eff1;
            public Attack.AttackEffects2 Eff2;
            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;
        internal TryTrip AddTarget(uint uid, DamageClass damage, Attack attack)
        {
            if (attack != null)
            {
                damage.Eff1 = attack.Effect1;
                damage.Eff2 = attack.Effect2;
            }
            Targets.Add(uid, damage);
            return this;
        }
        public Attack.AttackEffects1 Effect1
        {
            get;
            set;
        }
        public Attack.AttackEffects2 Effect2
        {
            get;
            set;
        }
        public TryTrip(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 uint Attacked
        {
            get { return BitConverter.ToUInt32(Buffer, 8); }
            set { Writer.WriteUInt32(value, 8, 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>();
        public void Deserialize(byte[] buffer)
        {
            this.Buffer = buffer;
        }
        public uint Damage
        {
            get { return BitConverter.ToUInt32(Buffer, 24); }
            set { Writer.WriteUInt32(value, 24, Buffer); }
        }
        public byte[] ToArray()
        {
            byte[] buffer = new byte[156];
            Writer.WriteUInt16(148, 0, buffer);
            Writer.WriteUInt16(1105, 2, buffer);
            Writer.WriteUInt32(Attacker, 4, buffer);
            Writer.WriteUInt32(Attacked, 8, buffer);
            Writer.WriteUInt16(SpellID, 12, buffer);
            Writer.WriteUInt16(SpellLevel, 14, buffer);
            Writer.WriteUInt32(3 << 8, 18, buffer);
            Writer.WriteByte(1, 20, Buffer);
            Writer.WriteByte(1, 21, Buffer);
            Writer.WriteByte(1, 22, Buffer);
            ushort offset = 24;
            foreach (KeyValuePair<uint, DamageClass> target in Targets)
            {
                for (int x = 0; x < 3; x++)
                {
                    Writer.WriteUInt32(target.Key, offset, buffer); offset += 4;
                    Writer.WriteUInt32(target.Value.Damage / 3, offset, buffer); offset += 4;
                    Writer.WriteBoolean(target.Value.Hit, offset, buffer); offset += 4;
                    Writer.WriteByte((Byte)target.Value.Eff1, offset, buffer); offset += 1;
                    Writer.WriteByte((Byte)target.Value.Eff2, offset, buffer); offset += 1;
                    offset += 18;
                }
            }
            return buffer;
        }
        public void Send(Client.GameState client)
        {
            client.Send(Buffer);
        }
    }  
    public class SpellUse : Interfaces.IPacket
    {
        public class DamageClass
        {
            public uint Damage;
            public bool Hit;
            public ushort newX, newY;
            public Attack.AttackEffects1 Eff1;
            public Attack.AttackEffects2 Eff2;

            public static implicit operator uint(SpellUse.DamageClass dmg)
            {
                return dmg.Damage;
            }

            public static implicit operator SpellUse.DamageClass(uint dmg)
            {
                return new SpellUse.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);
                LevelHu = (byte)Kernel.Random.Next(1, 2);
            }
        }
        public byte SoulLevel
        {
            get { return Buffer[20]; }
            set { Writer.WriteByte(value, 20, Buffer); }
        }
        public byte SoulType
        {
            get { return Buffer[21]; }
            set { Writer.WriteByte(value, 21, Buffer); }
        }
        public uint Attacker
        {
            get { return BitConverter.ToUInt32(Buffer, 4); }
            set { Writer.WriteUInt32(value, 4, Buffer); }
        }
        public uint Attacker1
        {
            get { return BitConverter.ToUInt32(Buffer, 8); }
            set { Writer.WriteUInt32(value, 8, 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 byte LevelHu
        {
            get { return Buffer[18]; }
            set
            {

                Buffer[18] = value;
            }
        }

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

        public SafeDictionary<uint, DamageClass> Targets = new SafeDictionary<uint, DamageClass>();

        public void Deserialize(byte[] buffer)
        {
            this.Buffer = buffer;
        }
        const int TargetLimit = 30;
        public byte[] ToArray()
        {
            if (Targets.Count <= TargetLimit)
            {
                byte[] buffer = new byte[61 + Targets.Count * 32];
                Writer.WriteUInt16((ushort)(buffer.Length - 8), 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);

                if (Kernel.GamePool.ContainsKey(Attacker))
                    if (Kernel.GamePool[Attacker].Spells != null)
                        if (Kernel.GamePool[Attacker].Spells[SpellID] != null)
                            LevelHu = Kernel.GamePool[Attacker].Spells[SpellID].LevelHu2;
                Writer.WriteByte(LevelHu, 18, buffer);


                Writer.WriteUInt32((uint)(Targets.Count/* << 8*/), 19, buffer);
                ushort offset = 24;
                foreach (KeyValuePair<uint, DamageClass> target in Targets)
                {
                    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.WriteByte((Byte)target.Value.Eff1, offset, buffer); offset += 1;
                    Writer.WriteByte((Byte)target.Value.Eff2, offset, buffer); offset += 1;
                    offset += 6;
                    Writer.WriteUInt32(target.Value.newX, offset, buffer); offset += 4;
                    Writer.WriteUInt32(target.Value.newY, offset, buffer); offset += 8;
                }
                return buffer;
            }
            else
            {
                using (MemoryStream stream = new MemoryStream())
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    var array = Targets.ToArray();
                    for (int i = 0; i < array.Length; i += TargetLimit)
                    {
                        int targets = array.Length - i;
                        if (targets > TargetLimit) targets = TargetLimit;

                        byte[] buffer = new byte[61 + targets * 32];
                        Writer.WriteUInt16((ushort)(buffer.Length - 8), 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);

                        if (Kernel.GamePool.ContainsKey(Attacker))
                            if (Kernel.GamePool[Attacker].Spells != null)
                                if (Kernel.GamePool[Attacker].Spells[SpellID] != null)
                                    LevelHu = Kernel.GamePool[Attacker].Spells[SpellID].LevelHu2;
                        Writer.WriteByte(LevelHu, 18, buffer);



                        Writer.WriteUInt32((uint)(targets/* << 8*/), 19, buffer);
                        ushort offset = 24;
                        for (int j = 0; j < targets; j++)
                        {
                            KeyValuePair<uint, DamageClass> target = array[i + j];
                            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.WriteByte((Byte)target.Value.Eff1, offset, buffer); offset += 1;
                            Writer.WriteByte((Byte)target.Value.Eff2, offset, buffer); offset += 1;
                            offset += 6;
                            Writer.WriteUInt32(target.Value.newX, offset, buffer); offset += 4;
                            Writer.WriteUInt32(target.Value.newY, offset, buffer); offset += 8;
                        }
                        Writer.WriteString("TQServer", buffer.Length - 8, buffer);
                        writer.Write(buffer, 0, buffer.Length);
                    }
                    return stream.ToArray();
                }
            }
        }
        public void Send(Client.GameState client)
        {
            client.Send(Buffer);
        }

        /* internal SpellUse AddTarget(uint uid, uint damage, Attack attack)
         {
             DamageClass cls = new DamageClass() { Damage = damage, Hit = true };
             if (attack != null)
             {
                 cls.Eff1 = attack.Effect1;
                 cls.Eff2 = attack.Effect2;
             }
             Targets.Add(uid, cls);
             return this;
         }*/
        internal SpellUse AddTarget(Interfaces.IMapObject obj, DamageClass damage, Attack attack)
        {
            if (attack != null)
            {
                damage.Eff1 = attack.Effect1;
                damage.Eff2 = attack.Effect2;
            }
            if (obj.MapObjType == Game.MapObjectType.SobNpc)
            {
                var attacked = obj as SobNpcSpawn;
                Targets.Add(attacked.UID, damage);
            }
            else if (obj.MapObjType == Game.MapObjectType.Player || obj.MapObjType == Game.MapObjectType.Monster)
            {
                var attacked = obj as Game.Entity;
                Targets.Add(attacked.UID, damage);
            }
            return this;
        }
    }
}  

Agora procure por #region Single target e cole isso no lugar

Código:
#region Single target
                                case 11140:
                                case 10490:
                                    {
                                        if (CanUseSpell(spell, attacker.Owner))
                                        {
                                            PrepareSpell(spell, attacker.Owner);

                                            TryTrip suse = new TryTrip(true);
                                            suse.Attacker = attacker.UID;
                                            suse.SpellID = spell.ID;

                                            suse.SpellLevel = spell.Level;

                                            if (Kernel.GetDistance(attacker.X, attacker.Y, X, Y) <= attacker.AttackRange + 1)
                                            {
                                                if (attackedsob != null)
                                                {
                                                    if (CanAttack(attacker, attackedsob, spell))
                                                    {
                                                        PrepareSpell(spell, attacker.Owner);
                                                        attack.Effect1 = Attack.AttackEffects1.None;
                                                        uint damage = Game.Attacking.Calculate.Melee(attacker, attackedsob, ref attack);
                                                        //damage = (uint)(damage * spell.PowerPercent);
                                                        ReceiveAttack(attacker, attackedsob, attack, damage, spell);
                                                        suse.Damage = damage;
                                                        suse.Attacked = attackedsob.UID;
                                                        suse.Effect1 = attack.Effect1;
                                                        suse.AddTarget(attackedsob.UID, damage, attack);
                                                    }
                                                }
                                                else
                                                {
                                                    if (CanAttack(attacker, attacked, spell, attack.AttackType == Attack.Melee))
                                                    {
                                                        PrepareSpell(spell, attacker.Owner);

                                                        attack.Effect1 = Attack.AttackEffects1.None;
                                                        uint damage = Game.Attacking.Calculate.Melee(attacker, attacked, spell, ref attack);

                                                        ReceiveAttack(attacker, attacked, attack, ref damage, spell);
                                                        suse.Damage = damage;
                                                        suse.Attacked = attacked.UID;
                                                        suse.Effect1 = attack.Effect1;
                                                        suse.AddTarget(attacked.UID, damage, attack);
                                                    }
                                                }
                                                attacker.AttackPacket = null;
                                            }
                                            else
                                            {
                                                attacker.AttackPacket = null;
                                            }
                                            attacker.Owner.SendScreen(suse, true);
                                        }
                                        attacker.AttackPacket = null;
                                        break;
                                    }
                                case 1290:
                                case 5030:
                                case 5040:
                                case 7000:
                                case 7010:
                                case 7030:
                                case 7040:
                                case 10381:

                                    //case 10490:
                                    {
                                        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;
                                            http://suse.SpellLevelHu = client_Spell.LevelHu2;
                                            suse.X = X;
                                            suse.Y = Y;

                                            if (Kernel.GetDistance(attacker.X, attacker.Y, X, Y) <= attacker.AttackRange + 1)
                                            {
                                                if (attackedsob != null)
                                                {
                                                    if (CanAttack(attacker, attackedsob, spell))
                                                    {
                                                        PrepareSpell(spell, attacker.Owner);
                                                        attack.Effect1 = Attack.AttackEffects1.None;
                                                        uint damage = Game.Attacking.Calculate.Melee(attacker, attackedsob, ref attack);
                                                        damage = (uint)(damage * spell.PowerPercent);
                                                        ReceiveAttack(attacker, attackedsob, attack, damage, spell);

                                                        suse.AddTarget(attackedsob, damage, attack);
                                                    }
                                                }
                                                else
                                                {
                                                    if (CanAttack(attacker, attacked, spell, attack.AttackType == Attack.Melee))
                                                    {
                                                        PrepareSpell(spell, attacker.Owner);

                                                        attack.Effect1 = Attack.AttackEffects1.None;
                                                        uint damage = Game.Attacking.Calculate.Melee(attacker, attacked, spell, ref attack, client_Spell.LevelHu2);
                                                        damage = (uint)((damage * 120) / 100);
                                                        suse.Effect1 = attack.Effect1;

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

                                                        suse.AddTarget(attacked, damage, attack);
                                                    }
                                                }
                                                attacker.AttackPacket = null;
                                            }
                                            else
                                            {
                                                attacker.AttackPacket = null;
                                            }
                                            attacker.Owner.SendScreen(suse, true);
                                        }
                                        attacker.AttackPacket = null;
                                        break;
                                    }
                                #endregion
Very Happy

FelipeXP
Membro
Membro

Mensagens : 320
Data de inscrição : 28/05/2014

https://www.youtube.com/channel/UCOmLJd3M1OSrMmlcR7UGlhw

Ir para o topo Ir para baixo

Ir para o topo

- Tópicos semelhantes

Criando um Conquer :: Solução de Problemas

 
Permissões neste sub-fórum
Não podes responder a tópicos