Writer.cs

SUBMITTED BY: Guest

DATE: Aug. 17, 2017, 4:23 a.m.

FORMAT: Text only

SIZE: 20.2 kB

Raw Download

HITS: 407

Report
  1. using System;
  2. using System.Text;
  3. using System.Collections.Generic;
  5. namespace Conquer_Online_Server.Network
  6. {
  7. public class Writer
  8. {
  9. public static void WriteStringWithLength(string arg, int len, int offset, byte[] buffer)
  10. {
  11. if (buffer == null)
  12. return;
  13. if (offset > buffer.Length - 1)
  14. return;
  15. int till = len;
  16. till = Math.Min(arg.Length, till);
  17. buffer[offset] = (byte)till;
  18. offset++;
  19. byte[] argEncoded = Server.Encoding.GetBytes(arg);
  20. Array.Copy(argEncoded, 0, buffer, offset, till);
  21. }
  22. public static void WriteStringWithLength(string arg, int offset, byte[] buffer)
  23. {
  24. if (buffer == null)
  25. return;
  26. if (offset > buffer.Length - 1)
  27. return;
  28. int till = buffer.Length - offset;
  29. till = Math.Min(arg.Length, till);
  30. buffer[offset] = (byte)arg.Length;
  31. offset++;
  32. byte[] argEncoded = Server.Encoding.GetBytes(arg);
  33. Array.Copy(argEncoded, 0, buffer, offset, till);
  34. }
  35. public static void WriteString(string arg, int offset, byte[] buffer)
  36. {
  37. if (buffer == null)
  38. return;
  39. if (offset > buffer.Length - 1)
  40. return;
  41. byte[] argEncoded = Server.Encoding.GetBytes(arg);
  42. if (buffer.Length >= offset + arg.Length)
  43. Array.Copy(argEncoded, 0, buffer, offset, arg.Length);
  44. }
  46. /* public static void WriteStringWithLength(string arg, int offset, byte[] buffer)
  47. {
  48. if (buffer == null)
  49. return;
  50. if (offset > buffer.Length - 1)
  51. return;
  52. int till = buffer.Length - offset;
  53. till = Math.Min(arg.Length, till);
  54. buffer[offset] = (byte)arg.Length;
  55. offset++;
  56. ushort i = 0;
  57. while (i < till)
  58. {
  59. buffer[(ushort)(i + offset)] = (byte)arg[i];
  60. i = (ushort)(i + 1);
  61. }
  62. }
  63. public static void WriteString(string arg, int offset, byte[] buffer)
  64. {
  65. if (buffer == null)
  66. return;
  67. if (offset > buffer.Length - 1)
  68. return;
  69. if (buffer.Length >= offset + arg.Length)
  70. {
  71. unsafe
  72. {
  73. #if UNSAFE
  74. fixed (byte* Buffer = buffer)
  75. {
  76. ushort i = 0;
  77. while (i < arg.Length)
  78. {
  79. *((byte*)(Buffer + offset + i)) = (byte)arg[i];
  80. i++;
  81. }
  82. }
  83. #else
  84. ushort i = 0;
  85. while (i < arg.Length)
  86. {
  87. buffer[(ushort)(i + offset)] = (byte)arg[i];
  88. i = (ushort)(i + 1);
  89. }
  90. #endif
  91. }
  92. }
  93. }*/
  95. public static void WriteByte(byte arg, int offset, byte[] buffer)
  96. {
  97. if (buffer == null)
  98. return;
  99. if (offset > buffer.Length - 1)
  100. return;
  101. buffer[offset] = arg;
  102. }
  103. public static void WriteBoolean(bool arg, int offset, byte[] buffer)
  104. {
  105. if (buffer == null)
  106. return;
  107. if (offset > buffer.Length - 1)
  108. return;
  109. WriteByte(arg == true ? (byte)1 : (byte)0, offset, buffer);
  110. }
  111. public static void WriteUInt16(ushort arg, int offset, byte[] buffer)
  112. {
  113. if (buffer == null)
  114. return;
  115. if (offset > buffer.Length - 1)
  116. return;
  117. if (buffer.Length >= offset + sizeof(ushort))
  118. {
  119. unsafe
  120. {
  121. #if UNSAFE
  122. fixed (byte* Buffer = buffer)
  123. *((ushort*)(Buffer + offset)) = arg;
  124. #else
  125. buffer[offset] = (byte)arg;
  126. buffer[offset + 1] = (byte)(arg >> 8);
  127. #endif
  128. }
  129. }
  130. }
  131. public static void WriteUInt32(uint arg, int offset, byte[] buffer)
  132. {
  133. if (buffer == null)
  134. return;
  135. if (offset > buffer.Length - 1)
  136. return;
  137. if (buffer.Length >= offset + sizeof(uint))
  138. {
  139. unsafe
  140. {
  141. #if UNSAFE
  142. fixed (byte* Buffer = buffer)
  143. *((uint*)(Buffer + offset)) = arg;
  144. #else
  145. buffer[offset] = (byte)arg;
  146. buffer[offset + 1] = (byte)(arg >> 8);
  147. buffer[offset + 2] = (byte)(arg >> 16);
  148. buffer[offset + 3] = (byte)(arg >> 24);
  149. #endif
  150. }
  151. }
  152. }
  153. public static unsafe void WriteUInt128(decimal arg, int offset, byte[] Buffer)
  154. {
  155. try
  156. {
  157. fixed (byte* buffer = Buffer)
  158. *((decimal*)(buffer + offset)) = arg;
  159. }
  160. catch (Exception e)
  161. {
  162. Console.WriteLine(e);
  163. }
  164. }
  165. public static void WriteInt32(int arg, int offset, byte[] buffer)
  166. {
  167. if (buffer == null)
  168. return;
  169. if (offset > buffer.Length - 1)
  170. return;
  171. if (buffer.Length >= offset + sizeof(uint))
  172. {
  173. unsafe
  174. {
  175. #if UNSAFE
  176. fixed (byte* Buffer = buffer)
  177. *((int*)(Buffer + offset)) = arg;
  178. #else
  179. buffer[offset] = (byte)(arg);
  180. buffer[offset + 1] = (byte)(arg >> 8);
  181. buffer[offset + 2] = (byte)(arg >> 16);
  182. buffer[offset + 3] = (byte)(arg >> 24);
  183. #endif
  184. }
  185. }
  186. }
  187. public static void WriteUInt64(ulong arg, int offset, byte[] buffer)
  188. {
  189. if (buffer == null)
  190. return;
  191. if (offset > buffer.Length - 1)
  192. return;
  193. if (buffer.Length >= offset + sizeof(ulong))
  194. {
  195. unsafe
  196. {
  197. #if UNSAFE
  198. fixed (byte* Buffer = buffer)
  199. *((ulong*)(Buffer + offset)) = arg;
  200. #else
  201. buffer[offset] = (byte)(arg);
  202. buffer[offset + 1] = (byte)(arg >> 8);
  203. buffer[offset + 2] = (byte)(arg >> 16);
  204. buffer[offset + 3] = (byte)(arg >> 24);
  205. buffer[offset + 4] = (byte)(arg >> 32);
  206. buffer[offset + 5] = (byte)(arg >> 40);
  207. buffer[offset + 6] = (byte)(arg >> 48);
  208. buffer[offset + 7] = (byte)(arg >> 56);
  209. #endif
  210. }
  211. }
  212. }
  213. public static void WriteStringList(List<string> arg, int offset, byte[] buffer)
  214. {
  215. if (arg == null)
  216. return;
  217. if (buffer == null)
  218. return;
  219. if (offset > buffer.Length - 1)
  220. return;
  221. buffer[offset] = (byte)arg.Count;
  222. offset++;
  223. foreach (string str in arg)
  224. {
  225. buffer[offset] = (byte)str.Length;
  226. WriteString(str, offset + 1, buffer);
  227. offset += str.Length + 1;
  228. }
  229. }
  230. public static void WriteStringList(string[] arg, int offset, byte[] buffer)
  231. {
  232. if (arg == null)
  233. return;
  234. if (buffer == null)
  235. return;
  236. if (offset > buffer.Length - 1)
  237. return;
  238. buffer[offset] = (byte)arg.Length;
  239. offset++;
  240. foreach (string str in arg)
  241. {
  242. buffer[offset] = (byte)str.Length;
  243. WriteString(str, offset + 1, buffer);
  244. offset += str.Length + 1;
  245. }
  246. }
  248. public static void String(string arg, int offset, byte[] buffer)
  249. {
  250. if (buffer == null)
  251. return;
  252. if (offset > buffer.Length - 1)
  253. return;
  254. byte[] argEncoded = Server.Encoding.GetBytes(arg);
  255. if (buffer.Length >= offset + arg.Length)
  256. Array.Copy(argEncoded, 0, buffer, offset, arg.Length);
  257. }
  259. /* public static void String(string arg, int offset, byte[] buffer)
  260. {
  261. if (buffer == null)
  262. return;
  263. if (offset > buffer.Length - 1)
  264. return;
  265. if (buffer.Length >= offset + arg.Length)
  266. {
  267. unsafe
  268. {
  269. #if UNSAFE
  270. fixed (byte* Buffer = buffer)
  271. {
  272. ushort i = 0;
  273. while (i < arg.Length)
  274. {
  275. *((byte*)(Buffer + offset + i)) = (byte)arg[i];
  276. i++;
  277. }
  278. }
  279. #else
  280. ushort i = 0;
  281. while (i < arg.Length)
  282. {
  283. buffer[(ushort)(i + offset)] = (byte)arg[i];
  284. i = (ushort)(i + 1);
  285. }
  286. #endif
  287. }
  288. }
  289. }*/
  290. public static void Byte(byte arg, int offset, byte[] buffer)
  291. {
  292. if (buffer == null)
  293. return;
  294. if (offset > buffer.Length - 1)
  295. return;
  296. buffer[offset] = arg;
  297. }
  298. public static void Boolean(bool arg, int offset, byte[] buffer)
  299. {
  300. if (buffer == null)
  301. return;
  302. if (offset > buffer.Length - 1)
  303. return;
  304. WriteByte(arg == true ? (byte)1 : (byte)0, offset, buffer);
  305. }
  306. public static void Ushort(ushort arg, int offset, byte[] buffer)
  307. {
  308. if (buffer == null)
  309. return;
  310. if (offset > buffer.Length - 1)
  311. return;
  312. if (buffer.Length >= offset + sizeof(ushort))
  313. {
  314. unsafe
  315. {
  316. #if UNSAFE
  317. fixed (byte* Buffer = buffer)
  318. {
  319. *((ushort*)(Buffer + offset)) = arg;
  320. }
  321. #else
  322. buffer[offset] = (byte)arg;
  323. buffer[offset + 1] = (byte)(arg >> 8);
  324. #endif
  325. }
  326. }
  327. }
  328. public static void Uint(uint arg, int offset, byte[] buffer)
  329. {
  330. if (buffer == null)
  331. return;
  332. if (offset > buffer.Length - 1)
  333. return;
  334. if (buffer.Length >= offset + sizeof(uint))
  335. {
  336. unsafe
  337. {
  338. #if UNSAFE
  339. fixed (byte* Buffer = buffer)
  340. {
  341. *((uint*)(Buffer + offset)) = arg;
  342. }
  343. #else
  344. buffer[offset] = (byte)arg;
  345. buffer[offset + 1] = (byte)(arg >> 8);
  346. buffer[offset + 2] = (byte)(arg >> 16);
  347. buffer[offset + 3] = (byte)(arg >> 24);
  348. #endif
  349. }
  350. }
  351. }
  352. public static unsafe void Decimal(decimal arg, int offset, byte[] Buffer)
  353. {
  354. try
  355. {
  356. fixed (byte* buffer = Buffer)
  357. {
  358. if (arg.GetType() == typeof(decimal))
  359. {
  360. *((decimal*)(buffer + offset)) = arg;
  361. }
  362. }
  363. }
  364. catch (Exception e)
  365. {
  366. Conquer_Online_Server.Console.WriteLine(e);
  367. }
  368. }
  369. public static void Int(int arg, int offset, byte[] buffer)
  370. {
  371. if (buffer == null)
  372. return;
  373. if (offset > buffer.Length - 1)
  374. return;
  375. if (buffer.Length >= offset + sizeof(uint))
  376. {
  377. unsafe
  378. {
  379. #if UNSAFE
  380. fixed (byte* Buffer = buffer)
  381. {
  382. *((int*)(Buffer + offset)) = arg;
  383. }
  384. #else
  385. buffer[offset] = (byte)(arg);
  386. buffer[offset + 1] = (byte)(arg >> 8);
  387. buffer[offset + 2] = (byte)(arg >> 16);
  388. buffer[offset + 3] = (byte)(arg >> 24);
  389. #endif
  390. }
  391. }
  392. }
  393. public static void Ulong(ulong arg, int offset, byte[] buffer)
  394. {
  395. if (buffer == null)
  396. return;
  397. if (offset > buffer.Length - 1)
  398. return;
  399. if (buffer.Length >= offset + sizeof(ulong))
  400. {
  401. unsafe
  402. {
  403. #if UNSAFE
  404. fixed (byte* Buffer = buffer)
  405. {
  406. *((ulong*)(Buffer + offset)) = arg;
  407. }
  408. #else
  409. buffer[offset] = (byte)(arg);
  410. buffer[offset + 1] = (byte)(arg >> 8);
  411. buffer[offset + 2] = (byte)(arg >> 16);
  412. buffer[offset + 3] = (byte)(arg >> 24);
  413. buffer[offset + 4] = (byte)(arg >> 32);
  414. buffer[offset + 5] = (byte)(arg >> 40);
  415. buffer[offset + 6] = (byte)(arg >> 48);
  416. buffer[offset + 7] = (byte)(arg >> 56);
  417. #endif
  418. }
  419. }
  420. }
  422. public static void WriteUshort(ushort arg, int offset, byte[] buffer)
  423. {
  424. if (buffer == null)
  425. return;
  426. if (offset > buffer.Length - 1)
  427. return;
  428. if (buffer.Length >= offset + sizeof(ushort))
  429. {
  430. unsafe
  431. {
  432. #if UNSAFE
  433. fixed (byte* Buffer = buffer)
  434. {
  435. *((ushort*)(Buffer + offset)) = arg;
  436. }
  437. #else
  438. buffer[offset] = (byte)arg;
  439. buffer[offset + 1] = (byte)(arg >> 8);
  440. #endif
  441. }
  442. }
  443. }
  444. public static void WriteUint(uint arg, int offset, byte[] buffer)
  445. {
  446. if (buffer == null)
  447. return;
  448. if (offset > buffer.Length - 1)
  449. return;
  450. if (buffer.Length >= offset + sizeof(uint))
  451. {
  452. unsafe
  453. {
  454. #if UNSAFE
  455. fixed (byte* Buffer = buffer)
  456. {
  457. *((uint*)(Buffer + offset)) = arg;
  458. }
  459. #else
  460. buffer[offset] = (byte)arg;
  461. buffer[offset + 1] = (byte)(arg >> 8);
  462. buffer[offset + 2] = (byte)(arg >> 16);
  463. buffer[offset + 3] = (byte)(arg >> 24);
  464. #endif
  465. }
  466. }
  467. }
  468. public static void WriteUlong(ulong arg, int offset, byte[] buffer)
  469. {
  470. if (buffer == null)
  471. return;
  472. if (offset > buffer.Length - 1)
  473. return;
  474. if (buffer.Length >= offset + sizeof(ulong))
  475. {
  476. unsafe
  477. {
  478. #if UNSAFE
  479. fixed (byte* Buffer = buffer)
  480. {
  481. *((ulong*)(Buffer + offset)) = arg;
  482. }
  483. #else
  484. buffer[offset] = (byte)(arg);
  485. buffer[offset + 1] = (byte)(arg >> 8);
  486. buffer[offset + 2] = (byte)(arg >> 16);
  487. buffer[offset + 3] = (byte)(arg >> 24);
  488. buffer[offset + 4] = (byte)(arg >> 32);
  489. buffer[offset + 5] = (byte)(arg >> 40);
  490. buffer[offset + 6] = (byte)(arg >> 48);
  491. buffer[offset + 7] = (byte)(arg >> 56);
  492. #endif
  493. }
  494. }
  495. }
  498. #region New Write
  499. public static void Write(string arg, int offset, byte[] buffer)
  500. {
  501. if (buffer == null)
  502. return;
  503. if (offset > buffer.Length - 1)
  504. return;
  505. byte[] argEncoded = Server.Encoding.GetBytes(arg);
  506. if (buffer.Length >= offset + arg.Length)
  507. Array.Copy(argEncoded, 0, buffer, offset, arg.Length);
  508. }
  509. public static void Write(byte arg, int offset, byte[] buffer)
  510. {
  511. if (buffer == null)
  512. return;
  513. if (offset > buffer.Length - 1)
  514. return;
  515. buffer[offset] = arg;
  516. }
  517. public static void Write(bool arg, int offset, byte[] buffer)
  518. {
  519. if (buffer == null)
  520. return;
  521. if (offset > buffer.Length - 1)
  522. return;
  523. WriteByte(arg == true ? (byte)1 : (byte)0, offset, buffer);
  524. }
  525. public static void Write(ushort arg, int offset, byte[] buffer)
  526. {
  527. if (buffer == null)
  528. return;
  529. if (offset > buffer.Length - 1)
  530. return;
  531. if (buffer.Length >= offset + sizeof(ushort))
  532. {
  533. unsafe
  534. {
  535. #if UNSAFE
  536. fixed (byte* Buffer = buffer)
  537. {
  538. *((ushort*)(Buffer + offset)) = arg;
  539. }
  540. #else
  541. buffer[offset] = (byte)arg;
  542. buffer[offset + 1] = (byte)(arg >> 8);
  543. #endif
  544. }
  545. }
  546. }
  547. public static void Write(uint arg, int offset, byte[] buffer)
  548. {
  549. if (buffer == null)
  550. return;
  551. if (offset > buffer.Length - 1)
  552. return;
  553. if (buffer.Length >= offset + sizeof(uint))
  554. {
  555. unsafe
  556. {
  557. #if UNSAFE
  558. fixed (byte* Buffer = buffer)
  559. {
  560. *((uint*)(Buffer + offset)) = arg;
  561. }
  562. #else
  563. buffer[offset] = (byte)arg;
  564. buffer[offset + 1] = (byte)(arg >> 8);
  565. buffer[offset + 2] = (byte)(arg >> 16);
  566. buffer[offset + 3] = (byte)(arg >> 24);
  567. #endif
  568. }
  569. }
  570. }
  571. public static void Write(ulong arg, int offset, byte[] buffer)
  572. {
  573. if (buffer == null)
  574. return;
  575. if (offset > buffer.Length - 1)
  576. return;
  577. if (buffer.Length >= offset + sizeof(ulong))
  578. {
  579. unsafe
  580. {
  581. #if UNSAFE
  582. fixed (byte* Buffer = buffer)
  583. {
  584. *((ulong*)(Buffer + offset)) = arg;
  585. }
  586. #else
  587. buffer[offset] = (byte)(arg);
  588. buffer[offset + 1] = (byte)(arg >> 8);
  589. buffer[offset + 2] = (byte)(arg >> 16);
  590. buffer[offset + 3] = (byte)(arg >> 24);
  591. buffer[offset + 4] = (byte)(arg >> 32);
  592. buffer[offset + 5] = (byte)(arg >> 40);
  593. buffer[offset + 6] = (byte)(arg >> 48);
  594. buffer[offset + 7] = (byte)(arg >> 56);
  595. #endif
  596. }
  597. }
  598. }
  599. #endregion
  600. }
  601. }
comments powered by Disqus