API tools faq
paste
Guest User

n_ini(v3) by Neufox

a guest
Dec 3rd, 2014
553
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.17 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Include: n_ini
  3. Brief: Simple, fast, easy INI-File manager. Generally used for saving stuff!
  4. Update: v3 (4/12/14)
  5. Creator: Neufox
  6.  
  7. Credits:
  8. * Thanks to Neufox - Creating this script
  9. * Thanks to [DRuG]Slick - Base SII include
  10. * Thanks to SAMP Team - You know why i stated this!
  11.  
  12. Converts:
  13. * DINI
  14. * DUDB
  15. * SFM(Southclaw's File Manager)
  16. * FINI
  17. * SII
  18. * SF(Simple File)
  19. * dFile
  20. - If you want to have more conversions, then post down your suggestion in main topic page!
  21.  
  22. - Checkout line ( 662 ) for UDB Path setting.
  23.  
  24. */
  25. #include <a_samp>
  26.  
  27. /*
  28. native INI_Create(const filename[], bool:open = false);
  29. native INI_Remove(const filename[]);
  30. native INI_Open(const filename[]);
  31. native INI_Close();
  32. native INI_Save();
  33. native INI_Rename(const newname[]);
  34. native INI_Copy(const copyname[]);
  35. native INI_WriteString(const key[], const value[]);
  36. native INI_WriteInt(const key[], value);
  37. native INI_WriteFloat(const key[], Float: value);
  38. native INI_WriteBool(const key[], bool:value);
  39. native INI_ReadString(const key[]);
  40. native INI_ReadInt(const key[]);
  41. native Float:INI_ReadFloat(const key[]);
  42. native bool:INI_ReadBool(const key[]);
  43. native INI_MultiWrite(format[], {Float,_}:...);
  44. native INI_MultiRead(format[],{Float,_}:...);
  45. native INI_RemoveKey(const key[]);
  46. native INI_KeyExist(const key[]);
  47. native INI_ReturnFile();
  48. native INI_ReturnFilename();
  49. */
  50.  
  51. #pragma dynamic 45000 // Change accordingly!!
  52.  
  53. #if defined MAX_STRING
  54. #define INI_MAX_VALUE MAX_STRING
  55. #else
  56. #define INI_MAX_VALUE 256
  57. #endif
  58.  
  59. //Some configs
  60. #define INI_MAX_KEY 24//maximum number of keys/entries in a file
  61. #define INI_MAX_LINE (INI_MAX_KEY + INI_MAX_VALUE + 3)
  62. #define INI_MAX_FILENAME 256//the max file name string can be!
  63. #define INI_MAX_LINES 256
  64. #define INI_AUTO_SAVE true//true = Automatically saves and write cache to file on closing
  65. #define INI_CONVERT true//true = Converts all other ini/file systems to n_ini automatically
  66. //
  67.  
  68. enum E_CACHE
  69. {
  70. E_KEY[INI_MAX_KEY],
  71. E_VALUE[INI_MAX_VALUE]
  72. }
  73.  
  74. enum E_FILE
  75. {
  76. E_FILENAME[INI_MAX_FILENAME],
  77. bool:E_OPEN
  78. }
  79.  
  80. static gCache[INI_MAX_LINES][E_CACHE];
  81. static gEmptyCache[E_CACHE];
  82. static gFile[E_FILE];
  83. static gNoFile[E_FILE];
  84.  
  85. #define INI_Exist fexist
  86.  
  87. stock INI_Create(const filename[], bool:open = false)
  88. {
  89. if(!filename[0]) return false;
  90. if(INI_Exist(filename)) return false;
  91.  
  92. if(open == false)
  93. {
  94. new File: h;
  95. h = fopen(filename, io_readwrite);
  96. if(h)
  97. {
  98. fclose(h);
  99. return true;
  100. }
  101. }
  102. else INI_Open(filename);
  103. return false;
  104. }
  105.  
  106. stock INI_Remove(const filename[])
  107. {
  108. if (!filename[0]) return false;
  109. if ((gFile[E_OPEN]) && (!strcmp(gFile[E_FILENAME], filename, true))) gFile = gNoFile;
  110. return fremove(filename);
  111. }
  112.  
  113. stock INI_Open(const filename[])
  114. {
  115. if (!filename[0]) return false;
  116. if (gFile[E_OPEN])
  117. {
  118. if (!strcmp(gFile[E_FILENAME], filename, true)) return true;
  119. INI_Close();
  120. }
  121. new File: h;
  122. h = fopen(filename, io_readwrite);
  123. if (h)
  124. {
  125. INI_strcpy(gFile[E_FILENAME], filename, INI_MAX_FILENAME, INI_MAX_FILENAME);
  126. new line[INI_MAX_LINE];
  127. new ln = -1;
  128. new separator;
  129. while (((ln + 1) < INI_MAX_LINES) && (fread(h, line)))
  130. {
  131. ln ++;
  132. INI_StripLine(line);
  133. separator = strfind(line, "=", false);
  134. if ((line[0] == ';') || (line[0] == '=') || (separator == -1) || (separator > INI_MAX_KEY))
  135. {
  136. if (line[0] == ';')
  137. {
  138. INI_strcpy(gCache[ln][E_VALUE], line, INI_MAX_VALUE, INI_MAX_VALUE);
  139. }
  140. else
  141. {
  142. INI_strcpy(gCache[ln][E_VALUE][1], line, INI_MAX_VALUE - 1, INI_MAX_VALUE - 1);
  143. gCache[ln][E_VALUE][0] = ';';
  144. }
  145. continue;
  146. }
  147. INI_strcpy(gCache[ln][E_KEY], line, separator, INI_MAX_KEY);
  148. INI_strcpy(gCache[ln][E_VALUE], line[separator + 1], INI_MAX_VALUE, INI_MAX_VALUE);
  149. if (!gCache[ln][E_VALUE][0]) gCache[ln][E_VALUE][0] = ' ';
  150. }
  151. fclose(h);
  152. gFile[E_OPEN] = true;
  153. return 1;
  154. }
  155. return 0;
  156. }
  157.  
  158. stock INI_Close()
  159. {
  160. if (!gFile[E_OPEN]) return false;
  161. #if(INI_AUTO_SAVE)
  162. INI_Save();
  163. #endif
  164. for (new ln; ln < INI_MAX_LINES; ln++) gCache[ln] = gEmptyCache;
  165. gFile = gNoFile;
  166. return true;
  167. }
  168.  
  169. stock INI_Save()
  170. {
  171. if (!gFile[E_OPEN]) return false;
  172. new File: h;
  173. h = fopen(gFile[E_FILENAME], io_write);
  174. if (h)
  175. {
  176. new line[INI_MAX_LINE];
  177. new ln = -1;
  178. while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  179. {
  180. ln ++;
  181. if (gCache[ln][E_VALUE][0] == ';')
  182. {
  183. if (gCache[ln][E_VALUE][1])
  184. {
  185. format(line, sizeof(line), "%s\r\n", gCache[ln][E_VALUE]);
  186. fwrite(h, line);
  187. continue;
  188. }
  189. fwrite(h, "\r\n");
  190. continue;
  191. }
  192. format(line, sizeof(line), "%s=%s\r\n", gCache[ln][E_KEY], gCache[ln][E_VALUE]);
  193. fwrite(h, line);
  194. }
  195. fclose(h);
  196. return true;
  197. }
  198. return false;
  199. }
  200.  
  201. stock INI_Rename(const newname[])
  202. {
  203. if (!gFile[E_OPEN]) return false;
  204. if (INI_Exist(newname)) return false;
  205.  
  206. INI_Close();
  207.  
  208. new File: h, File: g, string[INI_MAX_VALUE];
  209.  
  210. h = fopen(gFile[E_FILENAME], io_read);
  211. if (!h) return false;
  212.  
  213. g = fopen(newname, io_write);
  214. if (!g)
  215. {
  216. fclose(h);
  217. return false;
  218. }
  219.  
  220. while(fread(h, string)) fwrite(g, string);
  221. fclose(h);
  222. fclose(g);
  223. fremove(gFile[E_FILENAME);
  224.  
  225. INI_Open(newname);
  226. return true;
  227. }
  228.  
  229. stock INI_Copy(const copyname[])
  230. {
  231. if (!gFile[E_OPEN]) return false;
  232.  
  233. if (INI_Exist(copyname))
  234. {
  235. INI_Remove(copyname);
  236. }
  237.  
  238. new File: h, File: g, string[INI_MAX_VALUE];
  239.  
  240. h = fopen(gFile[E_FILENAME], io_read);
  241. if (!h) return false;
  242.  
  243. g = fopen(newname, io_write);
  244. if (!g)
  245. {
  246. fclose(h);
  247. return false;
  248. }
  249.  
  250. while(fread(h, string)) fwrite(g, string);
  251. fclose(h);
  252. fclose(g);
  253. return true;
  254. }
  255.  
  256. stock INI_WriteString(const key[], const value[])
  257. {
  258. if ((!gFile[E_OPEN]) || (!key[0]) || (key[0] == ';') || (strfind(key, "=", false) != -1)) return false;
  259. new ln = -1;
  260. while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  261. {
  262. ln ++;
  263. if (gCache[ln][E_VALUE][0] == ';') continue;
  264. if (!strcmp(gCache[ln][E_KEY], key, false))
  265. {
  266. INI_strcpy(gCache[ln][E_VALUE], value, INI_MAX_VALUE, INI_MAX_VALUE);
  267. return true;
  268. }
  269. }
  270. ln ++;
  271. if (ln < INI_MAX_LINES)
  272. {
  273. INI_strcpy(gCache[ln][E_KEY], key, INI_MAX_KEY, INI_MAX_KEY);
  274. INI_strcpy(gCache[ln][E_VALUE], value, INI_MAX_VALUE, INI_MAX_VALUE);
  275. return true;
  276. }
  277. return false;
  278. }
  279.  
  280. stock INI_WriteInt(const key[], value)
  281. {
  282. new dest[12];
  283. format(dest, sizeof(dest), "%i", value);
  284. return INI_WriteString(key, dest);
  285. }
  286.  
  287. stock INI_WriteFloat(const key[], Float: value)
  288. {
  289. new dest[12];
  290. format(dest, sizeof(dest), "%f", value);
  291. return INI_WriteString(key, dest);
  292. }
  293.  
  294. stock INI_WriteBool(const key[], bool:value)
  295. {
  296. if(value)
  297. {
  298. return INI_WriteString(key, "1");
  299. }
  300. else return INI_WriteString(key, "0");
  301. }
  302.  
  303. stock INI_ReadString(const key[])
  304. {
  305. new dest[INI_MAX_VALUE];
  306.  
  307. if ((!gFile[E_OPEN]) || (!key[0])) return dest;
  308. new ln = -1;
  309. while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  310. {
  311. ln ++;
  312. if (gCache[ln][E_VALUE][0] == ';') continue;
  313. if (!strcmp(gCache[ln][E_KEY], key, false))
  314. {
  315. INI_strcpy(dest, gCache[ln][E_VALUE], INI_MAX_VALUE, INI_MAX_VALUE);
  316. return dest;
  317. }
  318. }
  319. return dest;
  320. }
  321.  
  322. stock INI_ReadInt(const key[])
  323. {
  324. return strval(INI_ReadString(key));
  325. }
  326.  
  327. stock Float:INI_ReadFloat(const key[])
  328. {
  329. return floatstr(INI_ReadString(key));
  330. }
  331.  
  332. stock bool:INI_ReadBool(const key[])
  333. {
  334. if(strval(INI_ReadString(key)))
  335. {
  336. return true;
  337. }
  338. else return false;
  339. }
  340.  
  341. stock INI_MultiWrite(format[], {Float,_}:...)
  342. {
  343. new E_i = 0x-1;
  344.  
  345. while(++E_i < strlen(format))
  346. {
  347. new E_l = 0x-1,
  348. E_loop = -1,
  349. E_string[INI_MAX_VALUE],
  350. E_paramtar[0x80];
  351.  
  352. while(++E_l < 0x80)
  353. {
  354. E_paramtar[E_l] = getarg(1 + (E_i * 2), E_l);
  355. }
  356. switch(format[E_i])
  357. {
  358. case 'b': INI_WriteBool(E_paramtar, bool:getarg(2 + (E_i * 2)));
  359. case 'd', 'i': INI_WriteInt(E_paramtar, getarg(2 + (E_i * 2)));
  360. case 'f': INI_WriteFloat(E_paramtar, Float:(getarg(2 + (E_i * 2))));
  361. case 's':
  362. {
  363. while(++E_loop != 0x100)
  364. {
  365. E_string[E_loop] = getarg(2 + (E_i * 2), E_loop);
  366. }
  367. INI_WriteString(E_paramtar, E_string);
  368. }
  369. }
  370. }
  371. return true;
  372. }
  373.  
  374. stock INI_MultiRead(format[], {Float,_}:...)
  375. {
  376. new E_i = 0x-1;
  377.  
  378. while(++E_i < strlen(format))
  379. {
  380. new E_l = 0x-1,
  381. E_loop = 0x-1,
  382. E_parameter[0x80],
  383. E_string[INI_MAX_VALUE];
  384.  
  385. while(++E_l < 0x80)
  386. {
  387. E_parameter[E_l] = getarg(1 + (E_i * 2), E_l);
  388. }
  389. switch(format[E_i])
  390. {
  391. case 'b': setarg(2 + (E_i * 2), 0, INI_ReadBool(E_parameter));
  392. case 'd', 'i': setarg(2 + (E_i * 2), 0, INI_ReadInt(E_parameter));
  393. case 'f': setarg(2 + (E_i * 2), 0, _:INI_ReadFloat(E_parameter));
  394. case 's':
  395. {
  396. E_string = INI_ReadString(E_parameter);
  397.  
  398. while(strlen(E_string) != E_loop++)
  399. {
  400. setarg(2 + (E_i * 2), E_loop, E_string[E_loop]);
  401. }
  402. }
  403. }
  404. }
  405. return true;
  406. }
  407.  
  408. stock INI_RemoveKey(const key[])
  409. {
  410. if ((!gFile[E_OPEN]) || (!key[0]) || (strfind(key, "=", false) != -1)) return false;
  411. new ln = -1;
  412. while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  413. {
  414. ln ++;
  415. if (gCache[ln][E_VALUE][0] == ';') continue;
  416. if (!strcmp(gCache[ln][E_KEY], key, false))
  417. {
  418. for (; ln < (INI_MAX_LINES - 1); ln ++)
  419. {
  420. INI_strcpy(gCache[ln][E_KEY], gCache[ln + 1][E_KEY], INI_MAX_KEY, INI_MAX_KEY);
  421. INI_strcpy(gCache[ln][E_VALUE], gCache[ln + 1][E_VALUE], INI_MAX_VALUE, INI_MAX_VALUE);
  422. }
  423. return true;
  424. }
  425. }
  426. return false;
  427. }
  428.  
  429. stock INI_KeyExist(const key[])
  430. {
  431. if ((!gFile[E_OPEN]) || (!key[0]) || (strfind(key, "=", false) != -1)) return false;
  432. new ln = -1;
  433. while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  434. {
  435. ln ++;
  436. if (gCache[ln][E_VALUE][0] == ';') continue;
  437. if (!strcmp(gCache[ln][E_KEY], key, false))
  438. {
  439. return true;
  440. }
  441. }
  442. return false;
  443. }
  444.  
  445. stock INI_ReturnFile()
  446. {
  447. if ((!gFile[E_OPEN])) return false;
  448. else return gFile[E_OPEN];
  449. }
  450.  
  451. stock INI_ReturnFilename()
  452. {
  453. if ((!gFile[E_OPEN])) return gFile[E_FILENAME];
  454. else return gFile[E_FILENAME];
  455. }
  456.  
  457. //system functions
  458. stock INI_strcpy(dest[], const source[], numcells = sizeof(source), maxlength = sizeof(dest))
  459. {
  460. new i;
  461. while ((source[i]) && (i < numcells) && (i < maxlength))
  462. {
  463. dest[i] = source[i];
  464. i ++;
  465. }
  466. dest[(i == maxlength) ? (i - 1) : (i)] = '\0';
  467. }
  468.  
  469. stock INI_StripLine(string[])
  470. {
  471. new l;
  472. l = strlen(string);
  473. if (string[l - 2] == '\r') string[l - 2] = '\0';
  474. if (string[l - 1] == '\n') string[l - 1] = '\0';
  475. }
  476.  
  477. //converting system
  478. #if(INI_CONVERT)
  479.  
  480. // -> converting DINI(one of the best ini code!)
  481. #if defined dini_Exists
  482. #undef dini_Exists
  483. #endif
  484. #define dini_Exists fexist
  485.  
  486. #if defined dini_Remove
  487. #undef dini_Remove
  488. #endif
  489. #define dini_Remove INI_Remove
  490.  
  491. #if defined dini_Create
  492. #undef dini_Create
  493. #endif
  494. #define dini_Create INI_Create
  495.  
  496. stock dini_Set(filename[],key[],value[])
  497. {
  498. INI_Open(filename);
  499. return INI_WriteString(key, value);
  500. }
  501.  
  502. stock dini_IntSet(filename[],key[],value)
  503. {
  504. INI_Open(filename);
  505. return INI_WriteInt(key, value);
  506. }
  507.  
  508. stock dini_FloatSet(filename[],key[],Float:value)
  509. {
  510. INI_Open(filename);
  511. return INI_WriteFloat(key, value);
  512. }
  513.  
  514. stock dini_BoolSet(filename[],key[],value)
  515. {
  516. INI_Open(filename);
  517. if(value)
  518. {
  519. return INI_WriteBool(key, true);
  520. }
  521. return INI_WriteBool(key, false);
  522. }
  523.  
  524. stock dini_Get(filename[],key[])
  525. {
  526. INI_Open(filename);
  527. return INI_ReadString(key);
  528. }
  529.  
  530. stock dini_Int(filename[],key[])
  531. {
  532. INI_Open(filename);
  533. return INI_ReadInt(key);
  534. }
  535.  
  536. stock Float:dini_Float(filename[],key[])
  537. {
  538. INI_Open(filename);
  539. return INI_ReadFloat(key);
  540. }
  541.  
  542. stock dini_Bool(filename[],key[])
  543. {
  544. INI_Open(filename);
  545. if(INI_ReadBool(key))
  546. {
  547. return true;
  548. }
  549. else return false;
  550. }
  551.  
  552. stock dini_UnSet(filename[],key[])
  553. {
  554. INI_Open(filename);
  555. return INI_RemoveKey(key);
  556. }
  557.  
  558. stock dini_Isset(filename[],key[])
  559. {
  560. INI_Open(filename);
  561. return INI_KeyExist(key);
  562. }
  563.  
  564. #if defined DINI_StripNewLine
  565. #undef DINI_StripNewLine
  566. #endif
  567. #define DINI_StripNewLine INI_StripLine
  568.  
  569. stock DINI_fcopytextfile(filename[],copyname[])
  570. {
  571. INI_Open(filename);
  572. return INI_Copy(copyname);
  573. }
  574.  
  575. // -> converting SMF(Southclaw file manager)
  576. #if defined file_Create
  577. #undef file_Create
  578. #endif
  579. #define file_Create INI_Create
  580.  
  581. #if defined file_Delete
  582. #undef file_Delete
  583. #endif
  584. #define file_Delete INI_Remove
  585.  
  586. #if defined file_Open
  587. #undef file_Open
  588. #endif
  589. #define file_Open INI_Open
  590.  
  591. #if defined file_Save
  592. #undef file_Save
  593. #endif
  594. #define file_Save INI_Save
  595.  
  596. #if defined file_Close
  597. #undef file_Close
  598. #endif
  599. #define file_Close INI_Close
  600.  
  601. #if defined file_SetStr
  602. #undef file_SetStr
  603. #endif
  604. #define file_SetStr INI_WriteString
  605.  
  606. #if defined file_SetVal
  607. #undef file_SetVal
  608. #endif
  609. #define file_SetVal INI_WriteInt
  610.  
  611. #if defined file_SetFloat
  612. #undef file_SetFloat
  613. #endif
  614. #define file_SetFloat INI_WriteFloat
  615.  
  616. #if defined file_RemoveKey
  617. #undef file_RemoveKey
  618. #endif
  619. #define file_RemoveKey INI_RemoveKey
  620.  
  621. #if defined file_IncVal
  622. #undef file_IncVal
  623. #endif
  624. #define file_IncVal(%1,%2) INI_WriteInt(%1, INI_ReadInt(%1) + %2)
  625.  
  626. #if defined file_GetStr
  627. #undef file_GetStr
  628. #endif
  629. #define file_GetStr INI_ReadString
  630.  
  631. #if defined file_GetVal
  632. #undef file_GetVal
  633. #endif
  634. #define file_GetVal INI_ReadInt
  635.  
  636. #if defined file_GetFloat
  637. #undef file_GetFloat
  638. #endif
  639. #define file_GetFloat INI_ReadFloat
  640.  
  641. #if defined file_IsKey
  642. #undef file_IsKey
  643. #endif
  644. #define file_IsKey INI_KeyExist
  645.  
  646. #if defined file_dGetStr
  647. #undef file_dGetStr
  648. #endif
  649. #define file_dGetStr dini_Get
  650.  
  651. #if defined file_dGetVal
  652. #undef file_dGetVal
  653. #endif
  654. #define file_dGetVal dini_Int
  655.  
  656. #if defined file_dGetFloat
  657. #undef file_dGetFloat
  658. #endif
  659. #define file_dGetFloat dini_Float
  660.  
  661. // -> converting DUDB
  662. #define UDB_ACCOUNT_PATH "Accounts"//specify the path where the user files will be made!
  663.  
  664. #if defined dUser
  665. #undef dUser
  666. #endif
  667. #define dUser(%1).( UDB_ReadString(%1,
  668.  
  669. #if defined dUserSet
  670. #undef dUserSet
  671. #endif
  672. #define dUserSet(%1).( UDB_WriteString(%1,
  673.  
  674. #if defined dUserINT
  675. #undef dUserINT
  676. #endif
  677. #define dUserINT(%1).( UDB_ReadInt(%1,
  678.  
  679. #if defined dUserSetINT
  680. #undef dUserSetINT
  681. #endif
  682. #define dUserSetINT(%1).( UDB_WriteInt(%1,
  683.  
  684. #if defined dUserFLOAT
  685. #undef dUserFLOAT
  686. #endif
  687. #define dUserFLOAT(%1).( UDB_ReadFloat(%1,
  688.  
  689. #if defined dUserSetFLOAT
  690. #undef dUserSetFLOAT
  691. #endif
  692. #define dUserSetFLOAT(%1).( UDB_WriteFloat(%1,
  693.  
  694. #if defined udb_Exists
  695. #undef udb_Exists
  696. #endif
  697. #define udb_Exists UDB_Exist
  698.  
  699. #if defined udb_Remove
  700. #undef udb_Remove
  701. #endif
  702. #define udb_Remove UDB_Remove
  703.  
  704. #if defined udb_Create
  705. #undef udb_Create
  706. #endif
  707. #define udb_Create UDB_Create
  708.  
  709. #if defined udb_RenameUser
  710. #undef udb_RenameUser
  711. #endif
  712. #define udb_RenameUser UDB_Rename
  713.  
  714. #if defined udb_CheckLogin
  715. #undef udb_CheckLogin
  716. #endif
  717. #define udb_CheckLogin UDB_CheckPassword
  718.  
  719. #if defined udb_encode
  720. #undef udb_encode
  721. #endif
  722. #define udb_encode UDB_Encode
  723.  
  724. #if defined udb_decode
  725. #undef udb_decode
  726. #endif
  727. #define udb_decode UDB_Decode
  728.  
  729. stock strreplace(trg[],newstr[],src[])//Thanks to DracoBlue (dutils)
  730. {
  731. new f=0;
  732. new s1[INI_MAX_VALUE];
  733. new tmp[INI_MAX_VALUE];
  734. format(s1,sizeof(s1),"%s",src);
  735. f = strfind(s1,trg);
  736. tmp[0]=0;
  737. while (f>=0)
  738. {
  739. strcat(tmp,ret_memcpy(s1, 0, f));
  740. strcat(tmp,newstr);
  741. format(s1,sizeof(s1),"%s",ret_memcpy(s1, f+strlen(trg), strlen(s1)-f));
  742. f = strfind(s1,trg);
  743. }
  744. strcat(tmp,s1);
  745. return tmp;
  746. }
  747.  
  748. stock set(dest[],source[])//Thanks to DracoBlue (dutils)
  749. {
  750. new count = strlen(source);
  751. new i=0;
  752. for (i=0;i<count;i++) {
  753. dest[i]=source[i];
  754. }
  755. dest[count]=0;
  756. }
  757.  
  758. stock UDB_Encode(nickname[])//Thanks to DracoBlue (dudb)
  759. {
  760. new tmp[INI_MAX_VALUE];
  761. set(tmp,nickname);
  762. tmp=strreplace("_","_00",tmp);
  763. tmp=strreplace(";","_01",tmp);
  764. tmp=strreplace("!","_02",tmp);
  765. tmp=strreplace("/","_03",tmp);
  766. tmp=strreplace("\\","_04",tmp);
  767. tmp=strreplace("[","_05",tmp);
  768. tmp=strreplace("]","_06",tmp);
  769. tmp=strreplace("?","_07",tmp);
  770. tmp=strreplace(".","_08",tmp);
  771. tmp=strreplace("*","_09",tmp);
  772. tmp=strreplace("<","_10",tmp);
  773. tmp=strreplace(">","_11",tmp);
  774. tmp=strreplace("{","_12",tmp);
  775. tmp=strreplace("}","_13",tmp);
  776. tmp=strreplace(" ","_14",tmp);
  777. tmp=strreplace("\"","_15",tmp);
  778. tmp=strreplace(":","_16",tmp);
  779. tmp=strreplace("|","_17",tmp);
  780. tmp=strreplace("=","_18",tmp);
  781. return tmp;
  782. }
  783.  
  784. stock UDB_Decode(nickname[])//Thanks to DracoBlue (dudb)
  785. {
  786. new tmp[MAX_STRING];
  787. set(tmp,nickname);
  788. tmp=strreplace("_01",";",tmp);
  789. tmp=strreplace("_02","!",tmp);
  790. tmp=strreplace("_03","/",tmp);
  791. tmp=strreplace("_04","\\",tmp);
  792. tmp=strreplace("_05","[",tmp);
  793. tmp=strreplace("_06","]",tmp);
  794. tmp=strreplace("_07","?",tmp);
  795. tmp=strreplace("_08",".",tmp);
  796. tmp=strreplace("_09","*",tmp);
  797. tmp=strreplace("_10","<",tmp);
  798. tmp=strreplace("_11",">",tmp);
  799. tmp=strreplace("_12","{",tmp);
  800. tmp=strreplace("_13","}",tmp);
  801. tmp=strreplace("_14"," ",tmp);
  802. tmp=strreplace("_15","\"",tmp);
  803. tmp=strreplace("_16",":",tmp);
  804. tmp=strreplace("_17","|",tmp);
  805. tmp=strreplace("_18","=",tmp);
  806. tmp=strreplace("_00","_",tmp);
  807. return tmp;
  808. }
  809.  
  810. stock UDB_Exist(username[])
  811. {
  812. new string[INI_MAX_VALUE];
  813. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  814. return fexist(string);
  815. }
  816.  
  817. stock UDB_Create(username[], password[])
  818. {
  819. new string[INI_MAX_VALUE];
  820. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  821. INI_Open(string);
  822. INI_WriteString("Password", password);
  823. return INI_Close();
  824. }
  825.  
  826. stock UDB_Remove(username[])
  827. {
  828. new string[INI_MAX_VALUE];
  829. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  830. return INI_Remove(string);
  831. }
  832.  
  833. stock UDB_WriteInt(username[], key[], value)
  834. {
  835. new string[INI_MAX_VALUE];
  836. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  837. return dini_IntSet(string, key, value);
  838. }
  839.  
  840. stock UDB_WriteFloat(username[], key[], Float:value)
  841. {
  842. new string[INI_MAX_VALUE];
  843. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  844. return dini_FloatSet(string, key, value);
  845. }
  846.  
  847. stock UDB_WriteBool(username[], key[], bool:value)
  848. {
  849. new string[INI_MAX_VALUE];
  850. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  851. return dini_BoolSet(string, key, value);
  852. }
  853.  
  854. stock UDB_WriteString(username[], key[], value[])
  855. {
  856. new string[INI_MAX_VALUE];
  857. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  858. return dini_Set(string, key, value);
  859. }
  860.  
  861. stock UDB_ReadInt(username[], key[])
  862. {
  863. new string[INI_MAX_VALUE];
  864. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  865. return dini_Int(string, key);
  866. }
  867.  
  868. stock Float:UDB_ReadFloat(username[], key[])
  869. {
  870. new string[INI_MAX_VALUE];
  871. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  872. return dini_Float(string, key);
  873. }
  874.  
  875. stock UDB_ReadBool(username[], key[])
  876. {
  877. new string[INI_MAX_VALUE];
  878. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  879. return dini_Bool(string, key);
  880. }
  881.  
  882. stock UDB_ReadString(username[], key[])
  883. {
  884. new string[INI_MAX_VALUE];
  885. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  886. return dini_Get(string, key);
  887. }
  888.  
  889. stock UDB_Rename(username[], newname[])
  890. {
  891. new string[INI_MAX_VALUE];
  892. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  893. INI_Open(string);
  894. return INI_Rename(string, newname);
  895. }
  896.  
  897. stock UDB_Copy(username[], copyname[])
  898. {
  899. new string[INI_MAX_VALUE];
  900. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  901. INI_Open(string);
  902. return INI_Copy(string, copyname);
  903. }
  904.  
  905. stock UDB_CheckPassword(username[], password[])
  906. {
  907. new string[INI_MAX_VALUE];
  908. format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.dudb.sav",username);
  909. INI_Open(string);
  910.  
  911. if(! strcmp(password, INI_ReadString("Password")))
  912. {
  913. INI_Close();
  914. return true;
  915. }
  916. else
  917. {
  918. INI_Close();
  919. return false;
  920. }
  921. }
  922.  
  923. // -> converting FINI
  924. // INI_WriteString("key", "valor") //already defined in n_ini
  925. // INI_WriteFloat("key", valor) //already defined in n_ini
  926. // INI_WriteInt("key", valor) //already defined in n_ini
  927. // INI_ReadString("key") //already defined in n_ini
  928. // INI_ReadInt("key") //already defined in n_ini
  929. // INI_ReadFloat("key") //already defined in n_ini
  930. // INI_Create() //already defined in n_ini
  931. // INI_Open("arquivo") //already defined in n_ini
  932.  
  933. #if defined INI_Isset
  934. #undef INI_Isset
  935. #endif
  936. #define INI_Isset INI_KeyExist
  937.  
  938. // INI_Close() //already defined in n_ini
  939. // INI_Save() //already defined in n_ini
  940.  
  941. // -> Converting SF - Simple File
  942. #if defined FileCreate
  943. #undef FileCreate
  944. #endif
  945. #define FileCreate(%1,%2) INI_Create(%1)
  946.  
  947. #if defined FileDelete
  948. #undef FileDelete
  949. #endif
  950. #define FileDelete INI_Remove
  951.  
  952. #if defined FileExist
  953. #undef FileExist
  954. #endif
  955. #define FileExist INI_Exist
  956.  
  957. #if defined SaveFileString
  958. #undef SaveFileString
  959. #endif
  960. #define SaveFileString(%1,%2,%3) dini_Set(%1,%2,%3)
  961.  
  962. #if defined SaveFileInteger
  963. #undef SaveFileInteger
  964. #endif
  965. #define SaveFileInteger(%1,%2,%3) dini_IntSet(%1,%2,%3)
  966.  
  967. #if defined SaveFileFloat
  968. #undef SaveFileFloat
  969. #endif
  970. #define SaveFileFloat(%1,%2,%3) dini_FloatSet(%1,%2,%3)
  971.  
  972. #if defined GetFileString
  973. #undef GetFileString
  974. #endif
  975. #define GetFileString(%1,%2) dini_Get(%1,%2)
  976.  
  977. #if defined GetFileInteger
  978. #undef GetFileInteger
  979. #endif
  980. #define GetFileInteger(%1,%2) dini_IntGet(%1,%2)
  981.  
  982. #if defined GetFileFloat
  983. #undef GetFileFloat
  984. #endif
  985. #define GetFileFloat(%1,%2) dini_FloatGet(%1,%2)
  986.  
  987. #if defined EditFileName
  988. #undef EditFileName
  989. #endif
  990. #define EditFileName(%1,%2) dini_Rename(%1,%2)
  991.  
  992. // -> Converting dFile
  993. #if defined dfile_Create
  994. #undef dfile_Create
  995. #endif
  996. #define dfile_Create INI_Create
  997.  
  998. #if defined dfile_Delete
  999. #undef dfile_Delete
  1000. #endif
  1001. #define dfile_Delete INI_Remove
  1002.  
  1003. #if defined dfile_Open
  1004. #undef dfile_Open
  1005. #endif
  1006. #define dfile_Open INI_Open
  1007.  
  1008. #if defined dfile_WriteString
  1009. #undef dfile_WriteString
  1010. #endif
  1011. #define dfile_WriteString INI_WriteString
  1012.  
  1013. #if defined dfile_WriteInt
  1014. #undef dfile_WriteInt
  1015. #endif
  1016. #define dfile_WriteInt INI_WriteInt
  1017.  
  1018. #if defined dfile_WriteBool
  1019. #undef dfile_WriteBool
  1020. #endif
  1021. #define dfile_WriteBool INI_WriteBool
  1022.  
  1023. #if defined dfile_WriteFloat
  1024. #undef dfile_WriteFloat
  1025. #endif
  1026. #define dfile_WriteFloat INI_WriteFloat
  1027.  
  1028. #if defined dfile_ReadString
  1029. #undef dfile_ReadString
  1030. #endif
  1031. #define dfile_ReadString INI_ReadString
  1032.  
  1033. #if defined dfile_ReadInt
  1034. #undef dfile_ReadInt
  1035. #endif
  1036. #define dfile_ReadInt INI_ReadInt
  1037.  
  1038. #if defined dfile_ReadFloat
  1039. #undef dfile_ReadFloat
  1040. #endif
  1041. #define dfile_ReadFloat INI_ReadFloat
  1042.  
  1043. #if defined dfile_ReadBool
  1044. #undef dfile_ReadBool
  1045. #endif
  1046. #define dfile_ReadBool INI_ReadBool
  1047.  
  1048. #if defined dfile_MoveFile
  1049. #undef dfile_MoveFile
  1050. #endif
  1051. #define dfile_MoveFile INI_Rename
  1052.  
  1053. #if defined dfile_RenameFile
  1054. #undef dfile_RenameFile
  1055. #endif
  1056. #define dfile_RenameFile INI_Rename
  1057.  
  1058. #if defined dfile_SaveFile
  1059. #undef dfile_SaveFile
  1060. #endif
  1061. #define dfile_SaveFile INI_Save
  1062.  
  1063. #if defined dfile_FileExists
  1064. #undef dfile_FileExists
  1065. #endif
  1066. #define dfile_FileExists fexist
  1067.  
  1068. #if defined dfile_ParseString
  1069. #undef dfile_ParseString
  1070. #endif
  1071. #define dfile_ParseString dini_Get
  1072.  
  1073. #if defined dfile_ParseInt
  1074. #undef dfile_ParseInt
  1075. #endif
  1076. #define dfile_ParseInt dini_Int
  1077.  
  1078. #if defined dfile_ParseFloat
  1079. #undef dfile_ParseFloat
  1080. #endif
  1081. #define dfile_ParseFloat dini_Float
  1082.  
  1083. #if defined dfile_ParseBool
  1084. #undef dfile_ParseBool
  1085. #endif
  1086. #define dfile_ParseBool dini_Bool
  1087.  
  1088. #if defined dfile_IsSet
  1089. #undef dfile_IsSet
  1090. #endif
  1091. #define dfile_IsSet INI_KeyExist
  1092.  
  1093. #if defined dfile_UnSet
  1094. #undef dfile_UnSet
  1095. #endif
  1096. #define dfile_UnSet INI_RemoveKey
  1097.  
  1098. #if defined dfile_MultiSet
  1099. #undef dfile_MultiSet
  1100. #endif
  1101. #define dfile_MultiSet INI_MultiWrite
  1102.  
  1103. #if defined dfile_MultiGet
  1104. #undef dfile_MultiGet
  1105. #endif
  1106. #define dfile_MultiGet INI_MultiRead
  1107.  
  1108. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!