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

src/Cache/CPS/AverageQueue.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-unused-vars */
+import { ClickTimes, CookieTimes } from '../../Disp/VariablesAndData';
+import {
+	ChoEggDiff, ClicksDiff, CookiesDiff, WrinkDiff, WrinkFattestDiff,
+} from '../VariablesAndData';
+
+/**
+ * @class
+ * @classdesc 	This is a class used to store values used to calculate average over time (mostly cps)
+ * @var			{number}				maxLength	The maximum length of the value-storage
+ * @var			{[]}					queue		The values stored
+ * @method		addLatest(newValue)		Appends newValue to the value storage
+ * @method		calcAverage(timePeriod)	Returns the average over the specified timeperiod
+ */
+export class CMAvgQueue {
+	constructor(maxLength) {
+		this.maxLength = maxLength;
+		this.queue = [];
+	}
+
+	addLatest(newValue) {
+		if (this.queue.push(newValue) > this.maxLength) {
+			this.queue.shift();
+		}
+	}
+
+	/**
+	 * This functions returns the average of the values in the queue
+	 * @param 	{number}	timePeriod	The period in seconds to computer average over
+	 * @returns {number}	ret			The average
+ 	 */
+	calcAverage(timePeriod) {
+		if (timePeriod > this.maxLength) timePeriod = this.maxLength;
+		if (timePeriod > this.queue.length) timePeriod = this.queue.length;
+		let ret = 0;
+		for (let i = this.queue.length - 1; i >= 0 && i > this.queue.length - 1 - timePeriod; i--) {
+			ret += this.queue[i];
+		}
+		if (ret === 0) {
+			return 0;
+		}
+		return ret / timePeriod;
+	}
+}
+
+/**
+ * This functions caches creates the CMAvgQueue used by CM.Cache.CacheAvgCPS() to calculate CPS
+ * Called by CM.Cache.InitCache()
+ */
+export function InitCookiesDiff() {
+	CookiesDiff = new CMAvgQueue(CookieTimes[CookieTimes.length - 1]);
+	WrinkDiff = new CMAvgQueue(CookieTimes[CookieTimes.length - 1]);
+	WrinkFattestDiff = new CMAvgQueue(CookieTimes[CookieTimes.length - 1]);
+	ChoEggDiff = new CMAvgQueue(CookieTimes[CookieTimes.length - 1]);
+	ClicksDiff = new CMAvgQueue(ClickTimes[ClickTimes.length - 1]);
+}

src/Cache/CPS/CPS.js

@@ -0,0 +1,67 @@
+/* eslint-disable no-unused-vars */
+
+import { CMOptions } from '../../Config/VariablesAndData';
+import { ClickTimes, CookieTimes } from '../../Disp/VariablesAndData';
+import {
+	CacheAverageClicks, CacheAverageCPS, CacheAverageGainBank, CacheAverageGainChoEgg, CacheAverageGainWrink, CacheAverageGainWrinkFattest, CacheAvgCPSWithChoEgg, CacheLastChoEgg, CacheLastClicks, CacheLastCookies, CacheLastCPSCheck, CacheLastWrinkCookies, CacheLastWrinkFattestCookies, CacheRealCookiesEarned, CacheSellForChoEgg, CacheWrinklersFattest, CacheWrinklersTotal, ChoEggDiff, ClicksDiff, CookiesDiff, WrinkDiff, WrinkFattestDiff,
+} from '../VariablesAndData';
+
+/**
+ * This functions caches two variables related average CPS and Clicks
+ * It is called by CM.Cache.LoopCache()
+ * @global	{number}	CM.Cache.RealCookiesEarned	Cookies earned including the Chocolate Egg
+ * @global	{number}	CM.Cache.AvgCPS				Average cookies over time-period as defined by AvgCPSHist
+ * @global	{number}	CM.Cache.AverageClicks		Average cookies from clicking over time-period as defined by AvgClicksHist
+ * @global	{number}	CM.Cache.AvgCPSChoEgg		Average cookies from combination of normal CPS and average Chocolate Cookie CPS
+ */
+export default function CacheAvgCPS() {
+	const currDate = Math.floor(Date.now() / 1000);
+	// Only calculate every new second
+	if ((Game.T / Game.fps) % 1 === 0) {
+		let choEggTotal = Game.cookies + CacheSellForChoEgg;
+		if (Game.cpsSucked > 0) choEggTotal += CacheWrinklersTotal;
+		CacheRealCookiesEarned = Math.max(Game.cookiesEarned, choEggTotal);
+		choEggTotal *= 0.05;
+
+		// Add recent gains to AvgQueue's
+		const timeDiff = currDate - CacheLastCPSCheck;
+		const bankDiffAvg = Math.max(0, (Game.cookies - CacheLastCookies)) / timeDiff;
+		const wrinkDiffAvg = Math.max(0, (CacheWrinklersTotal - CacheLastWrinkCookies)) / timeDiff;
+		const wrinkFattestDiffAvg = Math.max(0, (CacheWrinklersFattest[0] - CacheLastWrinkFattestCookies)) / timeDiff;
+		const choEggDiffAvg = Math.max(0, (choEggTotal - CacheLastChoEgg)) / timeDiff;
+		const clicksDiffAvg = (Game.cookieClicks - CacheLastClicks) / timeDiff;
+		for (let i = 0; i < timeDiff; i++) {
+			CookiesDiff.addLatest(bankDiffAvg);
+			WrinkDiff.addLatest(wrinkDiffAvg);
+			WrinkFattestDiff.addLatest(wrinkFattestDiffAvg);
+			ChoEggDiff.addLatest(choEggDiffAvg);
+			ClicksDiff.addLatest(clicksDiffAvg);
+		}
+
+		// Store current data for next loop
+		CacheLastCPSCheck = currDate;
+		CacheLastCookies = Game.cookies;
+		CacheLastWrinkCookies = CacheWrinklersTotal;
+		CacheLastWrinkFattestCookies = CacheWrinklersFattest[0];
+		CacheLastChoEgg = choEggTotal;
+		CacheLastClicks = Game.cookieClicks;
+
+		// Get average gain over period of cpsLength seconds
+		const cpsLength = CookieTimes[CMOptions.AvgCPSHist];
+		CacheAverageGainBank = CookiesDiff.calcAverage(cpsLength);
+		CacheAverageGainWrink = WrinkDiff.calcAverage(cpsLength);
+		CacheAverageGainWrinkFattest = WrinkFattestDiff.calcAverage(cpsLength);
+		CacheAverageGainChoEgg = ChoEggDiff.calcAverage(cpsLength);
+		CacheAverageCPS = CacheAverageGainBank;
+		if (CMOptions.CalcWrink === 1) CacheAverageCPS += CacheAverageGainWrink;
+		if (CMOptions.CalcWrink === 2) CacheAverageCPS += CacheAverageGainWrinkFattest;
+
+		const choEgg = (Game.HasUnlocked('Chocolate egg') && !Game.Has('Chocolate egg'));
+
+		if (choEgg || CMOptions.CalcWrink === 0) {
+			CacheAvgCPSWithChoEgg = CacheAverageGainBank + CacheAverageGainWrink + (choEgg ? CacheAverageGainChoEgg : 0);
+		} else CacheAvgCPSWithChoEgg = CacheAverageCPS;
+
+		CacheAverageClicks = ClicksDiff.calcAverage(ClickTimes[CMOptions.AvgClicksHist]);
+	}
+}

src/Cache/CPS/CurrWrinklerCPS.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-unused-vars */
+import { SimObjects } from '../../Sim/VariablesAndData';
+import { CacheCurrWrinklerCount, CacheCurrWrinklerCPSMult } from '../VariablesAndData';
+
+/**
+ * This functions caches the current Wrinkler CPS multiplier
+ * @global	{number}	CM.Cache.CurrWrinklerCount		Current number of wrinklers
+ * @global	{number}	CM.Cache.CurrWrinklerCPSMult	Current multiplier of CPS because of wrinklers (excluding their negative sucking effect)
+ */
+export default function CacheCurrWrinklerCPS() {
+	CacheCurrWrinklerCPSMult = 0;
+	let count = 0;
+	for (const i in Game.wrinklers) {
+		if (Game.wrinklers[i].phase === 2) count++;
+	}
+	let godMult = 1;
+	if (SimObjects.Temple.minigameLoaded) {
+		const godLvl = Game.hasGod('scorn');
+		if (godLvl === 1) godMult *= 1.15;
+		else if (godLvl === 2) godMult *= 1.1;
+		else if (godLvl === 3) godMult *= 1.05;
+	}
+	CacheCurrWrinklerCount = count;
+	CacheCurrWrinklerCPSMult = count * (count * 0.05 * 1.1) * (Game.Has('Sacrilegious corruption') * 0.05 + 1) * (Game.Has('Wrinklerspawn') * 0.05 + 1) * godMult;
+}

src/Cache/CPS/GetCPSBuffMult.js

@@ -0,0 +1,11 @@
+/**
+ * This function returns the current CPS buff
+ * @returns {number}	mult	The multiplier
+ */
+export default function GetCPSBuffMult() {
+	let mult = 1;
+	for (const i of Object.keys(Game.buffs)) {
+		if (typeof Game.buffs[i].multCpS !== 'undefined') mult *= Game.buffs[i].multCpS;
+	}
+	return mult;
+}

src/Cache/CPS/NoGoldSwitchCPS.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-unused-vars */
+import CalcNoGoldSwitchCPS from '../../Sim/Calculations/NoGoldenSwitchCalc';
+import { CacheNoGoldSwitchCookiesPS } from '../VariablesAndData';
+
+/**
+ * This function calculates CPS without the Golden Switch as it might be needed in other functions
+ * If so it CM.Sim.Win()'s them and the caller function will know to recall CM.Sim.CalculateGains()
+ * It is called at the end of any functions that simulates certain behaviour
+ */
+export default function CacheNoGoldSwitchCPS() {
+	if (Game.Has('Golden switch [off]')) {
+		CacheNoGoldSwitchCookiesPS = CalcNoGoldSwitchCPS();
+	} else CacheNoGoldSwitchCookiesPS = Game.cookiesPs;
+}

src/Cache/CPS/SellChoEgg.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-unused-vars */
+import SellBuildingsForChoEgg from '../../Sim/SimulationEvents/SellBuildingForChoEgg';
+import { CacheSellForChoEgg } from '../VariablesAndData';
+
+/**
+ * This functions caches the reward for selling the Chocolate egg
+ * It is called by CM.Main.Loop()
+ * @global	{number}	CM.Cache.SellForChoEgg	Total cookies to be gained from selling Chocolate egg
+ */
+export default function CacheSellAllForChoEgg() {
+	let sellTotal = 0;
+	// Compute cookies earned by selling stock market goods
+	if (Game.Objects.Bank.minigameLoaded) {
+		const marketGoods = Game.Objects.Bank.minigame.goods;
+		let goodsVal = 0;
+		for (const i of Object.keys(marketGoods)) {
+			const marketGood = marketGoods[i];
+			goodsVal += marketGood.stock * marketGood.val;
+		}
+		sellTotal += goodsVal * Game.cookiesPsRawHighest;
+	}
+	// Compute cookies earned by selling all buildings with optimal auras (ES + RB)
+	sellTotal += SellBuildingsForChoEgg();
+	CacheSellForChoEgg = sellTotal;
+}