API tools faq
paste
Advertisement
Guest User

Untitled

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