API tools faq
paste
1234abcdcba4321

derivative clicker js copy for easy access

1234abcdcba4321
Jun 14th, 2014
417
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.30 KB | None | 0 0
raw download clone embed print report
  1. /* Todo: add more statistics, add prestige/soft resets, ???add upgrade paths????, add more derivatives
  2. Rollover hilarious jokes/stats
  3. Reset currency buyables: change click improver to reset curr buyable, ticks between builds decrease, upgrades influenced by certain buildings
  4. */
  5.  
  6. var player = {
  7. //currencies
  8. money: 0,
  9. moneyPerSecond: 0,
  10. netMoneyPerSecond: 0,
  11. moneyPerClick: 1,
  12. moneyPerAutoclick: 0,
  13. proofs: 0,
  14. proofsPerSecond: 0,
  15. costPerProof: 5,
  16. deriv1Money: 0.05,
  17.  
  18. /* main buildings: indexes
  19. 0: deriv1, 1: combinatorics, 2: computer, 3: high schooler, 4: mathematician
  20. 5: deriv2, 6: number theory, 7: assembly line, 8: undergraduate, 9: andrew wiles
  21. 10: deriv3, 11: calculus, 12: factory, 13: graduate student, 14: kurt godel
  22. 15: deriv4, 16: algebra, 17: factory architect, 18: postdoc, 19: georg riemann
  23. */
  24. buildings: [new Building(1.1, 0.1, 0), new Building(1.1, 25000, 0), new Building(1.3, 0, 2), new Building(1.1, 5, 0), new Building(1.05, 1000, 0),
  25. new Building(1.2, 500, 0), new Building(1.3, 20000000, 0), new Building(1.8, 0, 20000), new Building(1.2, 1000, 0), new Building(1.2, 100000000, 0),
  26. new Building(1.5, 20000, 0), new Building(1.8, 1000000000, 0), new Building(2.5, 0, 1000000), new Building(1.4, 100000, 0), new Building(1.5, 10000000000000, 0),
  27. new Building(2, 1000000, 1000), new Building(2.5, 500000000000, 0), new Building(4, 0, 30000000), new Building(2, 10000000, 0), new Building(2, 1000000000000000000, 0),
  28. new Building(2.5, 200000000, 500000), new Building(3, 20000000000000, 0), new Building(5, 0, 1000000000), new Building(2.7, 10000000000, 0), new Building(3, 100000000000000000000000, 0)],
  29.  
  30. /* upgrades: indexes
  31. 0: tier 1 upgrade, 1: tier 2 upgrade, 2: tier 3 upgrade, 3: tier 4 upgrade, 4: tier 5 upgrade
  32. upgrades: 0: autoclicker, 1: click improver
  33. */
  34. tierUpgrades: [0, 0, 0, 0, 0],
  35. upgrades: [0, 0],
  36. upgradeCosts: [1000000, 1000000000, 1000000000000, 1000000000000000, 1000000000000000000, 100000, 10],
  37.  
  38. //upgrade multipliers
  39. mult: [1, 1, 1, 1, 1],
  40.  
  41. //other tracking variables
  42. clickTracker: 0,
  43. updateInterval: 1000,
  44. numToBuy: 1,
  45. clicksToGain: 25,
  46.  
  47. //these variables aren't changed by resets
  48. //statistics
  49. totalMoneyEarned: 0,
  50. totalProofs: 0,
  51. totalClicks: 0,
  52. totalManualClicks: 0,
  53. proofsToNextCurr: 100000000000000,
  54. proofsToCurrTracker: 0,
  55. mathematiciansToNextCurr: 7000000000,
  56. mathematiciansToNextCurrTracker: 0,
  57. resetCurrTracker: 0, //this variable does have to be reset
  58.  
  59. numResets: [0, 0, 0, 0, 0],
  60. resetCurr: [0, 0, 0, 0, 0],
  61. versionNum: versionNum
  62. };
  63.  
  64. var versionNum = 0.182;
  65.  
  66. //these variables hold constants between plays
  67. var upgradeCostFactor = [1000, 1000, 1000, 1000, 1000, 1.8, 1];
  68.  
  69. var globalMult = [1, 1, 1, 1, 1];
  70.  
  71. var numTiers = 5;
  72.  
  73. var isActive = true;
  74.  
  75. window.onfocus = function(){isActive = true;};
  76. window.onblur = function(){isActive=false;};
  77.  
  78. //functions that add to variables
  79. function addMoney(money) {
  80. player.money = Math.round((player.money + money)*100)/100;
  81. if(money > 0){
  82. player.totalMoneyEarned = Math.round((player.totalMoneyEarned + money)*100)/100;
  83. }
  84. }
  85.  
  86. function addMoneyPerSecond(mps){
  87. player.moneyPerSecond = Math.round((player.moneyPerSecond + mps)*100)/100;
  88. }
  89.  
  90. function addNetMoneyPerSecond(nmps){
  91. player.netMoneyPerSecond = Math.round((player.netMoneyPerSecond + nmps)*100)/100;
  92. }
  93.  
  94. function addMoneyPerClick(mpc){
  95. player.moneyPerClick = Math.round((player.moneyPerClick + mpc)*100)/100;
  96. }
  97.  
  98. function addProofs(proofs){
  99. player.proofs += Math.floor(proofs);
  100. player.proofsToNextCurr -= Math.floor(proofs);
  101. player.totalProofs += Math.floor(proofs);
  102. addMoney(-Math.floor(proofs) * player.costPerProof);
  103. }
  104.  
  105. function addClickUpgrades(highSch, undergrad, graduate, postdoc){
  106. player.buildings[3].owned += highSch;
  107. player.buildings[8].owned += undergrad;
  108. player.buildings[13].owned += graduate;
  109. player.buildings[18].owned += postdoc;
  110. }
  111.  
  112. //function to display values
  113. function displayNum(num, ifMoney){
  114. var suffixes = ["K", "M", "B", "T", "Qa", "Qt", "Sx", "Sp", "Oc", "Nn", "Dc", "UDc", "DDc", "TDc", "QaDc", "QtDc", "SxDc", "SpDc", "ODc", "NDc", "Vi"]
  115.  
  116. for(var i = suffixes.length - 1; i >= 0; i--){
  117. if(Math.abs(num) >= Math.pow(10, 3*i + 3) * 0.99999){
  118. return i < 4 ? parseFloat(num/Math.pow(10, 3*i + 3)).toFixed(2) + suffixes[i] : parseFloat(num/Math.pow(10, 3*i + 3)).toFixed(2) + " " + suffixes[i];
  119. }
  120. }
  121.  
  122. return ifMoney ? parseFloat(num).toFixed(2) : num;
  123. }
  124.  
  125. //function that recalculates the multipliers associated with upgrades
  126. function calcMult(mult){
  127. switch(mult){
  128. case 1:
  129. player.mult[0] = Math.round(10000 + (player.tierUpgrades[0] * 0.0005 * (player.buildings[0].manual + player.buildings[1].manual + player.buildings[2].manual + player.buildings[3].manual + player.buildings[4].manual))*10000)/10000;
  130. break;
  131. case 2:
  132. player.mult[1] = Math.round(10000 + (player.tierUpgrades[1] * 0.002 * (player.buildings[5].manual + player.buildings[6].manual + player.buildings[7].manual + player.buildings[8].manual + player.buildings[9].manual))*10000)/10000;
  133. break;
  134. case 3:
  135. player.mult[2] = Math.round(10000 + (player.tierUpgrades[2] * 0.01 * (player.buildings[10].manual + player.buildings[11].manual + player.buildings[12].manual + player.buildings[13].manual + player.buildings[14].manual))*10000)/10000;
  136. break;
  137. case 4:
  138. player.mult[3] = Math.round(10000 + (player.tierUpgrades[3] * 0.02 * (player.buildings[15].manual + player.buildings[16].manual + player.buildings[17].manual + player.buildings[18].manual + player.buildings[19].manual))*10000)/10000;
  139. break;
  140. case 5:
  141. player.mult[4] = Math.round(10000 + (player.tierUpgrades[4] * 0.05 * (player.buildings[20].manual + player.buildings[21].manual + player.buildings[22].manual + player.buildings[23].manual + player.buildings[24].manual))*10000)/10000;
  142. default:
  143. break;
  144. }
  145. }
  146.  
  147. function calcGlobalMult(){
  148. for(var i = 0; i < globalMult.length; i++){
  149. globalMult[i] = parseFloat((player.resetCurr[i] * 0.01) + 1).toFixed(2);
  150. }
  151. }
  152.  
  153. //function that calculates price of buying multiple buildings at once
  154. function calcTotalPrice(price, factor, number){
  155. return price*((Math.pow(factor, number) - 1)/(factor - 1));
  156. }
  157.  
  158. //function that allows number to buy to be adjusted
  159. function getNumToBuy(ifMax){
  160. if(ifMax === -1){
  161. player.numToBuy = "Max";
  162. }
  163. else{
  164. var num = parseInt($("#numToBuy").val());
  165. if(!isNaN(num) && num > 0){
  166. player.numToBuy = num;
  167. }
  168. }
  169. $("#currentNumToBuy").html(player.numToBuy);
  170. updateInventory();
  171. }
  172.  
  173. function factorial(n){
  174. if(n <= 1) return 1;
  175. return n*factorial(n-1);
  176. }
  177.  
  178. //functions that handle saving
  179. function init(){
  180. player = {
  181. money: 0,
  182. moneyPerSecond: 0,
  183. netMoneyPerSecond: 0,
  184. moneyPerClick: 1,
  185. moneyPerAutoclick: 0,
  186. proofs: 0,
  187. proofsPerSecond: 0,
  188. costPerProof: 5,
  189. deriv1Money: 0.05,
  190. buildings: [new Building(1.1, 0.1, 0), new Building(1.1, 25000, 0), new Building(1.3, 0, 2), new Building(1.1, 5, 0), new Building(1.05, 1000, 0),
  191. new Building(1.2, 500, 0), new Building(1.3, 20000000, 0), new Building(1.8, 0, 20000), new Building(1.2, 1000, 0), new Building(1.2, 100000000, 0),
  192. new Building(1.5, 20000, 0), new Building(1.8, 1000000000, 0), new Building(2.5, 0, 1000000), new Building(1.4, 100000, 0), new Building(1.5, 10000000000000, 0),
  193. new Building(2, 1000000, 1000), new Building(2.5, 500000000000, 0), new Building(4, 0, 30000000), new Building(2, 10000000, 0), new Building(2, 1000000000000000000, 0),
  194. new Building(2.5, 200000000, 500000), new Building(3, 20000000000000, 0), new Building(5, 0, 1000000000), new Building(2.7, 10000000000, 0), new Building(3, 100000000000000000000000, 0)],
  195. tierUpgrades: [0, 0, 0, 0, 0],
  196. upgrades: [0, 0],
  197. upgradeCosts: [1000000, 1000000000, 1000000000000, 1000000000000000, 1000000000000000000, 100000, 10],
  198. mult: [1, 1, 1, 1, 1],
  199. clickTracker: 0,
  200. updateInterval: 1000,
  201. numToBuy: 1,
  202. clicksToGain: 25,
  203. totalMoneyEarned: 0,
  204. totalProofs: 0,
  205. totalClicks: 0,
  206. totalManualClicks: 0,
  207. proofsToNextCurr: 100000000000000,
  208. proofsToCurrTracker: 0,
  209. mathematiciansToNextCurr: 7000000000,
  210. mathematiciansToNextCurrTracker: 0,
  211. resetCurrTracker: 0,
  212. numResets: [0, 0, 0, 0, 0],
  213. resetCurr: [0, 0, 0, 0, 0],
  214. versionNum: versionNum
  215. };
  216. };
  217.  
  218. function save() {
  219. localStorage.setItem("playerStored", JSON.stringify(player));
  220. localStorage.setItem("enableChart", JSON.stringify(enableChart));
  221.  
  222. var d = new Date();
  223. $("#lastSave").html(d.toLocaleTimeString());
  224. }
  225.  
  226. function load() {
  227. $.extend(true, player, JSON.parse(localStorage.getItem("playerStored")));
  228. enableChart = JSON.parse(localStorage.getItem("enableChart"));
  229. }
  230.  
  231. function wipe() {
  232. var confirmation = confirm("Are you sure you want to permanently erase your savefile?");
  233. if(confirmation === true){
  234. init();
  235. localStorage.setItem("playerStored", JSON.stringify(player));
  236. calcGlobalMult();
  237.  
  238. updateMoney();
  239. updateInventory();
  240. updateUpgrades();
  241. updateStats();
  242. $("#currentNumToBuy").html(player.numToBuy);
  243. }
  244. }
  245.  
  246. function exportSave() {
  247. var exportText = btoa(JSON.stringify(player));
  248.  
  249. $("#exportSaveContents").toggle();
  250. $("#exportSaveText").val(exportText);
  251. $("#exportSaveText").select();
  252. }
  253.  
  254. function importSave(){
  255. var importText = prompt("Paste the text you were given by the export save dialog here.\n" +
  256. "Warning: this will erase your current save!");
  257. player = JSON.parse(atob(importText));
  258. if(player.upgrades[1] == 24) player.upgradeCosts[numTiers + 1] = Infinity;
  259. save();
  260. calcGlobalMult();
  261. $("#currentNumToBuy").html(player.numToBuy);
  262.  
  263. updateInventory();
  264. updateUpgrades();
  265. updateStats();
  266. updateMoney();
  267. updatePrestige();
  268. }
  269.  
  270. function ifMoreDerivs(){
  271. if(player.numResets[0] == 0) return "Access to another derivative.\n"
  272. return "";
  273. }
  274.  
  275. function reset(tier) {
  276. var index = tier - 1;
  277.  
  278. if(player.buildings[4 + 5 * index].owned < 7000000000){
  279. alert("You must have 7 billion mathematicians of tier " + tier + " to do this!")
  280. }
  281. else{
  282. var confirmationText = "Are you sure you want to reset? You will gain: \n";
  283.  
  284. confirmationText += (displayNum(player.resetCurrTracker, false) + " tier 1 reset currency.\n");
  285. if(tier > 1){
  286. for(var i = 1; i < tier; i++){
  287. confirmationText += (displayNum(Math.floor(player.resetCurr[i- 1] / 5, false)) + " tier " + (i + 1) + " reset currency.\n");
  288. confirmationText += ("At the cost of " + displayNum(Math.floor(player.resetCurr[i - 1] / 5) * 5, false) + " tier " + i + " reset currency.\n");
  289. }
  290. }
  291. confirmationText += ifMoreDerivs();
  292.  
  293. confirmationText += "\n\nYes, I know this looks pretty awful. If you have any ideas on how to restructure the text here I\'m all ears."
  294.  
  295. var confirmation = confirm(confirmationText);
  296.  
  297. if(confirmation === true){
  298. player.numResets[index]++;
  299. if(tier > 1){
  300. for(var i = index; i > 0; i--){
  301. player.resetCurr[i] += Math.floor(player.resetCurr[i - 1] / 5);
  302. player.resetCurr[i - 1] %= 5;
  303. }
  304. }
  305. player.resetCurr[0] += player.resetCurrTracker;
  306. calcGlobalMult();
  307.  
  308. //resets variables that are erased by reset
  309. $.extend(true, player, {
  310. money: 0,
  311. moneyPerSecond: 0,
  312. netMoneyPerSecond: 0,
  313. moneyPerClick: 1,
  314. moneyPerAutoclick: 0,
  315. proofs: 0,
  316. proofsPerSecond: 0,
  317. costPerProof: 5,
  318. deriv1Money: 0.05,
  319. buildings: [new Building(1.1, 0.1, 0), new Building(1.1, 25000, 0), new Building(1.3, 0, 2), new Building(1.1, 5, 0), new Building(1.05, 1000, 0),
  320. new Building(1.2, 500, 0), new Building(1.3, 20000000, 0), new Building(1.8, 0, 20000), new Building(1.2, 1000, 0), new Building(1.2, 100000000, 0),
  321. new Building(1.5, 20000, 0), new Building(1.8, 1000000000, 0), new Building(2.5, 0, 1000000), new Building(1.4, 100000, 0), new Building(1.5, 10000000000000, 0),
  322. new Building(2, 1000000, 1000), new Building(2.5, 500000000000, 0), new Building(4, 0, 30000000), new Building(2, 10000000, 0), new Building(2, 1000000000000000000, 0),
  323. new Building(2.5, 200000000, 500000), new Building(3, 20000000000000, 0), new Building(5, 0, 1000000000), new Building(2.7, 10000000000, 0), new Building(3, 100000000000000000000000, 0)],
  324. tierUpgrades: [0, 0, 0, 0, 0],
  325. upgrades: [0, 0],
  326. upgradeCosts: [1000000, 1000000000, 1000000000000, 1000000000000000, 1000000000000000000, 100000, 10],
  327. mult: [1, 1, 1, 1, 1],
  328. clickTracker: 0,
  329. updateInterval: 1000,
  330. clicksToGain: 25,
  331. resetCurrTracker: 0
  332. });
  333.  
  334. updateMoney();
  335. updateInventory();
  336. updateUpgrades();
  337. updateStats();
  338. updatePrestige();
  339.  
  340. ga('send', 'event', 'reset', 'click', 'reset'); //analytics
  341. }
  342. }
  343. }
  344.  
  345. //templates
  346. var moneyTableTemplate = _.template($("#moneyTableTemplate").html());
  347. var inventoryTemplate = _.template($("#inventoryTemplate").html());
  348. var row5Template = _.template($("#row5Template").html())
  349. var upgradesTemplate = _.template($("#upgradesTemplate").html());
  350. var statsTemplate = _.template($("#statsTemplate").html());
  351. var prestigeTemplate = _.template($("#prestigeTemplate").html());
  352.  
  353. //functions that update stuff onscreen
  354. function updateMoney() {
  355. var newMoneyTable = moneyTableTemplate({money: displayNum(player.money, true), moneyPerSecond: displayNum(player.moneyPerSecond, true), netMoneyPerSecond: displayNum(player.netMoneyPerSecond, true),
  356. proofs: displayNum(player.proofs, false), proofsPerSecond: displayNum(player.proofsPerSecond, false), moneyPerClick: displayNum(player.moneyPerClick, true),
  357. tickLength: parseFloat(player.updateInterval).toFixed(0), moneyPerAutoclick: displayNum(player.moneyPerAutoclick, true)});
  358.  
  359. $("#info").html(newMoneyTable);
  360. }
  361.  
  362. function updateInventory() {
  363. var firstRows = inventoryTemplate({deriv1Owned: displayNum(player.buildings[0].owned, false), deriv1Cost: displayNum(player.buildings[0].moneyCost, true), deriv1Manual: displayNum(player.buildings[0].manual, false), deriv1Power: displayNum(0.05 * player.mult[0] * globalMult[0], true),
  364. deriv2Owned: displayNum(player.buildings[5].owned, false), deriv2Cost: displayNum(player.buildings[5].moneyCost, true), deriv2Manual: displayNum(player.buildings[5].manual, false), deriv2Power: displayNum(Math.round(player.mult[1] * globalMult[1]), false),
  365. deriv3Owned: displayNum(player.buildings[10].owned, false), deriv3Cost: displayNum(player.buildings[10].moneyCost, true), deriv3Manual: displayNum(player.buildings[10].manual, false), deriv3Power: displayNum(Math.round(player.mult[2] * globalMult[2]), false),
  366. deriv4Owned: displayNum(player.buildings[15].owned, false), deriv4MoneyCost: displayNum(player.buildings[15].moneyCost, true), deriv4WidgetCost: displayNum(player.buildings[15].proofCost, false), deriv4Manual: displayNum(player.buildings[15].manual, false), deriv4Power: displayNum(Math.round(player.mult[3] * globalMult[3]), false),
  367. combinatoricsOwned: displayNum(player.buildings[1].owned, false), combinatoricsCost: displayNum(player.buildings[1].moneyCost, true), combinatoricsManual: displayNum(player.buildings[1].manual, false), combinatoricsPower: displayNum(Math.round(player.mult[0] * globalMult[0]), false),
  368. numberTheoryOwned: displayNum(player.buildings[6].owned, false), numberTheoryCost: displayNum(player.buildings[6].moneyCost, true), numberTheoryManual: displayNum(player.buildings[6].manual, false), numberTheoryPower: displayNum(Math.round(player.mult[1] * globalMult[1]), false),
  369. calculusOwned: displayNum(player.buildings[11].owned, false), calculusCost: displayNum(player.buildings[11].moneyCost, true), calculusManual: displayNum(player.buildings[11].manual, false), calculusPower: displayNum(Math.round(player.mult[2] * globalMult[2]), false),
  370. algebraOwned: displayNum(player.buildings[16].owned, false), algebraCost: displayNum(player.buildings[16].moneyCost, true), algebraManual: displayNum(player.buildings[16].manual, false), algebraPower: displayNum(Math.round(player.mult[3] * globalMult[3]), false),
  371. computerOwned: displayNum(player.buildings[2].owned, false), computerCost: displayNum(player.buildings[2].proofCost, false), computerManual: displayNum(player.buildings[2].manual, false), computerPower: displayNum(2 * player.mult[0] * globalMult[0], true),
  372. assemblyLineOwned: displayNum(player.buildings[7].owned, false), assemblyLineCost: displayNum(player.buildings[7].proofCost, false), assemblyLineManual: displayNum(player.buildings[7].manual, false), assemblyLinePower: displayNum(Math.round(3 * player.mult[1] * globalMult[1]), false),
  373. factoryOwned: displayNum(player.buildings[12].owned, false), factoryCost: displayNum(player.buildings[12].proofCost, false), factoryManual: displayNum(player.buildings[12].manual, false), factoryPower: displayNum(Math.round(3 * player.mult[2] * globalMult[2]), false),
  374. factoryArchitectOwned: displayNum(player.buildings[17].owned, false), factoryArchitectCost: displayNum(player.buildings[17].proofCost, false), factoryArchitectManual: displayNum(player.buildings[17].manual, false), factoryArchitectPower: displayNum(Math.round(3 * player.mult[3] * globalMult[3]), false),
  375. highSchoolerOwned: displayNum(player.buildings[3].owned, false), highSchoolerCost: displayNum(player.buildings[3].moneyCost, true), highSchoolerManual: displayNum(player.buildings[3].manual, false), highSchoolerPower: displayNum(0.1 * player.mult[0] * globalMult[0], true),
  376. undergraduateOwned: displayNum(player.buildings[8].owned, false), undergraduateCost: displayNum(player.buildings[8].moneyCost, true), undergraduateManual: displayNum(player.buildings[8].manual, false), undergraduatePower: displayNum(Math.round(player.mult[1] * globalMult[1]), false),
  377. graduateStudentOwned: displayNum(player.buildings[13].owned, false), graduateStudentCost: displayNum(player.buildings[13].moneyCost, true), graduateStudentManual: displayNum(player.buildings[13].manual, false), graduateStudentPower: displayNum(Math.round(player.mult[2] * globalMult[2]), false),
  378. postdocOwned: displayNum(player.buildings[18].owned, false), postdocCost: displayNum(player.buildings[18].moneyCost, true), postdocManual: displayNum(player.buildings[18].manual, false), postdocPower: displayNum(Math.round(player.mult[3] * globalMult[3]), false),
  379. mathematicianOwned: displayNum(player.buildings[4].owned, false), mathematicianCost: displayNum(player.buildings[4].moneyCost, true), mathematicianManual: displayNum(player.buildings[4].manual, false),
  380. andrewWilesOwned: displayNum(player.buildings[9].owned, false), andrewWilesCost: displayNum(player.buildings[9].moneyCost, true), andrewWilesManual: displayNum(player.buildings[9].manual, false), andrewWilesPower: displayNum(Math.round(player.mult[1] * globalMult[1]), false),
  381. kurtGodelOwned: displayNum(player.buildings[14].owned, false), kurtGodelCost: displayNum(player.buildings[14].moneyCost, true), kurtGodelManual: displayNum(player.buildings[14].manual, false), kurtGodelPower: displayNum(Math.round(player.mult[2] * globalMult[2]), false),
  382. georgRiemannOwned: displayNum(player.buildings[19].owned, false), georgRiemannCost: displayNum(player.buildings[19].moneyCost, true), georgRiemannManual: displayNum(player.buildings[19].manual, false), georgRiemannPower: displayNum(Math.round(player.mult[3] * globalMult[3]), false),
  383. clicksToGain: player.clicksToGain});
  384.  
  385. var row5 = row5Template({deriv5Owned: displayNum(player.buildings[20].owned, false), deriv5MoneyCost: displayNum(player.buildings[20].moneyCost, true), deriv5ProofCost: displayNum(player.buildings[20].proofCost, true), deriv5Manual: displayNum(player.buildings[20].manual, false), deriv5Power: displayNum(Math.round(player.mult[4] * globalMult[4]), false),
  386. topologyOwned: displayNum(player.buildings[21].owned, false), topologyCost: displayNum(player.buildings[21].moneyCost, true), topologyManual: displayNum(player.buildings[21].manual, false), topologyPower: displayNum(Math.round(player.mult[4] * globalMult[4]), false),
  387. designSchoolOwned: displayNum(player.buildings[22].owned, false), designSchoolCost: displayNum(player.buildings[22].proofCost, true), designSchoolManual: displayNum(player.buildings[22].manual, false), designSchoolPower: displayNum(Math.round(3 * player.mult[4] * globalMult[4]), false),
  388. researchScientistOwned: displayNum(player.buildings[23].owned, false), researchScientistCost: displayNum(player.buildings[23].moneyCost, true), researchScientistManual: displayNum(player.buildings[23].manual, false), researchScientistPower: displayNum(Math.round(player.mult[4] * globalMult[4]), false),
  389. carlGaussOwned: displayNum(player.buildings[24].owned, false), carlGaussCost: displayNum(player.buildings[24].moneyCost, true), carlGaussManual: displayNum(player.buildings[24].manual, false), carlGaussPower: displayNum(Math.round(player.mult[4] * globalMult[4]), false),
  390. clicksToGain: player.clicksToGain})
  391.  
  392. $("#firstRows").html(firstRows);
  393. if(player.numResets[0] >= 1) $("#row5").html(row5);
  394. else $("#row5").html(null);
  395.  
  396. //updates whether buttons are lit using a list of buttons
  397. buttonList = jQuery.makeArray($("#tableContainer div table tr .button"));
  398.  
  399. if(player.numToBuy == "Max"){
  400. for(var i = 0; i < buttonList.length; i++){
  401. if(player.money < player.buildings[i].moneyCost || player.proofs < player.buildings[i].proofCost){
  402. buttonList[i].className = "button";
  403. }
  404. else{
  405. buttonList[i].className = "buttonLit";
  406. }
  407. }
  408. }
  409. else{
  410. for(var i = 0; i < buttonList.length; i++){
  411. var moneyCost = calcTotalPrice(player.buildings[i].moneyCost, player.buildings[i].factor, player.numToBuy);
  412. var proofCost = calcTotalPrice(player.buildings[i].proofCost, player.buildings[i].factor, player.numToBuy);
  413. if(player.money < moneyCost || player.proofs < proofCost){
  414. buttonList[i].className = "button";
  415. }
  416. else{
  417. buttonList[i].className = "buttonLit";
  418. }
  419. }
  420. }
  421. }
  422.  
  423. function updateStats(){
  424. var newStats = statsTemplate({totalMoneyEarned: displayNum(player.totalMoneyEarned, true), totalProofs: displayNum(player.totalProofs, false),
  425. totalClicks: displayNum(player.totalClicks, false), totalManualClicks: displayNum(player.totalManualClicks, false)});
  426.  
  427. $("#statContainer").html(newStats);
  428. }
  429.  
  430. function updatePrestige(){
  431. var newPrestige = prestigeTemplate({tier1Resets: player.numResets[0], tier1ResetCurr: displayNum(player.resetCurr[0], false), tier1GlobalMult: displayNum(globalMult[0], false), tier1CurrTracker: displayNum(player.resetCurrTracker, false),
  432. tier2Resets: player.numResets[1], tier2ResetCurr: displayNum(player.resetCurr[1], false), tier2GlobalMult: displayNum(globalMult[1], false), tier2CurrTracker: displayNum(Math.floor(player.resetCurr[0] / 5), false),
  433. tier3Resets: player.numResets[2], tier3ResetCurr: displayNum(player.resetCurr[2], false), tier3GlobalMult: displayNum(globalMult[2], false), tier3CurrTracker: displayNum(Math.floor(player.resetCurr[1] / 5), false),
  434. tier4Resets: player.numResets[3], tier4ResetCurr: displayNum(player.resetCurr[3], false), tier4GlobalMult: displayNum(globalMult[3], false), tier4CurrTracker: displayNum(Math.floor(player.resetCurr[2] / 5), false),
  435. tier5Resets: player.numResets[4], tier5ResetCurr: displayNum(player.resetCurr[4], false), tier5GlobalMult: displayNum(globalMult[4], false), tier5CurrTracker: displayNum(Math.floor(player.resetCurr[3] / 5), false),
  436. proofsToNextCurr: displayNum(player.proofsToNextCurr, false), mathematiciansToNextCurr: displayNum(player.mathematiciansToNextCurr, false)});
  437.  
  438. $("#prestige").html(newPrestige);
  439. }
  440.  
  441. function ifUnlockedTier(tier){
  442. if(player.numResets[0] >= tier - 4) return true;
  443. return false;
  444. }
  445.  
  446. function updateUpgrades(){
  447. var newUpgrades = upgradesTemplate({tier1UpgradeCost: displayNum(player.upgradeCosts[0], true), tier1UpgradeOwned: displayNum(player.tierUpgrades[0], false), tier1Mult: displayNum(player.mult[0], false),
  448. tier2UpgradeCost: displayNum(player.upgradeCosts[1], true), tier2UpgradeOwned: displayNum(player.tierUpgrades[1], false), tier2Mult: displayNum(player.mult[1], false),
  449. tier3UpgradeCost: displayNum(player.upgradeCosts[2], true), tier3UpgradeOwned: displayNum(player.tierUpgrades[2], false), tier3Mult: displayNum(player.mult[2], false),
  450. tier4UpgradeCost: displayNum(player.upgradeCosts[3], true), tier4UpgradeOwned: displayNum(player.tierUpgrades[3], false), tier4Mult: displayNum(player.mult[3], false),
  451. tier5UpgradeCost: displayNum(player.upgradeCosts[4], true), tier5UpgradeOwned: displayNum(player.tierUpgrades[4], false), tier5Mult: displayNum(player.mult[4], false),
  452. autoclickerCost: displayNum(player.upgradeCosts[5], true), autoclickerOwned: displayNum(player.upgrades[0], false),
  453. clickImproverCost: displayNum(player.upgradeCosts[6], true), clickImproverOwned: displayNum(player.upgrades[1], false)});
  454.  
  455. $("#upgrades").html(newUpgrades);
  456.  
  457. //changes text if tiers aren't unlocked
  458. if(!ifUnlockedTier(5)) $("#ifUnlocked5").html("You haven't unlocked this tier. Don't waste your money.");
  459.  
  460. buttonList = jQuery.makeArray($("#upgradesTable tr .button"));
  461.  
  462. for(var i = 0; i < buttonList.length; i++){
  463. if(player.money < player.upgradeCosts[i]){
  464. buttonList[i].className = "button";
  465. }
  466. else{
  467. buttonList[i].className = "buttonLit";
  468. }
  469. }
  470. }
  471.  
  472. //this is a function to click the money button: allows auto button clicking
  473. function moneyButtonClick(amount) {
  474. addMoney(player.moneyPerClick * amount);
  475. updateMoney();
  476. player.clickTracker += amount;
  477. player.totalClicks += amount;
  478. while(player.clickTracker >= player.clicksToGain){
  479. var toAdd = Math.round(player.buildings[8].owned * player.mult[1] * globalMult[1])
  480. player.clickTracker -= player.clicksToGain;
  481. calcMult(1);
  482. addMoneyPerClick(0.1 * player.mult[0] * toAdd * globalMult[0]);
  483. addClickUpgrades(toAdd, Math.round(player.buildings[13].owned * player.mult[2] * globalMult[2]), Math.round(player.buildings[18].owned * player.mult[3] * globalMult[3]), Math.round(player.buildings[23].owned * player.mult[4] * globalMult[4]));
  484. update = true;
  485. }
  486. updateInventory();
  487. }
  488.  
  489. //things that run on startup: moneybutton initialization, tabs, initial DOM updates, load save
  490. $(document).ready(function(){
  491. $("#tabs").tabs({show:{effect: "slideDown"}}, {hide:{effect: "slideUp"}});
  492.  
  493. if(localStorage.getItem("playerStored") != null) load();
  494. if(typeof enableChart == 'undefined') enableChart = true;
  495. if(!enableChart) $("#chartStuff").toggle();
  496.  
  497. if(player.upgrades[1] == 24) player.upgradeCosts[numTiers + 1] = Infinity; //deals with JSON's incompatibility with Infinity
  498.  
  499. //resets if the current version is incompatible with the savefile
  500. if(typeof player.versionNum == 'undefined' || player.versionNum < 0.18){
  501. init();
  502. alert("Your save has been wiped as part of an update. Sorry for the inconvenience.");
  503. localStorage.setItem("playerStored", JSON.stringify(player));
  504. }
  505. else if(player.versionNum < versionNum) player.versionNum = versionNum;
  506.  
  507. $("#version").html(player.versionNum);
  508.  
  509. $("#currentNumToBuy").html(player.numToBuy);
  510.  
  511. calcGlobalMult();
  512.  
  513. updateMoney();
  514. updateInventory();
  515. updateUpgrades();
  516. updateStats();
  517. updatePrestige();
  518.  
  519. $("#moneyButton").click(function(){
  520. moneyButtonClick(1);
  521. player.totalManualClicks++;
  522. });
  523. });
  524.  
  525. //function to buy buildings: onclick events
  526.  
  527. function buyBuilding(index){
  528. var numToBuy, moneyCost, proofCost;
  529. if(player.numToBuy == "Max"){
  530. var numToBuy = 0;
  531. while(calcTotalPrice(player.buildings[index].moneyCost, player.buildings[index].factor, numToBuy) <= player.money && Math.round(calcTotalPrice(player.buildings[index].proofCost, player.buildings[index].factor, numToBuy)) <= player.proofs){
  532. numToBuy++;
  533. }
  534. numToBuy--;
  535. }
  536. else numToBuy = player.numToBuy;
  537.  
  538. moneyCost = calcTotalPrice(player.buildings[index].moneyCost, player.buildings[index].factor, numToBuy);
  539. proofCost = Math.round(calcTotalPrice(player.buildings[index].proofCost, player.buildings[index].factor, numToBuy));
  540.  
  541. if(player.money >= moneyCost && player.proofs >= proofCost){
  542.  
  543. player.buildings[index].owned += numToBuy;
  544. player.buildings[index].manual += numToBuy;
  545.  
  546. addMoney(-moneyCost);
  547. player.proofs -= proofCost;
  548.  
  549. player.buildings[index].moneyCost = Math.round((player.buildings[index].moneyCost * Math.pow(player.buildings[index].factor, numToBuy))*100)/100;
  550. player.buildings[index].proofCost = Math.round(player.buildings[index].proofCost * Math.pow(player.buildings[index].factor, numToBuy));
  551.  
  552. calcMult(Math.ceil(index/5.0 + 0.1)); //picks the right multiplier based on the index
  553. switch(index){
  554. case 0: //deriv1
  555. addMoneyPerSecond(player.deriv1Money * player.mult[0] * numToBuy * globalMult[0]);
  556. addNetMoneyPerSecond(player.deriv1Money * player.mult[0] * numToBuy * globalMult[0]);
  557. break;
  558. case 1: //combinatorics
  559. player.proofsPerSecond += 1 * player.mult[0] * numToBuy * globalMult[0];
  560. player.proofsPerSecond = Math.floor(player.proofsPerSecond);
  561. addNetMoneyPerSecond(-player.costPerProof * player.mult[0] * numToBuy * globalMult[0]);
  562. break;
  563. case 2: //computer
  564. addMoneyPerSecond(2 * player.mult[0] * numToBuy * globalMult[0]);
  565. addNetMoneyPerSecond(2 * player.mult[0] * numToBuy * globalMult[0]);
  566. break;
  567. case 3: //high schooler
  568. addMoneyPerClick(0.1 * player.mult[0] * numToBuy * globalMult[0]);
  569. break;
  570. case 4: //mathematician
  571. player.mathematiciansToNextCurr -= numToBuy;
  572. default:
  573. break;
  574. }
  575. }
  576. updateMoney();
  577. updateInventory();
  578. }
  579.  
  580. //function to buy upgrades: onclick events
  581.  
  582. function buyUpgrade(index){
  583. if(player.money >= player.upgradeCosts[index]){
  584. if(index < numTiers){
  585. player.tierUpgrades[index]++;
  586. }
  587. else{
  588. player.upgrades[index - numTiers]++;
  589. }
  590.  
  591. addMoney(-player.upgradeCosts[index]);
  592. player.upgradeCosts[index] = Math.round((player.upgradeCosts[index] * upgradeCostFactor[index])*100)/100;
  593. calcMult(index + 1);
  594.  
  595. if(index == numTiers + 1){
  596. player.upgradeCosts[index] = factorial(player.upgrades[1]+1)*10*player.upgrades[1]+1
  597. if(player.upgrades[index - numTiers] >= 24){
  598. player.upgradeCosts[index] = Infinity;
  599. }
  600. player.clicksToGain--;
  601. }
  602.  
  603. updateUpgrades();
  604. updateMoney();
  605. }
  606. }
  607.  
  608. //stuff that happens each tick
  609. setTimeout(function update(){
  610. // update.count makes stuff happen every 3 ticks
  611. if(typeof update.count == 'undefined'){
  612. update.count = 0;
  613. }
  614. // update.count2 makes stuff happen every minute
  615. if(typeof update.count2 == 'undefined'){
  616. update.count2 = 0;
  617. }
  618. //intervalTracker fixes window minimization issues
  619. if(typeof update.intervalTracker == 'undefined'){
  620. update.intervalTracker = 0;
  621. }
  622. if(typeof update.before == 'undefined'){
  623. update.before = new Date();
  624. }
  625.  
  626. var now = new Date();
  627. var elapsedTime = now.getTime() - update.before.getTime();
  628.  
  629. update.intervalTracker += isActive ? 0 : elapsedTime;
  630.  
  631. do{
  632. //updates multiplier
  633. for(var i = 0; i < numTiers; i++){
  634. calcMult(i);
  635. }
  636.  
  637. //adds money
  638. addMoney(player.buildings[0].owned * player.deriv1Money * player.mult[0] * globalMult[0]);
  639. addMoney(player.buildings[2].owned * 2 * player.mult[0] * globalMult[0]);
  640.  
  641. //checks if enough money to add full amount of proofs: if so, adds proofs, otherwise, adds as many proofs as possible
  642. if(player.money >= player.buildings[1].owned * player.costPerProof * player.mult[0] * globalMult[0]){
  643. addProofs(player.buildings[1].owned * player.mult[0] * globalMult[0]);
  644. }
  645. else addProofs(player.money / player.costPerProof);
  646.  
  647. //does stuff every ten ticks
  648. if(update.count === 10){
  649. inventoryAdder();
  650. update.count = 0;
  651. }
  652.  
  653. //does stuff every 60 ticks
  654. if(update.count2 === 60){
  655. save();
  656. moneyButtonClick(player.upgrades[0]);
  657. update.count2 = 0;
  658. }
  659.  
  660. //checks if enough proofs/mathematicians for reset currency: if so, adds reset currency
  661. while(player.proofsToNextCurr < 0){
  662. player.resetCurrTracker++;
  663. player.proofsToCurrTracker++;
  664. player.proofsToNextCurr += 100 * Math.pow(25 * (40 + player.proofsToCurrTracker), 4);
  665. }
  666. while(player.mathematiciansToNextCurr < 0){
  667. player.resetCurrTracker++;
  668. player.mathematiciansToNextCurrTracker++;
  669. player.mathematiciansToNextCurr += 70 * Math.pow((100 + player.mathematiciansToNextCurrTracker), 4)
  670. }
  671.  
  672.  
  673. //recalculates money/proofs per tick
  674. player.moneyPerClick = ((player.buildings[3].owned * player.mult[0] * 0.1) + 1) * globalMult[0];
  675. player.moneyPerSecond = (((player.buildings[0].owned * player.deriv1Money * player.mult[0]) + (player.buildings[2].owned * 2 * player.mult[0])) * globalMult[0]);
  676. player.proofsPerSecond = Math.floor(player.buildings[1].owned * player.mult[0] * globalMult[0]);
  677. player.netMoneyPerSecond = player.moneyPerSecond - (player.proofsPerSecond * player.costPerProof);
  678. player.moneyPerAutoclick = player.upgrades[0] * player.moneyPerClick;
  679.  
  680. update.count++;
  681. update.count2++;
  682.  
  683. player.updateInterval = 1000 * Math.pow(0.98, Math.log(player.buildings[4].owned * player.mult[0] * globalMult[0] + 1));
  684.  
  685. //this fixes minimization by running until the interval tracker is less than 0 if the thing isn't active
  686. if(!isActive) update.intervalTracker -= player.updateInterval;
  687.  
  688. }while(!isActive && update.intervalTracker > 0 && elapsedTime > player.updateInterval);
  689.  
  690. //checks active tab, updates appropriate things
  691. var activeTab = $("#tabs").tabs("option", "active");
  692. switch(activeTab){
  693. case 0:
  694. updateInventory();
  695. break;
  696.  
  697. case 1:
  698. updateUpgrades();
  699. break;
  700.  
  701. case 2:
  702. updatePrestige();
  703. break;
  704.  
  705. case 4:
  706. updateStats();
  707. break;
  708. }
  709. updateMoney();
  710.  
  711. update.before = new Date();
  712.  
  713. setTimeout(update, player.updateInterval);
  714. }, player.updateInterval);
  715.  
  716. //stuff that happens every ten ticks (i.e. inventory additions)
  717. function inventoryAdder(){
  718. player.mathematiciansToNextCurr -= Math.round(player.buildings[9].owned * player.mult[1] * globalMult[1]);
  719.  
  720. for(var i = 0; i < player.buildings.length - 5; i++){
  721. switch(i % 5){
  722. case 0:
  723. case 1:
  724. case 4:
  725. player.buildings[i].owned += Math.round(player.buildings[i+5].owned * player.mult[Math.floor(i/5) + 1] * globalMult[Math.floor(i/5) + 1]);
  726. break;
  727. case 2:
  728. player.buildings[i].owned += Math.round(3 * player.buildings[i+5].owned * player.mult[Math.floor(i/5) + 1] * globalMult[Math.floor(i/5) + 1]);
  729. break;
  730. default:
  731. break;
  732.  
  733. }
  734. }
  735. }
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!