XConquer

Untitled

Jul 1st, 2015
207
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Linq;
  3. using System.Collections.Generic;
  4. using System.IO;
  5.  
  6. namespace CM.Arg.Network.GamePackets
  7. {
  8.     public class Attacked { public ushort X, Y; public CM.Arg.Game.Enums.ConquerAngle Facing;}
  9.     public class TryTrip : Interfaces.IPacket
  10.     {
  11.         public class DamageClass
  12.         {
  13.             public uint Damage;
  14.             public bool Hit;
  15.  
  16.             public static implicit operator uint(DamageClass dmg)
  17.             {
  18.                 return dmg.Damage;
  19.             }
  20.             public static implicit operator DamageClass(uint dmg)
  21.             {
  22.                 return new DamageClass() { Damage = dmg, Hit = true };
  23.             }
  24.         }
  25.         byte[] Buffer;
  26.  
  27.         public TryTrip(bool Create)
  28.         {
  29.             if (Create)
  30.             {
  31.                 Buffer = new byte[8 + 20];
  32.                 Writer.WriteUInt16(20, 0, Buffer);
  33.                 Writer.WriteUInt16(1105, 2, Buffer);
  34.             }
  35.         }
  36.  
  37.         public uint Attacker
  38.         {
  39.             get { return BitConverter.ToUInt32(Buffer, 4); }
  40.             set { Writer.WriteUInt32(value, 4, Buffer); }
  41.         }
  42.         public uint Attacked
  43.         {
  44.             get { return BitConverter.ToUInt32(Buffer, 8); }
  45.             set { Writer.WriteUInt32(value, 8, Buffer); }
  46.         }
  47.  
  48.         public ushort SpellID
  49.         {
  50.             get { return BitConverter.ToUInt16(Buffer, 12); }
  51.             set { Writer.WriteUInt16(value, 12, Buffer); }
  52.         }
  53.  
  54.         public ushort SpellLevel
  55.         {
  56.             get { return BitConverter.ToUInt16(Buffer, 14); }
  57.             set { Writer.WriteUInt16(value, 14, Buffer); }
  58.         }
  59.  
  60.         public SafeDictionary<uint, DamageClass> Targets = new SafeDictionary<uint, DamageClass>();
  61.  
  62.         public void Deserialize(byte[] buffer)
  63.         {
  64.             this.Buffer = buffer;
  65.         }
  66.         public uint Damage
  67.         {
  68.             get { return BitConverter.ToUInt32(Buffer, 24); }
  69.             set { Writer.WriteUInt32(value, 24, Buffer); }
  70.  
  71.         }
  72.         public byte[] ToArray()
  73.         {
  74.             byte[] buffer = new byte[156];
  75.             Writer.WriteUInt16(148, 0, buffer);
  76.             Writer.WriteUInt16(1105, 2, buffer);
  77.             Writer.WriteUInt32(Attacker, 4, buffer);
  78.             Writer.WriteUInt32(Attacked, 8, buffer);
  79.             Writer.WriteUInt16(SpellID, 12, buffer);
  80.             Writer.WriteUInt16(SpellLevel, 14, buffer);
  81.             Writer.WriteUInt32(3, 19, buffer);
  82.             int offset = 20;
  83.             for (int i = 0; i < 3; i++)
  84.             {
  85.                 Writer.WriteUInt32(Attacked, offset, buffer);
  86.                 Writer.WriteUInt32(Damage / 3, offset + 4, buffer);
  87.                 offset += 32;
  88.             }
  89.             return buffer;
  90.         }
  91.         public void Send(Client.GameState client)
  92.         {
  93.             client.Send(Buffer);
  94.         }
  95.     }
  96.     public class SpellUse : Interfaces.IPacket
  97.     {
  98.         public class DamageClass
  99.         {
  100.             public uint Damage;
  101.             public bool Hit;
  102.             public ushort newX, newY;
  103.             public Attack.AttackEffects1 Eff1;
  104.             public Attack.AttackEffects2 Eff2;
  105.  
  106.             public static implicit operator uint(SpellUse.DamageClass dmg)
  107.             {
  108.                 return dmg.Damage;
  109.             }
  110.  
  111.             public static implicit operator SpellUse.DamageClass(uint dmg)
  112.             {
  113.                 return new SpellUse.DamageClass { Damage = dmg, Hit = true };
  114.             }
  115.         }
  116.         byte[] Buffer;
  117.  
  118.         public SpellUse(bool Create)
  119.         {
  120.             if (Create)
  121.             {
  122.                 Buffer = new byte[8 + 20];
  123.                 Writer.WriteUInt16(20, 0, Buffer);
  124.                 Writer.WriteUInt16(1105, 2, Buffer);
  125.                 LevelHu = (byte)Kernel.Random.Next(1, 2);
  126.             }
  127.         }
  128.         public byte SoulLevel
  129.         {
  130.             get { return Buffer[20]; }
  131.             set { Writer.WriteByte(value, 20, Buffer); }
  132.         }
  133.         public byte SoulType
  134.         {
  135.             get { return Buffer[21]; }
  136.             set { Writer.WriteByte(value, 21, Buffer); }
  137.         }
  138.         public uint Attacker
  139.         {
  140.             get { return BitConverter.ToUInt32(Buffer, 4); }
  141.             set { Writer.WriteUInt32(value, 4, Buffer); }
  142.         }
  143.         public uint Attacker1
  144.         {
  145.             get { return BitConverter.ToUInt32(Buffer, 8); }
  146.             set { Writer.WriteUInt32(value, 8, Buffer); }
  147.         }
  148.  
  149.         public ushort X
  150.         {
  151.             get { return BitConverter.ToUInt16(Buffer, 8); }
  152.             set { Writer.WriteUInt16(value, 8, Buffer); }
  153.         }
  154.  
  155.         public ushort Y
  156.         {
  157.             get { return BitConverter.ToUInt16(Buffer, 10); }
  158.             set { Writer.WriteUInt16(value, 10, Buffer); }
  159.         }
  160.  
  161.         public ushort SpellID
  162.         {
  163.             get { return BitConverter.ToUInt16(Buffer, 12); }
  164.             set { Writer.WriteUInt16(value, 12, Buffer); }
  165.         }
  166.  
  167.         public ushort SpellLevel
  168.         {
  169.             get { return BitConverter.ToUInt16(Buffer, 14); }
  170.             set { Writer.WriteUInt16(value, 14, Buffer); }
  171.         }
  172.  
  173.         public byte LevelHu
  174.         {
  175.             get { return Buffer[18]; }
  176.             set
  177.             {
  178.  
  179.                 Buffer[18] = value;
  180.             }
  181.         }
  182.  
  183.         public Attack.AttackEffects1 Effect1
  184.         {
  185.             get;
  186.             set;
  187.         }
  188.         public Attack.AttackEffects2 Effect2
  189.         {
  190.             get;
  191.             set;
  192.         }
  193.  
  194.         public SafeDictionary<uint, DamageClass> Targets = new SafeDictionary<uint, DamageClass>();
  195.  
  196.         public void Deserialize(byte[] buffer)
  197.         {
  198.             this.Buffer = buffer;
  199.         }
  200.         const int TargetLimit = 30;
  201.         public byte[] ToArray()
  202.         {
  203.             if (Targets.Count <= TargetLimit)
  204.             {
  205.                 byte[] buffer = new byte[61 + Targets.Count * 32];
  206.                 Writer.WriteUInt16((ushort)(buffer.Length - 8), 0, buffer);
  207.                 Writer.WriteUInt16(1105, 2, buffer);
  208.                 Writer.WriteUInt32(Attacker, 4, buffer);
  209.                 Writer.WriteUInt16(X, 8, buffer);
  210.                 Writer.WriteUInt16(Y, 10, buffer);
  211.                 Writer.WriteUInt16(SpellID, 12, buffer);
  212.                 Writer.WriteUInt16(SpellLevel, 14, buffer);
  213.  
  214.                 if (Kernel.GamePool.ContainsKey(Attacker))
  215.                     if (Kernel.GamePool[Attacker].Spells != null)
  216.                         if (Kernel.GamePool[Attacker].Spells[SpellID] != null)
  217.                             LevelHu = Kernel.GamePool[Attacker].Spells[SpellID].LevelHu2;
  218.                 Writer.WriteByte(LevelHu, 18, buffer);
  219.  
  220.  
  221.                 Writer.WriteUInt32((uint)(Targets.Count/* << 8*/), 19, buffer);
  222.                 ushort offset = 24;
  223.                 foreach (KeyValuePair<uint, DamageClass> target in Targets)
  224.                 {
  225.                     Writer.WriteUInt32(target.Key, offset, buffer); offset += 4;
  226.                     Writer.WriteUInt32(target.Value.Damage, offset, buffer); offset += 4;
  227.                     Writer.WriteBoolean(target.Value.Hit, offset, buffer); offset += 4;
  228.                     Writer.WriteByte((Byte)target.Value.Eff1, offset, buffer); offset += 1;
  229.                     Writer.WriteByte((Byte)target.Value.Eff2, offset, buffer); offset += 1;
  230.                     offset += 6;
  231.                     Writer.WriteUInt32(target.Value.newX, offset, buffer); offset += 4;
  232.                     Writer.WriteUInt32(target.Value.newY, offset, buffer); offset += 8;
  233.                 }
  234.                 return buffer;
  235.             }
  236.             else
  237.             {
  238.                 using (MemoryStream stream = new MemoryStream())
  239.                 using (BinaryWriter writer = new BinaryWriter(stream))
  240.                 {
  241.                     var array = Targets.ToArray();
  242.                     for (int i = 0; i < array.Length; i += TargetLimit)
  243.                     {
  244.                         int targets = array.Length - i;
  245.                         if (targets > TargetLimit) targets = TargetLimit;
  246.  
  247.                         byte[] buffer = new byte[61 + targets * 32];
  248.                         Writer.WriteUInt16((ushort)(buffer.Length - 8), 0, buffer);
  249.                         Writer.WriteUInt16(1105, 2, buffer);
  250.                         Writer.WriteUInt32(Attacker, 4, buffer);
  251.                         Writer.WriteUInt16(X, 8, buffer);
  252.                         Writer.WriteUInt16(Y, 10, buffer);
  253.                         Writer.WriteUInt16(SpellID, 12, buffer);
  254.                         Writer.WriteUInt16(SpellLevel, 14, buffer);
  255.  
  256.                         if (Kernel.GamePool.ContainsKey(Attacker))
  257.                             if (Kernel.GamePool[Attacker].Spells != null)
  258.                                 if (Kernel.GamePool[Attacker].Spells[SpellID] != null)
  259.                                     LevelHu = Kernel.GamePool[Attacker].Spells[SpellID].LevelHu2;
  260.                         Writer.WriteByte(LevelHu, 18, buffer);
  261.  
  262.  
  263.  
  264.                         Writer.WriteUInt32((uint)(targets/* << 8*/), 19, buffer);
  265.                         ushort offset = 24;
  266.                         for (int j = 0; j < targets; j++)
  267.                         {
  268.                             KeyValuePair<uint, DamageClass> target = array[i + j];
  269.                             Writer.WriteUInt32(target.Key, offset, buffer); offset += 4;
  270.                             Writer.WriteUInt32(target.Value.Damage, offset, buffer); offset += 4;
  271.                             Writer.WriteBoolean(target.Value.Hit, offset, buffer); offset += 4;
  272.                             Writer.WriteByte((Byte)target.Value.Eff1, offset, buffer); offset += 1;
  273.                             Writer.WriteByte((Byte)target.Value.Eff2, offset, buffer); offset += 1;
  274.                             offset += 6;
  275.                             Writer.WriteUInt32(target.Value.newX, offset, buffer); offset += 4;
  276.                             Writer.WriteUInt32(target.Value.newY, offset, buffer); offset += 8;
  277.                         }
  278.                         Writer.WriteString("TQServer", buffer.Length - 8, buffer);
  279.                         writer.Write(buffer, 0, buffer.Length);
  280.                     }
  281.                     return stream.ToArray();
  282.                 }
  283.             }
  284.         }
  285.         public void Send(Client.GameState client)
  286.         {
  287.             client.Send(Buffer);
  288.         }
  289.  
  290.         internal SpellUse AddTarget1(Interfaces.IMapObject obj, DamageClass damage, Attack attack)
  291.         {
  292.             if (attack != null)
  293.             {
  294.                 damage.Eff1 = attack.Effect1;
  295.                 damage.Eff2 = attack.Effect2;
  296.             }
  297.             if (obj.MapObjType == Game.MapObjectType.SobNpc)
  298.             {
  299.                 var attacked = obj as SobNpcSpawn;
  300.                 Targets.Add(attacked.UID, damage);
  301.             }
  302.             else if (obj.MapObjType == Game.MapObjectType.Player || obj.MapObjType == Game.MapObjectType.Monster)
  303.             {
  304.                 var attacked = obj as Game.Entity;
  305.                 Targets.Add(attacked.UID, damage);
  306.             }
  307.             return this;
  308.         }
  309.         internal SpellUse AddTarget(Interfaces.IMapObject obj, DamageClass damage, Attack attack)
  310.         {
  311.             if (attack != null)
  312.             {
  313.                 damage.Eff1 = attack.Effect1;
  314.                 damage.Eff2 = attack.Effect2;
  315.             }
  316.             if (obj.MapObjType == Game.MapObjectType.SobNpc)
  317.             {
  318.                 var attacked = obj as SobNpcSpawn;
  319.                 Targets.Add(attacked.UID, damage);
  320.             }
  321.             else if (obj.MapObjType == Game.MapObjectType.Player || obj.MapObjType == Game.MapObjectType.Monster)
  322.             {
  323.                 var attacked = obj as Game.Entity;
  324.                 Targets.Add(attacked.UID, damage);
  325.             }
  326.             return this;
  327.         }
  328.     }
  329. }
RAW Paste Data