API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Feb 21st, 2018
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 18.65 KB | None | 0 0
raw download clone embed print report
  1. import java.lang.reflect.Field;
  2.  
  3. public class Energy {
  4.  
  5. private static double espeed = 50;
  6. private static double ecap = 3700000;
  7. private static double ebars = 120;
  8. private static double epower = 154;
  9.  
  10. private static double espeedMult1 = 1;
  11. private static double ecapMult1 = 1.1991;
  12. private static double ebarsMult1 = 2.478;
  13. private static double epowerMult1 = 4.186;
  14.  
  15. private static double espeedMult2 = 1;
  16. private static double ecapMult2 = 1.2478;
  17. private static double ebarsMult2 = 1.965;
  18. private static double epowerMult2 = 4.638;
  19.  
  20. private static double espeedMult3 = 1;
  21. private static double ecapMult3 = 1.2744;
  22. private static double ebarsMult3 = 2.000;
  23. private static double epowerMult3 = 4.964;
  24.  
  25. private static double mspeed = 50;
  26. private static double mcap = 650000;
  27. private static double mbars = 28;
  28. private static double mpower = 29;
  29.  
  30. private static double mspeedMult1 = 1;
  31. private static double mcapMult1 = 1.0634;
  32. private static double mbarsMult1 = 1.999;
  33. private static double mpowerMult1 = 3.371;
  34.  
  35. private static double mspeedMult2 = 1;
  36. private static double mcapMult2 = 1.2394;
  37. private static double mbarsMult2 = 1.102;
  38. private static double mpowerMult2 = 4.851;
  39.  
  40. private static double mspeedMult3 = 1;
  41. private static double mcapMult3 = 1.2652;
  42. private static double mbarsMult3 = 1.113;
  43. private static double mpowerMult3 = 5.209;
  44.  
  45. private static double richJerk = 19;
  46.  
  47. private static double NGUEnergyFactor = 0.5;
  48. private static double augmentUpgradeEnergy = 20000;
  49.  
  50. private static double preGold = 14100000;
  51. private static double postGold = 20900000;
  52.  
  53. private static int minBlood = 1;
  54. private static int maxBlood = 2;
  55. private static boolean ascending = false;
  56.  
  57. private static int usedAugment = 1;
  58.  
  59. private static double runTime = 900;
  60.  
  61. public static void stuff(){
  62. int max = 6;
  63. int skill = 1;
  64. int ticksNeeded = skill*100;
  65. double stuff = 0;
  66. for(int x= 1;x<=3600;x++){
  67. ticksNeeded--;
  68. stuff+=skill*50;
  69. if (ticksNeeded==0&&skill<max){
  70. skill++;
  71. ticksNeeded =skill*100;
  72. }
  73. if ((x%60)==0){
  74. System.out.println(x/60 + " min: "+stuff/10000);
  75. }
  76. }
  77. }
  78.  
  79. public static void main(String[] args) {
  80. try {
  81. if (1 == 1) {
  82. }
  83. // bestPath();
  84. // for (int x = 0; x<=1800;x+=30){
  85. Result r = getBest(false, espeed * espeedMult1, ecap * ecapMult1,
  86. ebars * ebarsMult1, epower * epowerMult1,
  87. mspeed * mspeedMult1, mcap * mcapMult1, mbars * mbarsMult1,
  88. mpower * mpowerMult1);
  89. // System.out.print(x+" :");
  90. System.out.println("a");
  91. System.out.println(r.timeMachineTime);
  92. System.out.println(r.maxTimeMachineMagic);
  93. System.out.println(r.switch1Time);
  94. System.out.println(r.switch2Time);
  95. System.out.println(r.efficiency);
  96. System.out.println("a");
  97. getEfficiencies();
  98. // }
  99.  
  100. } catch (NoSuchFieldException | SecurityException
  101. | IllegalArgumentException | IllegalAccessException e) {
  102. e.printStackTrace();
  103. }
  104.  
  105. }
  106.  
  107. class Result {
  108. double timeMachineTime;
  109. double efficiency;
  110. double maxTimeMachineMagic;
  111. double switch1Time;
  112. double switch2Time;
  113.  
  114. private Result(double pTimeMachineTime, double pEfficiency,
  115. double pMaxTimeMachineMagic, double pSwitch1Time,
  116. double pSwitch2Time) {
  117. timeMachineTime = pTimeMachineTime;
  118. efficiency = pEfficiency;
  119. maxTimeMachineMagic = pMaxTimeMachineMagic;
  120. switch1Time = pSwitch1Time;
  121. switch2Time = pSwitch2Time;
  122. }
  123. }
  124.  
  125. enum Blood {
  126. Blood1(3 * Math.pow(10, 7), 2 * Math.pow(10, 6), 1), Blood2(
  127. 1 * Math.pow(10, 10), 2 * Math.pow(10, 7),
  128. 50), Blood3(2 * Math.pow(10, 12), 2 * Math.pow(10, 8),
  129. 2000), Blood4(4 * Math.pow(10, 14), 2 * Math.pow(10, 9),
  130. 60000), Blood5(8 * Math.pow(10, 16),
  131. 2 * Math.pow(10, 10),
  132. 1200000), Blood6(1.6 * Math.pow(10, 19),
  133. 2 * Math.pow(10, 11),
  134. 18000000), Blood7(
  135. 3.2 * Math.pow(10, 21),
  136. 2 * Math.pow(10, 12),
  137. 250000000);
  138.  
  139. double cost;
  140. double time;
  141. double gain;
  142.  
  143. Blood(double cost, double time, double gain) {
  144. this.cost = cost;
  145. this.time = time;
  146. this.gain = gain;
  147. }
  148.  
  149. }
  150.  
  151. enum Augment {
  152. Augment1(1 * Math.pow(10, 4), 4 * Math.pow(10, 5),1 * Math.pow(10, 0)),
  153. Augment2(2 * Math.pow(10, 5), 7.2 * Math.pow(10, 6),2 * Math.pow(10, 1)),
  154. Augment3(4 * Math.pow(10, 6), 1.28 * Math.pow(10, 8),4 * Math.pow(10, 2)),
  155. Augment4(8 * Math.pow(10, 7), 2.2 * Math.pow(10, 9),8 * Math.pow(10, 3)),
  156. Augment5(1.6 * Math.pow(10, 9), 4.2 * Math.pow(10, 10),1.6 * Math.pow(10, 5));
  157.  
  158.  
  159. double cost;
  160. double time;
  161. double gain;
  162.  
  163. Augment(double cost, double time, double gain) {
  164. this.cost = cost;
  165. this.time = time;
  166. this.gain = gain;
  167. }
  168.  
  169. }
  170.  
  171. enum AugmentUpgrade {
  172. AugmentUpgrade1(2 * Math.pow(10, 8), 1),
  173. AugmentUpgrade2(2.6 * Math.pow(10, 9), 1),
  174. AugmentUpgrade3(4 * Math.pow(10, 10), 1),
  175. AugmentUpgrade4(2.4 * Math.pow(10, 11), 1),
  176. AugmentUpgrade5(5 * Math.pow(10, 12), 1);
  177.  
  178.  
  179. double cost;
  180. double time;
  181.  
  182. AugmentUpgrade(double cost, double time) {
  183. this.cost = cost;
  184. this.time = time;
  185. }
  186.  
  187. }
  188.  
  189. private static void getEfficiencies()
  190. throws NoSuchFieldException, SecurityException,
  191. IllegalArgumentException, IllegalAccessException {
  192. double currentEfficiency = getBest(true, espeed * espeedMult1,
  193. ecap * ecapMult1, ebars * ebarsMult1, epower * epowerMult1,
  194. mspeed * mspeedMult1, mcap * mcapMult1, mbars * mbarsMult1,
  195. mpower * mpowerMult1).efficiency;
  196.  
  197. String[] fieldNames = {
  198. /*
  199. * "espeed", "espeed", "espeed", "espeed", "espeed", "espeed",
  200. */ "ecap", "ecap", "ebars", "ebars", "epower", "epower",
  201. "epower",
  202. /*
  203. * "mspeed", "mspeed", "mspeed", "mspeed", "mspeed", "mspeed",
  204. */ "mcap", "mcap", "mbars", "mbars", "mpower", "mpower",
  205. "mpower", "richJerk", "richJerk" };
  206. double[] addedValues = { /* 0.1, 0.5, 1, 5, 12.5, 25, */ 100000, 1000000,
  207. 1, 10, 1, 10, 50, /* 0.1, 0.5, 1, 5, 12.5, 25, */ 100000,
  208. 1000000, 1, 10, 1, 10, 50, 0.1, 1 };
  209. double[] addedCost = { /* 2, 10, 20, 100, 250, 500, */ 400, 4000, 80, 800,
  210. 150, 1500, 7500, /* 3, 15, 30, 150, 375, 750, */ 1200, 12000, 240,
  211. 2400, 450, 4500, 22500, 60, 600 };
  212.  
  213. Energy energy = new Energy();
  214. for (int x = 0; x < fieldNames.length; x++) {
  215. System.out.print(fieldNames[x] + "(" + addedValues[x] + ")" + ": ");
  216. Double addValue = addedValues[x];
  217. Double cost = addedCost[x];
  218. Field field = energy.getClass().getDeclaredField(fieldNames[x]);
  219. Double value = field.getDouble(energy);
  220. field.setDouble(energy, value + addValue);
  221. System.out.println(1 + ((getBest(true, espeed * espeedMult1,
  222. ecap * ecapMult1, ebars * ebarsMult1, epower * epowerMult1,
  223. mspeed * mspeedMult1, mcap * mcapMult1, mbars * mbarsMult1,
  224. mpower * mpowerMult1).efficiency / currentEfficiency) - 1)
  225. / cost * 1000);
  226. field.setDouble(energy, value);
  227. }
  228.  
  229. }
  230.  
  231. private static Result getBest(boolean silent, double pESpeed, double pECap,
  232. double pEBars, double pEPower, double pMSpeed, double pMCap,
  233. double pMBars, double pMPower)
  234. throws NoSuchFieldException, SecurityException,
  235. IllegalArgumentException, IllegalAccessException {
  236. double bestEff = 0;
  237. double bestTimeMachineTime = 0;
  238. double bestTimeMachineMagicCap = 0;
  239. for (double x = 0.5 * runTime; x <= 0.9 * runTime; x += 0.01
  240. * runTime) {
  241. for (double y = 0.3 * runTime; y <= 0.7 * runTime; y += 0.01
  242. * runTime) {
  243. double newEff = efficiency(x, y, pESpeed, pECap, pEBars,
  244. pEPower, pMSpeed, pMCap, pMBars, pMPower,
  245. true).efficiency;
  246. if (newEff > bestEff) {
  247. bestEff = newEff;
  248. bestTimeMachineTime = x;
  249. bestTimeMachineMagicCap = y;
  250. }
  251. }
  252. }
  253. Result res = efficiency(bestTimeMachineTime, bestTimeMachineMagicCap,
  254. pESpeed, pECap, pEBars, pEPower, pMSpeed, pMCap, pMBars,
  255. pMPower, silent);
  256. Energy energy = new Energy();
  257. return energy.new Result(bestTimeMachineTime, bestEff,
  258. bestTimeMachineMagicCap, res.switch1Time,
  259. res.switch2Time);
  260. }
  261.  
  262. private static Result efficiency(double timeMachineEnergyTime,
  263. double timeMachineMagicTime, double pESpeed, double pECap,
  264. double pEBars, double pEPower, double pMSpeed, double pMCap,
  265. double pMBars, double pMPower, boolean silent) {
  266. double baseAugmentUpgradeCost = AugmentUpgrade.values()[usedAugment-1].cost;
  267. double baseAugmentTime = Augment.values()[usedAugment-1].time / pEPower;
  268. double baseTimeMachineEnergyTime = 1000000000 / pEPower;
  269. double baseTimeMachineMagicTime = 1000000000 / pMPower;
  270. double gold = 0;
  271. double time = 0;
  272. double energy = 0;
  273. double magic = 0;
  274. double timeMachineEnergyLevel = 0;
  275. double timeMachineMagicLevel = 0;
  276. double blood = 0;
  277. double augmentLevel = 0;
  278. double augmentUpgradeLevel = 0;
  279.  
  280. double timeMachineEnergyProgress = 0;
  281. double timeMachineMagicProgress = 0;
  282. double augmentProgress = 0;
  283. boolean[] hasPaidForCurrentBlood = {false,false,false,false,false,false,false};
  284.  
  285. double switch1Time = 0;
  286. double switch2Time = 0;
  287. boolean swapped1 = false;
  288. boolean swapped2 = false;
  289.  
  290. int[] bloodCounter = { 0, 0, 0, 0, 0, 0, 0 };
  291. double[] bloodGains = { 0, 0, 0, 0, 0, 0, 0 };
  292. double baseGold = preGold;
  293. while (time < runTime) {
  294. time++;
  295. energy += (pEBars * 50d / Math.max(1, Math.ceil(50d / pESpeed)));
  296. if (time < timeMachineEnergyTime){
  297. energy = Math.min(energy, pECap);
  298. }
  299. else{
  300. energy = Math.min(energy, pECap*NGUEnergyFactor-augmentUpgradeEnergy);
  301. }
  302. magic += (pMBars * 50d / Math.max(1, Math.ceil(50d / pMSpeed)));
  303. magic = Math.min(magic, pMCap);
  304. gold += baseGold * Math.min(50, (1 + timeMachineEnergyLevel))
  305. * Math.max(1, (timeMachineEnergyLevel - 49))
  306. * (1 + timeMachineMagicLevel);
  307. if (!swapped1 && (energy == pECap||magic == pMCap)) {
  308. pESpeed *= espeedMult2 / espeedMult1;
  309. pECap *= ecapMult2 / ecapMult1;
  310. pEBars *= ebarsMult2 / ebarsMult1;
  311. pEPower *= epowerMult2 / epowerMult1;
  312. pMSpeed *= mspeedMult2 / mspeedMult1;
  313. pMCap *= mcapMult2 / mcapMult1;
  314. pMBars *= mbarsMult2 / mbarsMult1;
  315. pMPower *= mpowerMult2 / mpowerMult1;
  316. swapped1 = true;
  317. switch1Time = time;
  318.  
  319. baseAugmentTime *= epowerMult1 / epowerMult2;
  320. baseTimeMachineEnergyTime *= epowerMult1 / epowerMult2;
  321. baseTimeMachineMagicTime *= mpowerMult1 / mpowerMult2;
  322. }
  323.  
  324. if (time < timeMachineEnergyTime) {
  325. for (int x = 0; x < 50; x++) {
  326. timeMachineEnergyProgress += energy / 50;
  327. if (timeMachineEnergyProgress > (1 + timeMachineEnergyLevel)
  328. * baseTimeMachineEnergyTime) {
  329. timeMachineEnergyProgress = 0;
  330. timeMachineEnergyLevel++;
  331. }
  332. }
  333.  
  334. } else {
  335.  
  336. if (!swapped2) {
  337. pESpeed *= espeedMult3 / espeedMult2;
  338. pECap *= ecapMult3 / ecapMult2;
  339. pEBars *= ebarsMult3 / ebarsMult2;
  340. pEPower *= epowerMult3 / epowerMult2;
  341. pMSpeed *= mspeedMult3 / mspeedMult2;
  342. pMCap *= mcapMult3 / mcapMult2;
  343. pMBars *= mbarsMult3 / mbarsMult2;
  344. pMPower *= mpowerMult3 / mpowerMult2;
  345. swapped2 = true;
  346. switch2Time = time;
  347.  
  348. baseAugmentTime *= epowerMult2 / epowerMult3;
  349. baseTimeMachineEnergyTime *= epowerMult2 / epowerMult3;
  350. baseTimeMachineMagicTime *= mpowerMult2 / mpowerMult3;
  351. }
  352.  
  353. baseGold = postGold;
  354. for (int x = 0; x < 50; x++) {
  355. augmentProgress += energy / 50;
  356. if (augmentProgress > baseAugmentTime
  357. * (augmentLevel + 1)) {
  358. augmentLevel++;
  359. augmentProgress = 0;
  360. }
  361. }
  362. for (int x = 0; x < 50; x++) {
  363. if (gold > baseAugmentUpgradeCost
  364. * Math.pow(augmentUpgradeLevel + 1, 2)) {
  365. gold -= baseAugmentUpgradeCost
  366. * Math.pow(augmentUpgradeLevel + 1, 2);
  367. augmentUpgradeLevel++;
  368. } else {
  369. break;
  370. }
  371. }
  372. }
  373. if (time < timeMachineMagicTime) {
  374. for (int x = 0; x < 50; x++) {
  375. timeMachineMagicProgress += magic / 50;
  376. if (timeMachineMagicProgress > (1 + timeMachineMagicLevel)
  377. * baseTimeMachineMagicTime) {
  378. timeMachineMagicProgress = 0;
  379. timeMachineMagicLevel++;
  380. }
  381. }
  382.  
  383. } else {
  384. double remainingMagic = magic;
  385. for (int x = (ascending ? minBlood : maxBlood); ascending
  386. ? x <= maxBlood
  387. : x >= minBlood; x += (ascending ? 1 : -1)) {
  388. if (remainingMagic<=100){
  389. break;
  390. }
  391. double bloodCost = Blood.values()[x - 1].cost;
  392. double bloodTime = Blood.values()[x - 1].time
  393. / pMPower;
  394. double acc = 0;
  395. double usedMagic = 0;
  396. double ticks = 0;
  397. while (true) {
  398. ticks++;
  399. acc += remainingMagic / 50;
  400. if (acc >= bloodTime) {
  401. usedMagic = remainingMagic / (acc / bloodTime);
  402. remainingMagic -= usedMagic;
  403. break;
  404. }
  405. }
  406. if (!silent && time == -1 && x == 2) {
  407. System.out.println(ticks);
  408. System.out.println(usedMagic);
  409. }
  410. for (int y = 0; y < 50; y++) {
  411. if (!hasPaidForCurrentBlood[x-1]) {
  412. if (gold >= bloodCost) {
  413. gold -= bloodCost;
  414. hasPaidForCurrentBlood[x-1] = true;
  415. } else {
  416. break;
  417. }
  418. }
  419. if (hasPaidForCurrentBlood[x-1]) {
  420. bloodCounter[x - 1]++;
  421. if (bloodCounter[x - 1] >= ticks) {
  422. hasPaidForCurrentBlood[x-1] = false;
  423. blood += Blood.values()[x - 1].gain;
  424. bloodGains[x
  425. - 1] += Blood.values()[x - 1].gain;
  426. bloodCounter[x - 1] = 0;
  427. }
  428. }
  429. }
  430. }
  431. }
  432. }
  433.  
  434. if (!silent) {
  435. System.out.println("TME: " + timeMachineEnergyLevel);
  436. System.out.println("TMM: " + timeMachineMagicLevel);
  437. System.out.println("Blood: " + blood);
  438. System.out.println("Augment: " + augmentLevel);
  439. System.out.println("Upgrade: " + augmentUpgradeLevel);
  440.  
  441. //for (int x = 0; x < 7; x++) {
  442. // System.out.println(bloodGains[x]);
  443. //}
  444. }
  445.  
  446. double eff = (augmentLevel + 1) * (1 + blood)
  447. * (1 + Math.pow(augmentUpgradeLevel, 2)) * Augment.values()[usedAugment-1].gain * richJerk;
  448. Energy energy1 = new Energy();
  449. return energy1.new Result(0, eff, 0, switch1Time, switch2Time);
  450. }
  451.  
  452. private static double getEffect(double pSpeed, double pCap, double pBars,
  453. double pPower) {
  454. double timeToCap = pCap
  455. / (pBars * 50d / Math.max(1, Math.ceil(50d / pSpeed)));
  456. double timePre = Math.min(timeToCap, runTime);
  457. double timeAfter = runTime - timePre;
  458. return timeAfter > 0 ? pCap * (timePre / 2d + timeAfter) * pPower
  459. : pCap * (runTime / timeToCap) * timePre / 2d * pPower;
  460. }
  461. }
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!