Complete overhaul of code structure and relevant files (#639)

src/Cache/Stats/ChainCookies.js

@@ -0,0 +1,69 @@
+/* eslint-disable no-unused-vars */
+import GetCPSBuffMult from '../CPS/GetCPSBuffMult';
+import {
+	CacheChainFrenzyMaxReward, CacheChainFrenzyRequired, CacheChainFrenzyRequiredNext, CacheChainFrenzyWrathMaxReward, CacheChainFrenzyWrathRequired, CacheChainFrenzyWrathRequiredNext, CacheChainMaxReward, CacheChainRequired, CacheChainRequiredNext, CacheChainWrathMaxReward, CacheChainWrathRequired, CacheChainWrathRequiredNext, CacheDragonsFortuneMultAdjustment, CacheGoldenCookiesMult, CacheNoGoldSwitchCookiesPS, CacheWrathCookiesMult,
+} from '../VariablesAndData';
+
+/**
+ * This functions calculates the max possible payout given a set of variables
+ * It is called by CM.Disp.CreateStatsChainSection() and CM.Cache.CacheChain()
+ * @param	{number}					digit		Number of Golden Cookies in chain
+ * @param	{number}					maxPayout	Maximum payout
+ * @param	{number}					mult		Multiplier
+ * @returns	[{number, number, number}]				Total cookies earned, cookie needed for this and next level
+ */
+export function MaxChainCookieReward(digit, maxPayout, mult) {
+	let totalFromChain = 0;
+	let moni = 0;
+	let nextMoni = 0;
+	let nextRequired = 0;
+	let chain = 1 + Math.max(0, Math.ceil(Math.log(Game.cookies) / Math.LN10) - 10);
+	while (nextMoni < maxPayout) {
+		moni = Math.max(digit, Math.min(Math.floor(1 / 9 * 10 ** chain * digit * mult), maxPayout * mult));
+		nextMoni = Math.max(digit, Math.min(Math.floor(1 / 9 * 10 ** (chain + 1) * digit * mult), maxPayout * mult));
+		nextRequired = Math.floor(1 / 9 * 10 ** (chain + 1) * digit * mult);
+		totalFromChain += moni;
+		chain++;
+	}
+	return [totalFromChain, moni, nextRequired];
+}
+
+/**
+ * This functions caches data related to Chain Cookies reward from Golden Cookioes
+ * It is called by CM.Main.Loop() upon changes to cps and CM.Cache.InitCache()
+ * @global	[{number, number}]	CM.Cache.ChainMaxReward			Total cookies earned, and cookies needed for next level for normal chain
+ * @global	{number}			CM.Cache.ChainRequired			Cookies needed for maximum reward for normal chain
+ * @global	{number}			CM.Cache.ChainRequiredNext		Total cookies needed for next level for normal chain
+ * @global	[{number, number}]	CM.Cache.ChainMaxWrathReward			Total cookies earned, and cookies needed for next level for wrath chain
+ * @global	{number}			CM.Cache.ChainWrathRequired			Cookies needed for maximum reward for wrath chain
+ * @global	{number}			CM.Cache.ChainWrathRequiredNext		Total cookies needed for next level for wrath chain
+ * @global	[{number, number}]	CM.Cache.ChainFrenzyMaxReward			Total cookies earned, and cookies needed for next level for normal frenzy chain
+ * @global	{number}			CM.Cache.ChainFrenzyRequired			Cookies needed for maximum reward for normal frenzy chain
+ * @global	{number}			CM.Cache.ChainFrenzyRequiredNext		Total cookies needed for next level for normal frenzy chain
+ * @global	[{number, number}]	CM.Cache.ChainFrenzyWrathMaxReward			Total cookies earned, and cookies needed for next level for wrath frenzy chain
+ * @global	{number}			CM.Cache.ChainFrenzyWrathRequired			Cookies needed for maximum reward for wrath frenzy chain
+ * @global	{number}			CM.Cache.ChainFrenzyWrathRequiredNext		Total cookies needed for next level for wrath frenzy chain
+ */
+export function CacheChain() {
+	let maxPayout = CacheNoGoldSwitchCookiesPS * 60 * 60 * 6 * CacheDragonsFortuneMultAdjustment;
+	// Removes effect of Frenzy etc.
+	const cpsBuffMult = GetCPSBuffMult();
+	if (cpsBuffMult > 0) maxPayout /= cpsBuffMult;
+	else maxPayout = 0;
+
+	CacheChainMaxReward = MaxChainCookieReward(7, maxPayout, CacheGoldenCookiesMult);
+	CacheChainRequired = CacheChainMaxReward[1] * 2 / CacheGoldenCookiesMult;
+	CacheChainRequiredNext = CacheChainMaxReward[2] / 60 / 60 / 6 / CacheDragonsFortuneMultAdjustment;
+
+	CacheChainWrathMaxReward = MaxChainCookieReward(6, maxPayout, CacheWrathCookiesMult);
+	CacheChainWrathRequired = CacheChainWrathMaxReward[1] * 2 / CacheWrathCookiesMult;
+	CacheChainWrathRequiredNext = CacheChainWrathMaxReward[2] / 60 / 60 / 6 / CacheDragonsFortuneMultAdjustment;
+
+	CacheChainFrenzyMaxReward = MaxChainCookieReward(7, maxPayout * 7, CacheGoldenCookiesMult);
+	CacheChainFrenzyRequired = CacheChainFrenzyMaxReward[1] * 2 / CacheGoldenCookiesMult;
+	CacheChainFrenzyRequiredNext = CacheChainFrenzyMaxReward[2] / 60 / 60 / 6 / CacheDragonsFortuneMultAdjustment;
+
+	CacheChainFrenzyWrathMaxReward = MaxChainCookieReward(6, maxPayout * 7, CacheWrathCookiesMult);
+	CacheChainFrenzyWrathRequired = CacheChainFrenzyWrathMaxReward[1] * 2 / CacheWrathCookiesMult;
+	CacheChainFrenzyWrathRequiredNext = CacheChainFrenzyWrathMaxReward[2] / 60 / 60 / 6 / CacheDragonsFortuneMultAdjustment;
+}

src/Cache/Stats/HeavenlyChips.js

@@ -0,0 +1,33 @@
+/* eslint-disable no-unused-vars */
+import {
+	CacheHCPerSecond, CacheLastHeavenlyCheck, CacheLastHeavenlyChips, HeavenlyChipsDiff,
+} from '../VariablesAndData';
+
+/**
+ * This functions caches the heavenly chips per second in the last five seconds
+ * It is called by CM.Cache.LoopCache()
+ * @global	{number}	CM.Cache.HCPerSecond	The Heavenly Chips per second in the last five seconds
+ */
+export default function CacheHeavenlyChipsPS() {
+	const currDate = Math.floor(Date.now() / 1000);
+	// Only calculate every new second
+	if ((Game.T / Game.fps) % 1 === 0) {
+		const chipsOwned = Game.HowMuchPrestige(Game.cookiesReset);
+		const ascendNowToOwn = Math.floor(Game.HowMuchPrestige(Game.cookiesReset + Game.cookiesEarned));
+		const ascendNowToGet = ascendNowToOwn - Math.floor(chipsOwned);
+
+		// Add recent gains to AvgQueue's
+		const timeDiff = currDate - CacheLastHeavenlyCheck;
+		const heavenlyChipsDiffAvg = Math.max(0, (ascendNowToGet - CacheLastHeavenlyChips)) / timeDiff;
+		for (let i = 0; i < timeDiff; i++) {
+			HeavenlyChipsDiff.addLatest(heavenlyChipsDiffAvg);
+		}
+
+		// Store current data for next loop
+		CacheLastHeavenlyCheck = currDate;
+		CacheLastHeavenlyChips = ascendNowToGet;
+
+		// Get average gain over period of 5 seconds
+		CacheHCPerSecond = HeavenlyChipsDiff.calcAverage(5);
+	}
+}

src/Cache/Stats/MissingUpgrades.js

@@ -0,0 +1,40 @@
+/* eslint-disable no-unused-vars */
+import { crateMissing } from '../../Disp/MenuSections/CreateMissingUpgrades';
+import { CacheMissingUpgrades, CacheMissingUpgradesCookies, CacheMissingUpgradesPrestige } from '../VariablesAndData';
+
+/**
+ * This functions caches variables related to missing upgrades
+ * It is called by CM.Main.Loop() and CM.Cache.InitCache()
+ * @global	{string}	CM.Cache.MissingUpgrades			String containig the HTML to create the "crates" for missing normal upgrades
+ * @global	{string}	CM.Cache.MissingUpgradesCookies		String containig the HTML to create the "crates" for missing cookie upgrades
+ * @global	{string}	CM.Cache.MissingUpgradesPrestige	String containig the HTML to create the "crates" for missing prestige upgrades
+ */
+export default function CacheAllMissingUpgrades() {
+	CacheMissingUpgrades = '';
+	CacheMissingUpgradesCookies = '';
+	CacheMissingUpgradesPrestige = '';
+	const list = [];
+	// sort the upgrades
+	for (const i of Object.keys(Game.Upgrades)) {
+		list.push(Game.Upgrades[i]);
+	}
+	const sortMap = function (a, b) {
+		if (a.order > b.order) return 1;
+		if (a.order < b.order) return -1;
+		return 0;
+	};
+	list.sort(sortMap);
+
+	for (const i of Object.keys(list)) {
+		const me = list[i];
+
+		if (me.bought === 0) {
+			let str = '';
+
+			str += crateMissing(me);
+			if (me.pool === 'prestige') CacheMissingUpgradesPrestige += str;
+			else if (me.pool === 'cookie') CacheMissingUpgradesCookies += str;
+			else if (me.pool !== 'toggle' && me.pool !== 'unused' && me.pool !== 'debug') CacheMissingUpgrades += str;
+		}
+	}
+}

src/Cache/Stats/Reindeer.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-unused-vars */
+import { CacheSeaSpec } from '../VariablesAndData';
+
+/**
+ * This functions caches the reward of popping a reindeer
+ * It is called by CM.Main.Loop() and CM.Cache.InitCache()
+ * @global	{number}	CM.Cache.SeaSpec	The reward for popping a reindeer
+ */
+export default function CacheSeasonSpec() {
+	if (Game.season === 'christmas') {
+		let val = Game.cookiesPs * 60;
+		if (Game.hasBuff('Elder frenzy')) val *= 0.5;
+		if (Game.hasBuff('Frenzy')) val *= 0.75;
+		CacheSeaSpec = Math.max(25, val);
+		if (Game.Has('Ho ho ho-flavored frosting')) CacheSeaSpec *= 2;
+	}
+}

src/Cache/Stats/Stats.js

@@ -0,0 +1,73 @@
+/* eslint-disable no-unused-vars */
+/** Functions related to Caching stats */
+
+import SimHas from '../../Sim/ReplacedGameFunctions/SimHas';
+import GetCPSBuffMult from '../CPS/GetCPSBuffMult';
+import {
+	CacheConjure, CacheConjureReward, CacheDragonsFortuneMultAdjustment, CacheEdifice, CacheEdificeBuilding, CacheGoldenCookiesMult, CacheLucky, CacheLuckyFrenzy, CacheLuckyReward, CacheLuckyRewardFrenzy, CacheLuckyWrathReward, CacheLuckyWrathRewardFrenzy, CacheNoGoldSwitchCookiesPS, CacheWrathCookiesMult,
+} from '../VariablesAndData';
+
+/**
+ * This functions caches variables related to the stats page
+ */
+export function CacheStatsCookies() {
+	CacheLucky = (CacheNoGoldSwitchCookiesPS * 900) / 0.15;
+	CacheLucky *= CacheDragonsFortuneMultAdjustment;
+	const cpsBuffMult = GetCPSBuffMult();
+	if (cpsBuffMult > 0) CacheLucky /= cpsBuffMult;
+	else CacheLucky = 0;
+	CacheLuckyReward = CacheGoldenCookiesMult * (CacheLucky * 0.15) + 13;
+	CacheLuckyWrathReward = CacheWrathCookiesMult * (CacheLucky * 0.15) + 13;
+	CacheLuckyFrenzy = CacheLucky * 7;
+	CacheLuckyRewardFrenzy = CacheGoldenCookiesMult * (CacheLuckyFrenzy * 0.15) + 13;
+	CacheLuckyWrathRewardFrenzy = CacheWrathCookiesMult * (CacheLuckyFrenzy * 0.15) + 13;
+	CacheConjure = CacheLucky * 2;
+	CacheConjureReward = CacheConjure * 0.15;
+
+	CacheEdifice = 0;
+	let max = 0;
+	let n = 0;
+	for (const i of Object.keys(Game.Objects)) {
+		if (Game.Objects[i].amount > max) max = Game.Objects[i].amount;
+		if (Game.Objects[i].amount > 0) n++;
+	}
+	for (const i of Object.keys(Game.Objects)) {
+		if ((Game.Objects[i].amount < max || n === 1)
+			&& Game.Objects[i].amount < 400
+			&& Game.Objects[i].price * 2 > CacheEdifice) {
+			CacheEdifice = Game.Objects[i].price * 2;
+			CacheEdificeBuilding = i;
+		}
+	}
+}
+
+/**
+ * This functions calculates the multipliers of Golden and Wrath cookie rewards
+ */
+export function CacheGoldenAndWrathCookiesMults() {
+	let goldenMult = 1;
+	let wrathMult = 1;
+	let mult = 1;
+
+	// Factor auras and upgrade in mults
+	if (SimHas('Green yeast digestives')) mult *= 1.01;
+	if (SimHas('Dragon fang')) mult *= 1.03;
+
+	goldenMult *= 1 + Game.auraMult('Ancestral Metamorphosis') * 0.1;
+	goldenMult *= Game.eff('goldenCookieGain');
+	wrathMult *= 1 + Game.auraMult('Unholy Dominion') * 0.1;
+	wrathMult *= Game.eff('wrathCookieGain');
+
+	// Calculate final golden and wrath multipliers
+	CacheGoldenCookiesMult = mult * goldenMult;
+	CacheWrathCookiesMult = mult * wrathMult;
+
+	// Calculate Dragon's Fortune multiplier adjustment:
+	// If Dragon's Fortune (or Reality Bending) aura is active and there are currently no golden cookies,
+	// compute a multiplier adjustment to apply on the current CPS to simulate 1 golden cookie on screen.
+	// Otherwise, the aura effect will be factored in the base CPS making the multiplier not requiring adjustment.
+	CacheDragonsFortuneMultAdjustment = 1;
+	if (Game.shimmerTypes.golden.n === 0) {
+		CacheDragonsFortuneMultAdjustment *= 1 + Game.auraMult('Dragon\'s Fortune') * 1.23;
+	}
+}