API tools faq
paste
Guest User

Untitled

a guest
Apr 23rd, 2020
97
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.68 KB | None | 0 0
raw download clone embed print report
  1. /**********************************************************************************************************************************
  2. * *
  3. * )( Unsigned Long 61 Bit [Long Yoyo] )( *
  4. * *
  5. * Copyright © 2019 Abyss Morgan. All rights reserved. *
  6. * *
  7. * Website: adm.ct8.pl *
  8. * Download: adm.ct8.pl/r/download *
  9. * *
  10. * Plugins: None *
  11. * Modules: None *
  12. * *
  13. * File Version: 1.6.1 *
  14. * *
  15. * Pawn Unsigned Long for 32 Bit language (precision 61-bit) *
  16. * Available limit: *
  17. * 0 - 2 147 483 647 000 000 000 *
  18. * 0 - 2 000 000 000 000 000 000 *
  19. * *
  20. * Functions: *
  21. * IsValueContainLY(prefix,suffix,value); *
  22. * GetLYString(prefix,suffix,string[],maxdest = sizeof(string)); *
  23. * LYStringToLY(&prefix,&suffix,const string[]); //Reverse to GetLYString *
  24. * UpdateLY(&prefix,&suffix,value,limitprefix = DEFAULT_MAX_LY_PREFIX); *
  25. * AddSeparatorLY(string[],const separator[]); *
  26. * DeleteSeparatorLY(const string[],const separator[]); *
  27. * CalculatePercentLY(&prefix,&suffix,Float:percent = 0.0,increase = true,limitprefix = DEFAULT_MAX_LY_PREFIX); *
  28. * GetPercentLY(prefix,suffix,&o_prefix,&o_suffix,Float:percent = 0.0,limitprefix = DEFAULT_MAX_LY_PREFIX); *
  29. * *
  30. * Operators: *
  31. * IsLYEqual(prefix,suffix,from_prefix,from_suffix); *
  32. * IsLYSmallerThan(prefix,suffix,from_prefix,from_suffix); *
  33. * IsLYSmallerThanOrEqual(prefix,suffix,from_prefix,from_suffix); *
  34. * IsLYBiggerThan(prefix,suffix,from_prefix,from_suffix); *
  35. * IsLYBiggerThanOrEqual(prefix,suffix,from_prefix,from_suffix); *
  36. * *
  37. **********************************************************************************************************************************/
  38.  
  39. #if defined _Long_Yoyo
  40. #endinput
  41. #endif
  42. #define _Long_Yoyo
  43.  
  44. #define Long_Yoyo_Version (10601) //a.b.c 10000*a+100*b+c
  45.  
  46. #define LY_STRING_LEN (20)
  47. #define SEP_LY_STRING_LEN (LY_STRING_LEN+10)
  48. #define MAX_LY_STRING (LY_STRING_LEN)
  49. #define MAX_SEP_LY_STRING (SEP_LY_STRING_LEN)
  50.  
  51. #define MAX_LY_PREFIX (2147483647)
  52. #define DEFAULT_MAX_LY_PREFIX (2000000000)
  53.  
  54. stock IsValueContainLY(prefix,suffix,value){
  55. if((prefix == 0) && (suffix == 0)) return false;
  56. if((suffix < value) && (prefix == 0)) return false;
  57. return true;
  58. }
  59.  
  60. stock GetLYString(prefix,suffix,string[],maxdest = sizeof(string)){
  61. if(prefix == 0){
  62. format(string,maxdest,"%d",suffix);
  63. } else {
  64. format(string,maxdest,"%d%09d",prefix,suffix);
  65. }
  66. }
  67.  
  68. //Pawn Unsigned Long for 32 Bit language (precision 61-bit)
  69. stock UpdateLY(&prefix,&suffix,value,limitprefix = DEFAULT_MAX_LY_PREFIX){
  70. if(value == 0) return 1; //skip
  71.  
  72. new tmp = value;
  73.  
  74. if((tmp > 0) && (prefix >= limitprefix) && (suffix >= 0)){
  75. prefix = limitprefix;
  76. suffix = 0;
  77. } else if((tmp > 0) && (prefix >= limitprefix-1) && (suffix >= 999999999)){
  78. prefix = limitprefix;
  79. suffix = 0;
  80. } else if((tmp > 0) && (prefix >= limitprefix) && (suffix >= 999999999)){
  81. prefix = limitprefix;
  82. suffix = 0;
  83. } else {
  84. if(value >= 0){
  85. while(tmp >= 1000000000){
  86. tmp -= 1000000000;
  87. prefix += 1;
  88. }
  89. suffix += tmp;
  90. while(suffix > 999999999){
  91. suffix -= 1000000000;
  92. prefix += 1;
  93. }
  94. } else if(value < 0){
  95. while(tmp <= -1000000000){
  96. prefix -= 1;
  97. tmp += 1000000000;
  98. }
  99. suffix += (tmp);
  100. while(suffix < 0){
  101. suffix += 1000000000;
  102. prefix -= 1;
  103. }
  104. if(prefix < 0){
  105. prefix = 0;
  106. suffix = 0;
  107. }
  108. }
  109. }
  110. if((prefix >= limitprefix) && (suffix >= 0)){
  111. prefix = limitprefix;
  112. suffix = 0;
  113. }
  114. return 1;
  115. }
  116.  
  117. stock AddSeparatorLY(string[],const separator[]){
  118. new tStr[MAX_SEP_LY_STRING];
  119. format(tStr,sizeof(tStr),"%s",string);
  120.  
  121. if(strlen(tStr) < 4) return tStr;
  122. new iPos = strlen(tStr), iCount = 1;
  123.  
  124. while(iPos > 0){
  125. if(iCount == 4){
  126. iCount = 0;
  127. strins(tStr,separator[0],iPos,1);
  128. iPos++;
  129. }
  130. iCount++;
  131. iPos--;
  132. }
  133. return tStr;
  134. }
  135.  
  136. stock DeleteSeparatorLY(const string[],const separator[]){
  137. new tStr[MAX_LY_STRING], idx = 0;
  138. for(new i = 0, j = strlen(string); i < j ; i++){
  139. if(string[i] != separator[0]){
  140. tStr[idx] = string[i];
  141. idx++;
  142. }
  143. }
  144. return tStr;
  145. }
  146.  
  147. stock CalculatePercentLY(&prefix,&suffix,Float:percent = 0.0,bool:increase = true,limitprefix = DEFAULT_MAX_LY_PREFIX){
  148. new Float:lycut = (prefix*(percent/100.0)),
  149. modify_p = floatround(lycut),
  150. modify_s = floatround((lycut-modify_p)*100000) * 10000;
  151.  
  152. if(increase){
  153. prefix += modify_p;
  154. UpdateLY(prefix,suffix,modify_s,limitprefix);
  155. modify_s = floatround(suffix*(percent/100.0));
  156. UpdateLY(prefix,suffix,modify_s,limitprefix);
  157. } else {
  158. prefix -= modify_p;
  159. UpdateLY(prefix,suffix,-modify_s,limitprefix);
  160. modify_s = floatround(suffix*(percent/100.0));
  161. UpdateLY(prefix,suffix,-modify_s,limitprefix);
  162. }
  163. }
  164.  
  165. stock GetPercentLY(prefix,suffix,&o_prefix,&o_suffix,Float:percent = 0.0,limitprefix = DEFAULT_MAX_LY_PREFIX){
  166. o_suffix = 0, o_prefix = 0;
  167.  
  168. new Float:lycut = (prefix*(percent/100.0)),
  169. modify_p = floatround(lycut),
  170. modify_s = floatround((lycut-modify_p)*100000) * 10000;
  171.  
  172. o_prefix += modify_p;
  173. UpdateLY(o_prefix,o_suffix,modify_s,limitprefix);
  174. modify_s = floatround(suffix*(percent/100.0));
  175. UpdateLY(o_prefix,o_suffix,modify_s,limitprefix);
  176.  
  177. }
  178.  
  179. //Operator a == b
  180. stock IsLYEqual(prefix,suffix,from_prefix,from_suffix){
  181. if(prefix == from_prefix && suffix == from_suffix) return true;
  182. return false;
  183. }
  184.  
  185. //Operator a < b
  186. stock IsLYSmallerThan(prefix,suffix,from_prefix,from_suffix){
  187. if(prefix < from_prefix) return true;
  188. if(prefix == from_prefix && suffix < from_suffix) return true;
  189. return false;
  190. }
  191.  
  192. //Operator a <= b
  193. stock IsLYSmallerThanOrEqual(prefix,suffix,from_prefix,from_suffix){
  194. if(prefix <= from_prefix) return true;
  195. if(prefix == from_prefix && suffix <= from_suffix) return true;
  196. return false;
  197. }
  198.  
  199. //Operator a > b
  200. stock IsLYBiggerThan(prefix,suffix,from_prefix,from_suffix){
  201. if(prefix > from_prefix) return true;
  202. if(prefix == from_prefix && suffix > from_suffix) return true;
  203. return false;
  204. }
  205.  
  206. //Operator a >= b
  207. stock IsLYBiggerThanOrEqual(prefix,suffix,from_prefix,from_suffix){
  208. if(prefix >= from_prefix) return true;
  209. if(prefix == from_prefix && suffix >= from_suffix) return true;
  210. return false;
  211. }
  212.  
  213. //Reverse to GetLYString
  214. stock LYStringToLY(&prefix,&suffix,const string[]){
  215. new len = strlen(string);
  216. prefix = 0, suffix = 0;
  217. for(new i = strlen(string)-1; i >= 0; i--){
  218. if(len-i <= 9){
  219. suffix += (string[i]-48)*floatround(floatpower(10,len-i-1));
  220. } else {
  221. prefix += (string[i]-48)*floatround(floatpower(10,len-i-10));
  222. }
  223. }
  224. }
  225.  
  226. //EOF
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!