API tools faq
paste
Advertisement
Guest User

Untitled

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