API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 9th, 2012
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.06 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  
  3. ri File - Version 1.1.0
  4. © 2012 by RFT
  5.  
  6. */
  7. #include <a_samp>
  8.  
  9.  
  10.  
  11. /*
  12. native ri_Create(File[]);
  13. native ri_Open(File[]);
  14. native ri_Close();
  15. native ri_Save();
  16. native ri_ReadString(Var[], str[]);
  17. native ri_ReadInt(Var[]);
  18. native ri_ReadFloat(Var[]);
  19. native ri_WriteString(Var[], str[]);
  20. native ri_WriteInt(Var[], inte);
  21. native ri_WriteFloat(Var[], Float:f);
  22. native ri_Remove(File[]);
  23. native ri_Duplicate();
  24. native ri_Debug();
  25. native ri_Delline(Var[]);
  26. */
  27.  
  28.  
  29.  
  30.  
  31. new ri_path[32];
  32. new ri_Cache[100][128];
  33. new ri_line[100];
  34. new ri_line_counter;
  35. new ri_readed=0;
  36. new bool:ri_Debugging;
  37.  
  38.  
  39. stock ri_Create(File[])
  40. {
  41. new string[128];
  42. if(fexist(File))
  43. {
  44. if(ri_Debugging == true)
  45. {
  46. new Day, Month, Year, Minute, Hour;
  47. gettime(Hour, Minute);
  48. getdate(Year, Month, Day);
  49. new File:rFile = fopen("/ri/Debug.log", io_append);
  50. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Datei exestiert bereits!\r\n", Day, Month, Year, Hour, Minute);
  51. fwrite(rFile, string);
  52. fclose(rFile);
  53. return false;
  54. }
  55. }
  56. else if(ri_readed==1)
  57. {
  58. if(ri_Debugging == true)
  59. {
  60. new Day, Month, Year, Minute, Hour;
  61. gettime(Hour, Minute);
  62. getdate(Year, Month, Day);
  63. new File:rFile = fopen("/ri/Debug.log", io_append);
  64. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Es ist eine Datei geladen.!\r\n", Day, Month, Year, Hour, Minute);
  65. fwrite(rFile, string);
  66. fclose(rFile);
  67. return false;
  68. }
  69. }
  70. else
  71. {
  72. new File:w_file=fopen(File, io_write);
  73. fclose(w_file);
  74. return true;
  75. }
  76. return 0;
  77. }
  78.  
  79. stock ri_Remove(File[])
  80. {
  81. new string[128];
  82. if(!fexist(File))
  83. {
  84. if(ri_Debugging == true)
  85. {
  86. new Day, Month, Year, Minute, Hour;
  87. gettime(Hour, Minute);
  88. getdate(Year, Month, Day);
  89. new File:rFile = fopen("/ri/Debug.log", io_append);
  90. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Datei exestiert nicht!\r\n", Day, Month, Year, Hour, Minute);
  91. fwrite(rFile, string);
  92. fclose(rFile);
  93. }
  94. }
  95. else if(ri_readed==1)
  96. {
  97. if(ri_Debugging == true)
  98. {
  99. new Day, Month, Year, Minute, Hour;
  100. gettime(Hour, Minute);
  101. getdate(Year, Month, Day);
  102. new File:rFile = fopen("/ri/Debug.log", io_append);
  103. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Es ist eine Datei geladen.!\r\n", Day, Month, Year, Hour, Minute);
  104. fwrite(rFile, string);
  105. fclose(rFile);
  106. }
  107. }
  108. fremove(File);
  109. return true;
  110. }
  111.  
  112. stock ri_Open(File[])
  113. {
  114. new string[128];
  115. if(!fexist(File))
  116. {
  117. if(ri_Debugging == true)
  118. {
  119. new Day, Month, Year, Minute, Hour;
  120. gettime(Hour, Minute);
  121. getdate(Year, Month, Day);
  122. new File:rFile = fopen("/ri/Debug.log", io_append);
  123. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Datei exestiert nicht!\r\n", Day, Month, Year, Hour, Minute);
  124. fwrite(rFile, string);
  125. fclose(rFile);
  126. return 1;
  127. }
  128. }
  129. else if(ri_readed==1)
  130. {
  131. if(ri_Debugging == true)
  132. {
  133. new Day, Month, Year, Minute, Hour;
  134. gettime(Hour, Minute);
  135. getdate(Year, Month, Day);
  136. new File:rFile = fopen("/ri/Debug.log", io_append);
  137. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Es ist eine Datei geladen.!\r\n", Day, Month, Year, Hour, Minute);
  138. fwrite(rFile, string);
  139. fclose(rFile);
  140. return 1;
  141. }
  142. }
  143. ri_readed=1;
  144. printf("%d", ri_readed);
  145. new File:r_file=fopen(File, io_read);
  146. strmid(ri_path, File, 0, strlen(File), 64);
  147. new c=0, load[128];
  148. while(fread(r_file, load))
  149. {
  150. new len=strlen(load);
  151. strmid(ri_Cache[c], load, 0, len-2, 128);
  152. ri_line[c]=1;
  153. ri_line_counter++;
  154. c++;
  155. }
  156. fclose(r_file);
  157. return 1;
  158. }
  159.  
  160. stock ri_Close()
  161. {
  162. new string[128];
  163. if(ri_readed == 0)
  164. {
  165. if(ri_Debugging == true)
  166. {
  167. new Day, Month, Year, Minute, Hour;
  168. gettime(Hour, Minute);
  169. getdate(Year, Month, Day);
  170. new File:rFile = fopen("/ri/Debug.log", io_append);
  171. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Keine Datei geladen!\r\n", Day, Month, Year, Hour, Minute);
  172. fwrite(rFile, string);
  173. fclose(rFile);
  174. }
  175. return 0;
  176. }
  177. ri_readed = 0;
  178. for(new i = 0; i < sizeof(ri_Cache); i++)
  179. {
  180. if(ri_line[i]==0)continue;
  181. ri_Cache[i]="\n";
  182. ri_line[i]=0;
  183. ri_line_counter=0;
  184. }
  185. return true;
  186. }
  187.  
  188. stock ri_Save()
  189. {
  190. new string[128];
  191. if(ri_readed == 0)
  192. {
  193. if(ri_Debugging == true)
  194. {
  195. new Day, Month, Year, Minute, Hour;
  196. gettime(Hour, Minute);
  197. getdate(Year, Month, Day);
  198. new File:rFile = fopen("/ri/Debug.log", io_append);
  199. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Keine Datei geladen!\r\n", Day, Month, Year, Hour, Minute);
  200. fwrite(rFile, string);
  201. fclose(rFile);
  202. }
  203. return 0;
  204. }
  205. new File:w_file=fopen(ri_path, io_write);
  206. new str[128];
  207. for(new i = 0; i < sizeof(ri_Cache); i++)
  208. {
  209. if(ri_line[i]==0)continue;
  210. format(str, sizeof(str), "%s\r\n", ri_Cache[i]);
  211. fwrite(w_file, str);
  212. }
  213. fclose(w_file);
  214. return true;
  215. }
  216.  
  217. stock ri_ReadString(Var[], str[])
  218. {
  219. new string[128];
  220. if(ri_readed == 0)
  221. {
  222. if(ri_Debugging == true)
  223. {
  224. new Day, Month, Year, Minute, Hour;
  225. gettime(Hour, Minute);
  226. getdate(Year, Month, Day);
  227. new File:rFile = fopen("/ri/Debug.log", io_append);
  228. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Keine Datei geladen!\r\n", Day, Month, Year, Hour, Minute);
  229. fwrite(rFile, string);
  230. fclose(rFile);
  231. }
  232. return 0;
  233. }
  234. for(new i = 0; i < sizeof(ri_Cache); i++)
  235. {
  236. if(ri_line[i]==0)continue;
  237. if(strfind(ri_Cache[i], Var, true)!=-1)
  238. {
  239. new s=strfind(ri_Cache[i], "=", true);
  240. if(s!=-1)
  241. {
  242. s++;
  243. new o=strlen(ri_Cache[i][s]);
  244. strmid(str, ri_Cache[i], s, s+o, 128);
  245. return true;
  246. }
  247. }
  248. }
  249. new Day, Month, Year, Minute, Hour;
  250. gettime(Hour, Minute);
  251. getdate(Year, Month, Day);
  252. new File:rFile = fopen("/ri/Debug.log", io_append);
  253. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler Bezeichnung: %s nicht gefunden!\r\n", Day, Month, Year, Hour, Minute, Var);
  254. fwrite(rFile, string);
  255. fclose(rFile);
  256. return 0;
  257. }
  258.  
  259. stock ri_ReadInt(Var[])
  260. {
  261. new str[128];
  262. ri_ReadString(Var, str);
  263. return strval(str);
  264. }
  265.  
  266. stock ri_ReadFloat(Var[])
  267. {
  268. new str[128];
  269. ri_ReadString(Var, str);
  270. return float:floatstr(str);
  271. }
  272.  
  273. stock ri_WriteString(Var[], str[])
  274. {
  275. new string[128];
  276. if(ri_readed == 0)
  277. {
  278. if(ri_Debugging == true)
  279. {
  280. new Day, Month, Year, Minute, Hour;
  281. gettime(Hour, Minute);
  282. getdate(Year, Month, Day);
  283. new File:rFile = fopen("/ri/Debug.log", io_append);
  284. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Keine Datei geladen!\r\n", Day, Month, Year, Hour, Minute);
  285. fwrite(rFile, string);
  286. fclose(rFile);
  287. }
  288. return 0;
  289. }
  290. for(new i = 0; i < sizeof(ri_Cache); i++)
  291. {
  292. if(ri_line[i]==0)continue;
  293. if(strfind(ri_Cache[i], Var, true)!=-1)
  294. {
  295. new s=strfind(ri_Cache[i], "=", true);
  296. s++;
  297. strdel(ri_Cache[i], s, 128);
  298. strins(ri_Cache[i], str, s, 128);
  299. return true;
  300. }
  301. }
  302. ri_line_counter++;
  303. format(ri_Cache[ri_line_counter], 128, "%s=%s", Var, str);
  304. ri_line[ri_line_counter]=1;
  305. return true;
  306. }
  307.  
  308. stock ri_WriteInt(Var[], inte)
  309. {
  310. new str[32];
  311. format(str, sizeof(str), "%d", inte);
  312. ri_WriteString(Var, str);
  313. return true;
  314. }
  315.  
  316. stock ri_WriteFloat(Var[], Float:f)
  317. {
  318. new str[32];
  319. format(str, sizeof(str), "%f", f);
  320. ri_WriteString(Var, str);
  321. return true;
  322. }
  323.  
  324. stock getFreeFileSlot(File[])
  325. {
  326. new str[64];
  327. for(new i = 1; i < 100; i++)
  328. {
  329. format(str, sizeof(str), "%s(%d).ini", File, i);
  330. if(!fexist(str))
  331. {
  332. return i;
  333. }
  334. }
  335. if(ri_Debugging == true)
  336. {
  337. new Day, Month, Year, Minute, Hour;
  338. gettime(Hour, Minute);
  339. getdate(Year, Month, Day);
  340. new File:rFile = fopen("/ri/Debug.log", io_append);
  341. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Kein Freier Slot gefunden.\r\n", Day, Month, Year, Hour, Minute);
  342. fwrite(rFile, string);
  343. fclose(rFile);
  344. }
  345. return -1;
  346. }
  347.  
  348. stock ri_Duplicate()
  349. {
  350. new str[64];
  351. if(ri_readed == 1)
  352. {
  353. new id = getFreeFileSlot(ri_path);
  354. format(str, sizeof(str), "%s(%d).ini", ri_path, id);
  355. ri_Create(str);
  356. new OldPath[64];
  357. strmid(OldPath, ri_path, 0, strlen(ri_path), 64);
  358. strmid(ri_path, str, 0, strlen(str), 64);
  359. ri_Save();
  360. strmid(ri_path, OldPath, 0, strlen(OldPath), 64);
  361. return 1;
  362. }
  363. else
  364. {
  365. if(ri_Debugging == true)
  366. {
  367. new string[128];
  368. new Day, Month, Year, Minute, Hour;
  369. gettime(Hour, Minute);
  370. getdate(Year, Month, Day);
  371. new File:rFile = fopen("/ri/Debug.log", io_append);
  372. format(string, sizeof(string), "[%02d.%02d.%d][%02d:%02d]: Fehler: Keine Datei geöffnet.\r\n", Day, Month, Year, Hour, Minute);
  373. fwrite(rFile, string);
  374. fclose(rFile);
  375. }
  376. return 0;
  377. }
  378. }
  379.  
  380. stock ri_Debug()
  381. {
  382. new string[128];
  383. ri_Debugging = true;
  384. new Day, Month, Year, Minute, Hour;
  385. gettime(Hour, Minute);
  386. getdate(Year, Month, Day);
  387. new File:rFile;
  388. if(fexist("/ri/Debug.log"))
  389. {
  390. rFile = fopen("/ri/Debug.log", io_append);
  391. }
  392. else
  393. {
  394. rFile = fopen("/ri/Debug.log", io_write);
  395. }
  396. fwrite(rFile, "__________________________________________________");
  397. format(string, sizeof(string), "ri_File Debug gestartet am: %02d.%02d.%d Um: %02d:%02d", Day, Month, Year, Hour, Minute);
  398. fwrite(rFile, string);
  399. fwrite(rFile, "__________________________________________________\r\n\n\n");
  400. fclose(rFile);
  401. return 1;
  402. }
  403.  
  404. stock ri_Delline(Var[])
  405. {
  406. for(new i = 0; i < sizeof(ri_Cache); i++)
  407. {
  408. if(ri_line[i]==0)continue;
  409. if(strfind(ri_Cache[i], Var, true)!=-1)
  410. {
  411. new s=strfind(ri_Cache[i], "=", true);
  412. if(s!=-1)
  413. {
  414. s++;
  415. ri_line[i] = 0;
  416. return true;
  417. }
  418. }
  419. }
  420. }
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!