API tools faq
paste
Guest User

n_ini(v2) by Neufox

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