elmzeny

Untitled

Sep 4th, 2020
1,179
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using ProtoBuf;
  3. using System.Linq;
  4. using System.Collections.Generic;
  5. using System.IO;
  6.  
  7. namespace UchihaFamily.Network.GamePackets
  8. {
  9.     public class TryTrip : Interfaces.IPacket
  10.     {
  11.         [ProtoContract]
  12.         public class TryTripQuery
  13.         {
  14.             [ProtoMember(1)]
  15.             public uint Attacker;
  16.             [ProtoMember(2)]
  17.             public uint Attacked;
  18.             [ProtoMember(3)]
  19.             public ushort X;
  20.             [ProtoMember(4)]
  21.             public ushort Y;
  22.             [ProtoMember(5, IsRequired = true)]
  23.             public ushort SpellID;
  24.             [ProtoMember(6, IsRequired = true)]
  25.             public ushort SpellLevel;
  26.             [ProtoMember(7, IsRequired = true)]
  27.             public uint NextSpell;
  28.             [ProtoMember(8, IsRequired = true)]
  29.             public byte LevelJH;
  30.             [ProtoMember(9, IsRequired = true)]
  31.             public byte SpellEffect;
  32.             [ProtoMember(10)]
  33.             public DamageClass Damageclass;
  34.         }
  35.         [ProtoContract]
  36.         public class DamageClass
  37.         {
  38.             [ProtoMember(1, IsRequired = true)]
  39.             public uint UID;
  40.             [ProtoMember(2, IsRequired = true)]
  41.             public uint Damage;
  42.             [ProtoMember(3, IsRequired = true)]
  43.             public bool Hit;
  44.             [ProtoMember(4, IsRequired = true)]
  45.             public MsgInteract.InteractEffects Effect;
  46.             [ProtoMember(5)]
  47.             public uint un3;
  48.             [ProtoMember(6, IsRequired = true)]
  49.             public ushort newX;
  50.             [ProtoMember(7, IsRequired = true)]
  51.             public ushort newY;
  52.  
  53.             public static implicit operator uint(DamageClass dmg)
  54.             {
  55.                 return dmg.Damage;
  56.             }
  57.             public static implicit operator DamageClass(uint dmg)
  58.             {
  59.                 return new DamageClass()
  60.                 {
  61.                     Damage = dmg,
  62.                     Hit = true
  63.                 };
  64.             }
  65.         }
  66.         public MsgInteract.InteractEffects Effect1
  67.         {
  68.             get;
  69.             set;
  70.         }
  71.         public MsgInteract.InteractEffects2 Effect2
  72.         {
  73.             get;
  74.             set;
  75.         }
  76.         public TryTripQuery pQuery;
  77.         public TryTrip(bool Create)
  78.         {
  79.             if (Create)
  80.             {
  81.                 pQuery = new TryTripQuery();
  82.             }
  83.         }
  84.         public uint Attacker
  85.         {
  86.             get { return pQuery.Attacker; }
  87.             set { pQuery.Attacker = value; }
  88.         }
  89.         public uint Attacked
  90.         {
  91.             get { return pQuery.Attacked; }
  92.             set { pQuery.Attacked = value; }
  93.         }
  94.         public ushort SpellID
  95.         {
  96.             get { return pQuery.SpellID; }
  97.             set { pQuery.SpellID = value; }
  98.         }
  99.         public ushort SpellLevel
  100.         {
  101.             get { return pQuery.SpellLevel; }
  102.             set { pQuery.SpellLevel = value; }
  103.         }
  104.         public SafeDictionary<uint, DamageClass> Targets = new SafeDictionary<uint, DamageClass>();
  105.  
  106.         public void Deserialize(byte[] buffer)
  107.         {
  108.             this.pQuery = buffer.ConvertToProto<TryTripQuery>();
  109.         }
  110.         public uint Damage
  111.         {
  112.             get { return pQuery.Damageclass.Damage; }
  113.             set { pQuery.Damageclass.Damage = value; }
  114.         }
  115.         public uint Damage1
  116.         {
  117.             get { return pQuery.Damageclass.Damage; }
  118.             set { pQuery.Damageclass.Damage = value; }
  119.         }
  120.         public uint Damage2
  121.         {
  122.             get { return pQuery.Damageclass.Damage; }
  123.             set { pQuery.Damageclass.Damage = value; }
  124.         }
  125.         public MsgInteract.InteractEffects Eff1
  126.         {
  127.             get;
  128.             set;
  129.         }
  130.         public MsgInteract.InteractEffects Eff2
  131.         {
  132.             get;
  133.             set;
  134.         }
  135.         public MsgInteract.InteractEffects Eff3
  136.         {
  137.             get;
  138.             set;
  139.         }
  140.         public byte Count
  141.         {
  142.             get { return pQuery.SpellEffect; }
  143.             set { pQuery.SpellEffect = value; }
  144.         }
  145.         public byte[] ToArray()
  146.         {
  147.             foreach (KeyValuePair<uint, DamageClass> target in Targets)
  148.             {
  149.                 for (int x = 0; x < 3; x++)
  150.                 {
  151.                     pQuery.Damageclass = new DamageClass();
  152.                     pQuery.Damageclass.UID = target.Key;
  153.                     pQuery.Damageclass.Damage = target.Value.Damage;
  154.                     pQuery.Damageclass.Hit = target.Value.Hit;
  155.                     pQuery.Damageclass.Effect = target.Value.Effect;
  156.                     pQuery.Damageclass.newX = target.Value.newX;
  157.                     pQuery.Damageclass.newY = target.Value.newY;
  158.                 }
  159.             }
  160.             return Kernel.FinalizeProtoBuf(pQuery, (ushort)MsgTypes.MsgMagicEffect);
  161.         }
  162.         public void Send(Client.GameState client)
  163.         {
  164.             client.Send(ToArray());
  165.         }
  166.         internal TryTrip AddTarget(uint uid, DamageClass damage, MsgInteract attack)
  167.         {
  168.             if (attack != null)
  169.             {
  170.                 damage.Effect = attack.Effect;
  171.             }
  172.             Targets.Add(uid, damage);
  173.             return this;
  174.         }
  175.     }
  176.     public class MsgMagicEffect : Interfaces.IPacket
  177.     {
  178.         [ProtoContract]
  179.         public class MagicEffectQuery
  180.         {
  181.             [ProtoMember(1)]
  182.             public uint Attacker;
  183.             [ProtoMember(2)]
  184.             public uint Attacked;
  185.             [ProtoMember(3)]
  186.             public ushort X;
  187.             [ProtoMember(4)]
  188.             public ushort Y;
  189.             [ProtoMember(5, IsRequired = true)]
  190.             public ushort SpellID;
  191.             [ProtoMember(6, IsRequired = true)]
  192.             public ushort SpellLevel;
  193.             [ProtoMember(7, IsRequired = true)]
  194.             public uint NextSpell;
  195.             [ProtoMember(8, IsRequired = true)]
  196.             public byte LevelJH;
  197.             [ProtoMember(9, IsRequired = true)]
  198.             public byte SpellEffect;
  199.             [ProtoMember(10)]
  200.             public DamageClass Damageclass;
  201.         }
  202.         [ProtoContract]
  203.         public class DamageClass
  204.         {
  205.             [ProtoMember(1, IsRequired = true)]
  206.             public uint UID;
  207.             [ProtoMember(2, IsRequired = true)]
  208.             public uint Damage;
  209.             [ProtoMember(3, IsRequired = true)]
  210.             public bool Hit;
  211.             [ProtoMember(4, IsRequired = true)]
  212.             public MsgInteract.InteractEffects Effect;
  213.             [ProtoMember(5)]
  214.             public uint un3;
  215.             [ProtoMember(6, IsRequired = true)]
  216.             public ushort newX;
  217.             [ProtoMember(7, IsRequired = true)]
  218.             public ushort newY;
  219.  
  220.             public static implicit operator uint(DamageClass dmg)
  221.             {
  222.                 return dmg.Damage;
  223.             }
  224.             public static implicit operator DamageClass(uint dmg)
  225.             {
  226.                 return new DamageClass()
  227.                 {
  228.                     Damage = dmg,
  229.                     Hit = true
  230.                 };
  231.             }
  232.         }
  233.         public MagicEffectQuery pQuery;
  234.         public MsgMagicEffect(bool Create)
  235.         {
  236.             if (Create)
  237.             {
  238.                 pQuery = new MagicEffectQuery();
  239.             }
  240.         }
  241.         public uint Attacker
  242.         {
  243.             get { return pQuery.Attacker; }
  244.             set { pQuery.Attacker = value; }
  245.         }
  246.         public uint Attacker1 //x
  247.         {
  248.             get { return pQuery.Attacked; }
  249.             set { pQuery.Attacked = value; }
  250.         }
  251.         public ushort X
  252.         {
  253.             get { return pQuery.X; }
  254.             set { pQuery.X = value; }
  255.         }
  256.         public ushort Y
  257.         {
  258.             get { return pQuery.Y; }
  259.             set { pQuery.Y = value; }
  260.         }
  261.         public ushort SpellID
  262.         {
  263.             get { return pQuery.SpellID; }
  264.             set { pQuery.SpellID = value; }
  265.         }
  266.         public ushort SpellLevel
  267.         {
  268.             get { return pQuery.SpellLevel; }
  269.             set { pQuery.SpellLevel = value; }
  270.         }
  271.         public byte LevelHu
  272.         {
  273.             get { return pQuery.LevelJH; }
  274.             set { pQuery.LevelJH = value; }
  275.         }
  276.         public byte SpellEffect
  277.         {
  278.             get { return pQuery.SpellEffect; }
  279.             set { pQuery.SpellEffect = value; }
  280.         }
  281.         public byte SpecialEffect
  282.         {
  283.             get { return pQuery.SpellEffect; }
  284.             set { pQuery.SpellEffect = value; }
  285.         }
  286.         public MsgInteract.InteractEffects Effect { get; set; }
  287.         public MsgInteract.InteractEffects2 Effect2 { get; set; }
  288.         public SafeDictionary<uint, DamageClass> Targets = new SafeDictionary<uint, DamageClass>();
  289.  
  290.         public void Deserialize(byte[] buffer)
  291.         {
  292.             this.pQuery = buffer.ConvertToProto<MagicEffectQuery>();
  293.         }
  294.         private const int TargetLimit = 30;
  295.  
  296.         public byte[] ToArray()
  297.         {
  298.             if (Targets.Count <= TargetLimit)
  299.             {
  300.                 if (Kernel.GamePool.ContainsKey(Attacker))
  301.                     if (Kernel.GamePool[Attacker].Spells != null)
  302.                         if (Kernel.GamePool[Attacker].Spells[SpellID] != null)
  303.                             LevelHu = Kernel.GamePool[Attacker].Spells[SpellID].LevelHu2;
  304.  
  305.                 foreach (KeyValuePair<uint, DamageClass> target in Targets)
  306.                 {
  307.                     pQuery.Damageclass = new DamageClass();
  308.                     pQuery.Damageclass.UID = target.Key;
  309.                     pQuery.Damageclass.Damage = target.Value.Damage;
  310.                     pQuery.Damageclass.Hit = target.Value.Hit;
  311.                     pQuery.Damageclass.Effect = target.Value.Effect;
  312.                     pQuery.Damageclass.newX = target.Value.newX;
  313.                     pQuery.Damageclass.newY = target.Value.newY;
  314.                 }
  315.                 return Kernel.FinalizeProtoBuf(pQuery, (ushort)MsgTypes.MsgMagicEffect);
  316.             }
  317.             else
  318.             {
  319.                 var array = Targets.ToArray();
  320.                 for (int i = 0; i < array.Length; i += TargetLimit)
  321.                 {
  322.                     int targets = array.Length - i;
  323.                     if (targets > TargetLimit) targets = TargetLimit;
  324.  
  325.                     if (Kernel.GamePool.ContainsKey(Attacker))
  326.                         if (Kernel.GamePool[Attacker].Spells != null)
  327.                             if (Kernel.GamePool[Attacker].Spells[SpellID] != null)
  328.                                 LevelHu = Kernel.GamePool[Attacker].Spells[SpellID].LevelHu2;
  329.  
  330.                     for (int j = 0; j < targets; j++)
  331.                     {
  332.                         KeyValuePair<uint, DamageClass> target = array[i + j];
  333.                         pQuery.Damageclass = new DamageClass();
  334.                         pQuery.Damageclass.UID = target.Key;
  335.                         pQuery.Damageclass.Damage = target.Value.Damage;
  336.                         pQuery.Damageclass.Hit = target.Value.Hit;
  337.                         pQuery.Damageclass.Effect = target.Value.Effect;
  338.                         pQuery.Damageclass.newX = target.Value.newX;
  339.                         pQuery.Damageclass.newY = target.Value.newY;
  340.                     }
  341.                 }
  342.                 return Kernel.FinalizeProtoBuf(pQuery, (ushort)MsgTypes.MsgMagicEffect);
  343.             }
  344.         }
  345.  
  346.         public void Send(Client.GameState client)
  347.         {
  348.             client.Send(ToArray());
  349.         }
  350.         internal MsgMagicEffect AddTarget(Interfaces.IMapObject obj, DamageClass damage, MsgInteract attack)
  351.         {
  352.             if (attack != null)
  353.             {
  354.                 damage.Effect = attack.Effect;
  355.             }
  356.             if (obj.MapObjType == Game.MapObjectType.SobNpc)
  357.             {
  358.                 var attacked = obj as MsgNpcInfoEX;
  359.                 Targets.Add(attacked.UID, damage);
  360.             }
  361.             else if (obj.MapObjType == Game.MapObjectType.Player || obj.MapObjType == Game.MapObjectType.Monster)
  362.             {
  363.                 var attacked = obj as Game.Player;
  364.                 Targets.Add(attacked.UID, damage);
  365.             }
  366.             return this;
  367.         }
  368.         internal MsgMagicEffect AddTarget(uint uid, DamageClass damage, MsgInteract attack)
  369.         {
  370.             if (attack != null)
  371.             {
  372.                 damage.Effect = attack.Effect;
  373.             }
  374.             Targets.Add(uid, damage);
  375.             return this;
  376.         }
  377.     }
  378. }
RAW Paste Data