API tools faq
paste
Advertisement
Guest User

Update By Over

a guest
May 5th, 2016
60
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.21 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using OverDrive.Game;
  3. using System.Collections.Generic;
  4.  
  5. namespace OverDrive.Network.GamePackets
  6. {
  7. public unsafe class ConquerItem : Writer, Interfaces.IPacket
  8. {
  9. public const ushort
  10. Inventory = 0,
  11. Head = 1,
  12. Necklace = 2,
  13. Armor = 3,
  14. RightWeapon = 4,
  15. LeftWeapon = 5,
  16. Ring = 6,
  17. Bottle = 7,
  18. Boots = 8,
  19. Garment = 9,
  20. Fan = 10,
  21. Tower = 11,
  22. Steed = 12,
  23. Wing = 19,
  24. NewWing = 20,
  25. RightWeaponAccessory = 15,
  26. LeftWeaponAccessory = 16,
  27. SteedArmor = 17,
  28. SteedCrop = 18,
  29. SteedWing = 19,
  30. AlternateHead = 21,
  31. AlternateNecklace = 22,
  32. AlternateArmor = 23,
  33. AlternateRightWeapon = 24,
  34. AlternateLeftWeapon = 25,
  35. AlternateRing = 26,
  36. AlternateBottle = 27,
  37. AlternateBoots = 28,
  38. AlternateGarment = 29,
  39. Remove = 255;
  40.  
  41. public const uint GoldPrize = 2100075;
  42. public bool IsWorn = false;
  43. public byte[] Buffer;
  44. public bool InWardrobe { get; set; }
  45. public static Counter ItemUID = new Counter(0);
  46. private UInt32 mRefineItem = 0;
  47. private DateTime mRefineryTime;
  48. private ulong suspiciousStart = 0, unlockEnd = 0;
  49. private bool unlocking = false;
  50. private ushort warehouse = 0;
  51. public static ushort NWing;
  52. public Dictionary<uint, string> Agate_map
  53. {
  54. get;
  55. set;
  56. }
  57. public DateTime RefineryStarted
  58. {
  59. get;
  60. set;
  61. }
  62. public byte Days
  63. {
  64. get;
  65. set;
  66. }
  67. private int _Active;
  68. public int Active
  69. {
  70. get
  71. {
  72. return _Active;
  73. }
  74. set
  75. {
  76. _Active = value;
  77. }
  78. }
  79. public DateTime DayStamp
  80. {
  81. get;
  82. set;
  83. }
  84. public ushort MaxStackSize
  85. {
  86. get;
  87. set;
  88. }
  89. public bool MobDropped
  90. {
  91. get;
  92. set;
  93. }
  94. public bool StatsLoaded
  95. {
  96. get;
  97. set;
  98. }
  99. public string Agate
  100. {
  101. get;
  102. set;
  103. }
  104. public ItemAdding.Purification_ Purification;
  105. public ItemAdding.Refinery_ ExtraEffect;
  106. public Network.GamePackets.Auction AuctionInfo
  107. {
  108. get;
  109. set;
  110. }
  111.  
  112. public ConquerItem(bool Create)
  113. {
  114. if (Create)
  115. {
  116. Agate_map = new Dictionary<uint, string>(10);
  117. Buffer = new byte[92];
  118. WriteUInt16(84, 0, Buffer);
  119. WriteUInt16(1008, 2, Buffer);
  120. Mode = Game.Enums.ItemMode.Default;
  121. StatsLoaded = false;
  122. }
  123. }
  124. public uint UID
  125. {
  126. get { return BitConverter.ToUInt32(Buffer, 4); }
  127. set { WriteUInt32(value, 4, Buffer); }
  128. }
  129. public uint ID
  130. {
  131. get { return BitConverter.ToUInt32(Buffer, 8); }
  132. set
  133. {
  134. if (value == 0 && ID != 0)
  135. throw new Exception("Invalid ID for an Item. Please check the stack trace to find the cause.");
  136. WriteUInt32(value, 8, Buffer);
  137. }
  138. }
  139. public void SetID(uint ID)
  140. {
  141. WriteUInt32(ID, 8, Buffer);
  142. }
  143. public ushort Durability
  144. {
  145. get { return BitConverter.ToUInt16(Buffer, 12); }
  146. set { WriteUInt16(value, 12, Buffer); }
  147. }
  148. public ushort MaximDurability
  149. {
  150. get { return BitConverter.ToUInt16(Buffer, 14); }
  151. set { WriteUInt16(value, 14, Buffer); }
  152. }
  153. public Enums.ItemMode Mode
  154. {
  155. get { return (Enums.ItemMode)BitConverter.ToUInt16(Buffer, 16); }
  156. set { WriteUInt16((ushort)value, 16, Buffer); }
  157. }
  158. public ushort Position
  159. {
  160. get { return BitConverter.ToUInt16(Buffer, 18); }
  161. set { WriteUInt16(value, 18, Buffer); }
  162. }
  163. public ushort Warehouse
  164. {
  165. get { return warehouse; }
  166. set { warehouse = value; }
  167. }
  168. public uint SocketProgress
  169. {
  170. get { return BitConverter.ToUInt32(Buffer, 20); }
  171. set { WriteUInt32(value, 20, Buffer); }
  172. }
  173. public Enums.Gem SocketOne
  174. {
  175. get { return (Enums.Gem)Buffer[24]; }
  176. set { Buffer[24] = (byte)value; }
  177. }
  178. public Enums.Gem SocketTwo
  179. {
  180. get { return (Enums.Gem)Buffer[25]; }
  181. set { Buffer[25] = (byte)value; }
  182. }
  183. public Enums.ItemEffect Effect
  184. {
  185. get { return (Enums.ItemEffect)BitConverter.ToUInt16(Buffer, 28); }
  186. set { WriteUInt16((ushort)value, 28, Buffer); }
  187. }
  188. public byte Plus
  189. {
  190. get { return Buffer[33]; }
  191. set { Buffer[33] = value; }
  192. }
  193. public byte Bless
  194. {
  195. get { return Buffer[34]; }
  196. set { Buffer[34] = value; }
  197. }
  198. public bool Bound
  199. {
  200. get { return Buffer[35] == 0 ? false : true; }
  201. set { Buffer[35] = (byte)(value ? 1 : 0); }
  202. }
  203. public byte Enchant
  204. {
  205. get { return Buffer[36]; }
  206. set { Buffer[36] = value; }
  207. }
  208. public byte NextRed
  209. {
  210. get { return Buffer[34]; }
  211. set { Buffer[34] = value; }
  212. }
  213. public byte NextBlue
  214. {
  215. get { return Buffer[36]; }
  216. set { Buffer[36] = value; }
  217. }
  218. public byte NextGreen
  219. {
  220. get { return Buffer[40]; }
  221. set { Buffer[40] = value; }
  222. }
  223. public bool Suspicious
  224. {
  225. get { return Buffer[44] == 0 ? false : true; }
  226. set { Buffer[44] = (byte)(value ? 1 : 0); }
  227. }
  228. public byte Lock
  229. {
  230. get { return Buffer[46]; }
  231. set { Buffer[46] = value; }
  232. }
  233. public Enums.Color Color
  234. {
  235. get { return (Enums.Color)BitConverter.ToUInt32(Buffer, 48); }
  236. set { WriteUInt32((uint)value, 48, Buffer); }
  237. }
  238. public uint PlusProgress
  239. {
  240. get { return BitConverter.ToUInt32(Buffer, 52); }
  241. set { WriteUInt32(value, 52, Buffer); }
  242. }
  243. public bool Inscribed
  244. {
  245. get { return (BitConverter.ToUInt16(this.Buffer, 56) == 1); }
  246. set { Writer.WriteUInt16(value ? ((byte)1) : ((byte)0), 56, this.Buffer); }
  247. }
  248. public uint TimeLeftInMinutes
  249. {
  250. get { return BitConverter.ToUInt32(Buffer, 60); }
  251. set { WriteUInt32(value, 60, Buffer); }
  252. }
  253. public ushort StackSize
  254. {
  255. get { return BitConverter.ToUInt16(Buffer, 68); }
  256. set { WriteUInt16(value, 68, Buffer); }
  257. }
  258. public DateTime SuspiciousStart
  259. {
  260. get { return DateTime.FromBinary((long)suspiciousStart); }
  261. set { suspiciousStart = (ulong)value.Ticks; }
  262. }
  263. public DateTime UnlockEnd
  264. {
  265. get { return DateTime.FromBinary((long)unlockEnd); }
  266. set { unlockEnd = (ulong)value.Ticks; }
  267. }
  268. public bool Unlocking
  269. {
  270. get { return unlocking; }
  271. set { unlocking = value; }
  272. }
  273. public UInt32 RefineItem
  274. {
  275. get { return mRefineItem; }
  276. set { mRefineItem = value; }
  277. }
  278. public byte[] ToArray()
  279. {
  280. return Buffer;
  281. }
  282. public void Deserialize(byte[] buffer)
  283. {
  284. throw new NotImplementedException();
  285. }
  286. public Double GemBonus(Byte type)
  287. {
  288. Double bonus = 0;
  289. if (SocketOne != Enums.Gem.NoSocket)
  290. {
  291. if ((Int32)SocketOne / 10 == type)
  292. bonus += ItemSocket.GetGemBonus((Byte)SocketOne);
  293. if (SocketTwo != Enums.Gem.NoSocket)
  294. {
  295. if ((Int32)SocketTwo / 10 == type)
  296. bonus += ItemSocket.GetGemBonus((Byte)SocketTwo);
  297. }
  298. }
  299. return bonus;
  300. }
  301. public override string ToString()
  302. {
  303. return ID.ToString() + "#"
  304. + Durability.ToString() + "#"
  305. + MaximDurability.ToString() + "#"
  306. + Position.ToString() + "#"
  307. + SocketProgress.ToString() + "#"
  308. + ((byte)SocketOne).ToString() + "#"
  309. + ((byte)SocketTwo).ToString() + "#"
  310. + ((ushort)Effect).ToString() + "#"
  311. + Plus.ToString() + "#"
  312. + Bless.ToString() + "#"
  313. + (Bound ? "1" : "0") + "#"
  314. + Enchant.ToString() + "#"
  315. + (Suspicious ? "1" : "0") + "#"
  316. + Lock.ToString() + "#"
  317. + (Unlocking ? "1" : "0") + "#"
  318. + PlusProgress.ToString() + "#"
  319. + (Inscribed ? "1" : "0") + "#"
  320. + Days.ToString() + "#"
  321. + DayStamp.ToString() + "#"
  322. + suspiciousStart.ToString() + "#"
  323. + unlockEnd.ToString();
  324. }
  325. public string ToLog()
  326. {
  327. return "UID: " + UID.ToString() + " | "
  328. + "ID: " + ID.ToString() + " | "
  329. + "Plus: " + Plus.ToString();
  330. }
  331. public void SendExtras(Client.GameState client)
  332. {
  333. if (client == null) return;
  334. if (RefineItem != 0)
  335. {
  336. Refinery.RefineryItem rI = RefineStats;
  337. if (rI != null)
  338. {
  339. client.Send(new ItemSoul()
  340. {
  341. ID = rI.Identifier,
  342. Identifier = UID,
  343. Level = rI.Level,
  344. Mode = ItemSoul.Types.Refine,
  345. Percent = rI.Percent,
  346. Type = 1,
  347. Time = (UInt32)(RefineryTime.Subtract(DateTime.Now).TotalSeconds)
  348. });
  349. }
  350. }
  351. ItemAdding add = new ItemAdding(true);
  352. if (Purification.Available)
  353. add.Append(Purification);
  354. if (ExtraEffect.Available)
  355. add.Append(ExtraEffect);
  356. if (Purification.Available || ExtraEffect.Available)
  357. client.Send(add);
  358. if (Lock == 2)
  359. {
  360. ItemLock itemLock = new ItemLock(true);
  361. itemLock.UID = UID;
  362. itemLock.ID = ItemLock.UnlockDate;
  363. itemLock.dwParam = (uint)(UnlockEnd.Year * 10000 + UnlockEnd.Month * 100 + UnlockEnd.Day);
  364. client.Send(itemLock);
  365. }
  366. }
  367. public void SendAgate(Client.GameState client)
  368. {
  369. byte[] packet = new byte[8 + 32 + 48 * Agate_map.Count + 48];
  370. WriteUInt16((ushort)(packet.Length - 8), 0, packet);
  371. WriteUInt16(2110, 2, packet);
  372. WriteUInt32(this.UID, 8, packet);
  373. WriteUInt32((byte)Agate_map.Count, 12, packet);
  374. WriteUInt32((byte)Agate_map.Count, 16, packet);
  375. WriteUInt32(Durability, 24, packet);
  376. WriteUInt32((byte)Agate_map.Count, 28, packet);
  377. if (Agate_map.Count > 0)
  378. {
  379. int position_next = 32;
  380. uint x = 0;
  381. for (; x < Agate_map.Count; x++)
  382. {
  383. WriteUInt32(x, position_next, packet);
  384. position_next += 4;
  385. WriteUInt16(ushort.Parse(Agate_map[x].Split('~')[0].ToString()), position_next, packet);
  386. position_next += 4;
  387. WriteUInt16(ushort.Parse(Agate_map[x].Split('~')[1].ToString()), position_next, packet);
  388. position_next += 4;
  389. WriteUInt16(ushort.Parse(Agate_map[x].Split('~')[2].ToString()), position_next, packet);
  390. position_next += 36;
  391. }
  392. }
  393. else
  394. {
  395. }
  396. client.Send(packet);
  397. }
  398. public void Send(Client.GameState client)
  399. {
  400. if (client == null) return;
  401. if (ID == 300000)
  402. {
  403. uint G = SocketProgress & 0xFF;
  404. uint B = (SocketProgress >> 8) & 0xFF;
  405. uint R = (SocketProgress >> 16) & 0xFF;
  406. if (NextRed == 0 && NextBlue == 0 && NextGreen == 0)
  407. {
  408. NextRed = (byte)R;
  409. NextBlue = (byte)B;
  410. NextGreen = (byte)G;
  411. Database.ConquerItemTable.UpdateNextSteedColor(this);
  412. }
  413. }
  414. if (Days > 0)
  415. {
  416. if (DateTime.Now >= DayStamp.AddDays(Days))
  417. {
  418. Database.ConquerItemTable.DeleteItem(UID);
  419. Database.ConquerItemTable.RemoveItem(UID);
  420. client.Send(Database.ConquerItemInformation.BaseInformations[ID].Name + " is Has Expired");
  421. }
  422. TimeSpan Remain = DayStamp.AddDays(Days) - DateTime.Now;
  423. TimeLeftInMinutes = (uint)Remain.TotalSeconds;
  424. }
  425. client.Send(Buffer);
  426. if (RefineItem != 0)
  427. {
  428. Refinery.RefineryItem rI = RefineStats;
  429. if (rI != null)
  430. {
  431. client.Send(new ItemSoul()
  432. {
  433. ID = rI.Identifier,
  434. Identifier = UID,
  435. Level = rI.Level,
  436. Mode = ItemSoul.Types.Refine,
  437. Percent = rI.Percent,
  438. Type = 1,
  439. Time = (UInt32)(RefineryTime.Subtract(DateTime.Now).TotalSeconds)
  440. });
  441. }
  442. }
  443. ItemAdding add = new ItemAdding(true);
  444. if (Purification.Available)
  445. add.Append(Purification);
  446. if (ExtraEffect.Available)
  447. add.Append(ExtraEffect);
  448. if (Purification.Available || ExtraEffect.Available)
  449. client.Send(add);
  450. if (Lock == 2 && (Mode == Enums.ItemMode.Default || Mode == Enums.ItemMode.Update))
  451. {
  452. ItemLock itemLock = new ItemLock(true);
  453. itemLock.UID = UID;
  454. itemLock.ID = ItemLock.UnlockDate;
  455. itemLock.dwParam = (uint)(UnlockEnd.Year * 10000 + UnlockEnd.Month * 100 + UnlockEnd.Day);
  456. client.Send(itemLock);
  457. }
  458. Mode = Enums.ItemMode.Default;
  459. }
  460. public static Boolean isRune(UInt32 itemid)
  461. {
  462. if (itemid >= 729960 && itemid <= 729970)
  463. return true;
  464. return false;
  465. }
  466. public ushort Vigor
  467. {
  468. get;
  469. set;
  470. }
  471. public short BattlePower
  472. {
  473. get
  474. {
  475. short potBase = 0;
  476. byte Quality = (byte)(ID % 10);
  477. if (Quality >= 5)
  478. potBase += (byte)(Quality - 5);
  479. potBase += Plus;
  480. if (SocketOne != Enums.Gem.NoSocket) potBase++;
  481. if (SocketTwo != Enums.Gem.NoSocket) potBase++;
  482. if (((byte)SocketOne) % 10 == 3) potBase++;
  483. if (((byte)SocketTwo) % 10 == 3) potBase++;
  484. if (ID / 1000 == 421 || PacketHandler.IsTwoHand(ID))
  485. potBase *= 2;
  486. return potBase;
  487. }
  488. }
  489. public override int GetHashCode()
  490. {
  491. return (int)this.UID;
  492. }
  493. public override bool Equals(object obj)
  494. {
  495. return (obj as ConquerItem).UID == GetHashCode();
  496. }
  497. public Refinery.RefineryItem RefineStats
  498. {
  499. get
  500. {
  501. Refinery.RefineryItem i = null;
  502. Kernel.DatabaseRefinery.TryGetValue(RefineItem, out i);
  503. return i;
  504. }
  505. }
  506. public DateTime RefineryTime
  507. {
  508. get { return mRefineryTime; }
  509. set { mRefineryTime = value; }
  510. }
  511. public uint Minutes
  512. {
  513. get;
  514. set;
  515. }
  516. public bool IsTwoHander()
  517. {
  518. ItemTypes item_type = (ItemTypes)GetItemType();
  519. bool check = ((UInt16)item_type >= 500 && (UInt16)item_type <= 580 || (UInt16)item_type == 421 || (UInt16)item_type == 612);
  520. if (check)
  521. {
  522. check = (item_type != ItemTypes.ShieldID);
  523. if (check)
  524. {
  525. check = (item_type != ItemTypes.NinjaSwordID);
  526. if (check)
  527. {
  528. check = (item_type != ItemTypes.MonkBeadsID);
  529. }
  530. if (check)
  531. {
  532. check = (item_type != ItemTypes.Rapier);
  533. }
  534. }
  535. }
  536. return check;
  537. }
  538. public ItemTypes GetItemType()
  539. {
  540. return (ItemTypes)(this.ID / 1000);
  541. }
  542. public static void CheckItemExtra(ConquerItem i, Client.GameState c)
  543. {
  544. if (i.RefineryTime.Ticks != 0)
  545. {
  546. if (DateTime.Now > i.RefineryTime)
  547. {
  548. i.RefineItem = 0;
  549. i.RefineryTime = new DateTime(0);
  550. ItemSoul expire = new ItemSoul()
  551. {
  552. Identifier = i.UID
  553. };
  554. expire.Expired(c);
  555. i.Send(c);
  556. WindowStats Stats = new WindowStats(c);
  557. c.Send(Stats.ToArray());
  558. Database.ConquerItemTable.UpdateRefineryItem(i);
  559. Database.ConquerItemTable.UpdateRefineryTime(i);
  560. if (!c.Equipment.Free(i.Position))
  561. {
  562. c.LoadItemStats();
  563. }
  564. }
  565. }
  566. }
  567. public enum ItemTypes : ushort
  568. {
  569. BowID = 500,
  570. ArrowID = 1050,
  571. ShieldID = 900,
  572. BackswordID = 421,
  573. BladeID = 410,
  574. SwordID = 420,
  575. NinjaSwordID = 601,
  576. MonkBeadsID = 610,
  577. FanID = 201,
  578. TowerID = 202,
  579. CropID = 203,
  580. GarmentID_1 = 181,
  581. GarmentID_2 = 182,
  582. BottleID = 2100,
  583. GemID = 700,
  584. PickaxeID = 562,
  585. RingID = 150,
  586. BootID = 160,
  587. SteedArmorID = 200,
  588. Rapier = 611,
  589. Pistol = 612,
  590. NecklaceID = 120,
  591. BraceletID = 152,
  592. BagID = 121,
  593. RightAccessory1 = 350,
  594. RightAccessory2 = 360,
  595. RightAccessory3 = 370,
  596. LeftAccessory = 380,
  597. }
  598.  
  599.  
  600. }
  601. public class ItemSocket
  602. {
  603. public const Byte
  604. Phoenix = 0,
  605. Dragon = 1,
  606. Fury = 2,
  607. Rainbow = 3,
  608. Kylin = 4,
  609. Violet = 5,
  610. Moon = 6,
  611. Tortoise = 7,
  612. Thunder = 10,
  613. Glory = 12,
  614. OpenSocket = 255,
  615. NoSocket = 0;
  616. public static Double GetGemBonus(Byte value)
  617. {
  618. switch (value)
  619. {
  620. case 71:
  621. return 0.02;
  622. case 72:
  623. return 0.04;
  624. case 1:
  625. case 11:
  626. case 21:
  627. return 0.05;
  628. case 73:
  629. return 0.06;
  630. case 2:
  631. case 12:
  632. case 22:
  633. case 31:
  634. return 0.10;
  635. case 3:
  636. case 23:
  637. case 32:
  638. case 61:
  639. case 13:
  640. return 0.15;
  641. case 33:
  642. return 0.25;
  643. case 51:
  644. case 62:
  645. return 0.30;
  646. case 41:
  647. case 52:
  648. case 63:
  649. return 0.50;
  650. case 42:
  651. case 53:
  652. return 1.00;
  653. case 43:
  654. return 2.00;
  655. case 101:
  656. case 121:
  657. return 100;
  658. case 102:
  659. case 122:
  660. return 300;
  661. case 103:
  662. case 123:
  663. return 500;
  664. default:
  665. return 0;
  666. }
  667. }
  668. }
  669. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!