game.js

// @ts-check
/**
 * A class for a game page container
 *
 * See core.js for the conventions used here. In short: every dojo.declare result
 * is captured in a plain global var so the checker can infer the class shape from
 * the object literal, while dojo.declare still registers the dotted path
 * (classes.game.Timer, com.nuclearunicorn.game.ui.GamePage, ...) exactly as before.
 * `new classes.game.X(...)` call sites are deliberately left alone so mods that
 * swap out a class on the global namespace keep working; the captured var is used
 * only in superclass position and in type annotations.
 */

/**
 * One line of a resource breakdown tooltip.
 * @typedef {{name: any, type: string, value: any, forceDisplay?: boolean}} ResStackEntry
 */
/**
 * A resource breakdown, as consumed by `processResourcePerTickStack`. Entries
 * nest: an element that is itself an array is rendered as an indented sub-stack.
 * @typedef {(ResStackEntry | ResStack)[]} ResStack
 */
/**
 * Display metadata for one effect. Every field is optional - a bare `{title: ...}`
 * is a valid meta, and `getEffectMeta` falls back to exactly that.
 * @typedef {{title?: string, resName?: string, type?: string, calculation?: string}} EffectMeta
 */
/**
 * A parsed save blob. Every manager owns a top level key and is free to put
 * whatever it likes under it, so this stays an open record; `saveVersion` is the
 * only field game.js itself reads.
 * @typedef {{saveVersion?: number} & Record<string, any>} SaveData
 */
/**
 * One undoable game action, as recorded by `UndoChange#addEvent`.
 * @typedef {{managerId: string, data: any, description: string}} UndoEvent
 */
/**
 * A recurring callback registered with `Timer#addEvent`. `phase` counts down once
 * per tick; the handler fires and the phase resets when it reaches zero.
 * @typedef {{handler: () => void, frequency: number, phase: number}} TimerEvent
 */

/**
 * dojo.declare hands back a constructor *value*, not a TypeScript class, so the
 * bare name cannot be used in a type position. These aliases give each captured
 * class an instance type under the same name - the type and the var live in
 * separate declaration spaces, so `Timer` means the constructor in an expression
 * and the instance everywhere a type is expected.
 *
 * These are inferred from the object literals, so a component that types its
 * `game` back-reference as `GamePage` may NOT be referenced back from GamePage's
 * own props by type: the two inferences would chase each other and TS bails with
 * "circularly references itself". The back-reference is the side worth keeping -
 * it is what every manager in js/ wants (see the TODO on TabManager#game in
 * core.js) - so GamePage's handles to those components stay loose instead.
 *
 * @typedef {InstanceType<typeof Timer>} Timer
 * @typedef {InstanceType<typeof Telemetry>} Telemetry
 * @typedef {InstanceType<typeof Server>} Server
 * @typedef {InstanceType<typeof UndoChange>} UndoChange
 * @typedef {InstanceType<typeof EffectsManager>} EffectsManager
 * @typedef {InstanceType<typeof GamePage>} GamePage
 */



/**
 * Just a simple timer, js timer sucks
 */
var Timer = dojo.declare("classes.game.Timer", null, {
	/** @type {TimerEvent[]} */
	handlers: [],
	/** @type {(() => void)[]} */
	scheduledHandlers: [],

	ticksTotal: 0,
	/** @type {number} epoch ms captured by beforeUpdate */
	timestampStart: null,
	/** @type {number} running sum of every tick's duration, in ms */
	totalUpdateTime: null,
	currentTime: 0,
	averageTime: 0,



	/**
	 * Register a handler to be fired every `frequency` ticks.
	 * @param {() => void} handler
	 * @param {number} frequency - in ticks
	 */
	addEvent: function(handler, frequency){
		this.handlers.push({
			handler: handler,
			frequency: frequency,
			phase: 0
		});
	},

	update: function(){
		for (var i = 0; i < this.handlers.length; i++){
			var h = this.handlers[i];
			h.phase--;
			if (h.phase <= 0){
				h.phase = h.frequency;
				h.handler();
			}
		}
	},

	/**
	 * Run `handler` once, at the top of the next tick. Used to keep save/load/reset
	 * from landing in the middle of an update cycle.
	 * @param {() => void} handler
	 */
	scheduleEvent: function(handler){
		this.scheduledHandlers.push(handler);
	},

	updateScheduledEvents: function(){
		for (var i in this.scheduledHandlers){
			this.scheduledHandlers[i]();
		}
		this.scheduledHandlers = [];
	},

	beforeUpdate: function(){
		this.timestampStart = new Date().getTime();
	},

	afterUpdate: function(){
		this.ticksTotal++;

		var timestampEnd = new Date().getTime();

		var tsDiff = timestampEnd - this.timestampStart;
		this.totalUpdateTime += tsDiff;


		this.currentTime = tsDiff;
		this.averageTime = Math.round(this.totalUpdateTime / this.ticksTotal);
	}
});

var IDataStorageAware = dojo.declare("mixin.IDataStorageAware", null, {
	/**
	 * `save`/`load` are the contract this mixin imposes on whatever class mixes
	 * it in; they are not defined here.
	 * @this {{save: (...args: any[]) => any, load: (...args: any[]) => any}}
	 */
	constructor: function(){
		dojo.subscribe("server/save", dojo.hitch(this, this.save));
		dojo.subscribe("server/load", dojo.hitch(this, this.load));
	}
});

var Telemetry = dojo.declare("classes.game.Telemetry", [IDataStorageAware], {

	/** @type {string} rfc4122 v4 id identifying this player across saves */
	guid: null,
	/** @type {GamePage} */
	game: null,

	/** @type {string} set by the platform bootstrap from build.version.json */
	buildRevision: null,
	/** @type {string} */
	version: null,
	errorCount: 0,

	/** @param {GamePage} game */
	constructor: function(game) {
		this.guid = this.generateGuid();
		this.game = game;
	},

	// See https://www.ietf.org/rfc/rfc4122.txt, section 4.4
	/** @returns {string} */
	generateGuid: function() {
		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
			return (c == "x" ? 16 * Math.random() | 0 : 4 * Math.random() | 8).toString(16);
		});
	},

	/** @param {SaveData} data */
	save: function(data) {
		data["telemetry"] = {
			guid: this.guid
		};
	},

	/** @param {SaveData} data */
	load: function(data) {
		if (data["telemetry"]) {
			this.guid = data["telemetry"].guid || this.generateGuid();
		}

		var self = this;

		// FIXME: This really wants to happen before `window.load` is fired, but
		// this script isn't even loaded yet. So the first PageView will not get
		// all this data.
		if (window.newrelic && !this.game.opts.disableTelemetry){
			// Add a "release" so NR can determine which version of the code was loaded
			// when a JS error was noticed.
			window.newrelic.addRelease('KG', this.version + ".r" + this.buildRevision);

			// Log basic information to *all* PageAction and BrowserInteraction events
			// that follow such as game build, uid, etc.
			window.newrelic.setCustomAttribute('buildRevision', this.version + ".r" + this.buildRevision);
			window.newrelic.setCustomAttribute('guid', this.guid);

			if (this.game.server.userProfile){
				window.newrelic.setCustomAttribute('uid', this.game.server.userProfile.uid);
			}

			/**
			 * Known offenders that folks still use
			 */
			window.newrelic.setErrorHandler(function (err) {
				self.game.achievements.unlockBadge("ghostInTheMachine");

				if (self.errorCount >= 100){
					return true;
				}
				//ban error reporting from https://rawgit.com/mikiso1024/kitten-master/master/kitten_master.js
				if (err.stack.lastIndexOf("mikiso1024") >= 0){
					return true;
				} else {
					self.errorCount++;
					return false;
				}
			});

		}
	},

	// Use this method to create a new PageAction event
	/**
	 * @param {string} eventType
	 * @param {any} [payload] - decorated with build/uid by the browser agent
	 */
	logEvent: function(eventType, payload) {
		payload = payload || {};

		if (this.game.isReadOnly()){
			return;	//previewing someone else's save, none of this is our telemetry to send
		}

		if (window.newrelic && !this.game.opts.disableTelemetry){
			// This will already be decorated by other common things like game build, uid, etc.
			window.newrelic.addPageAction(eventType, payload);
		}
	},

	/** @param {string} name - the tab the player switched to */
	logRouteChange: function(name) {
		if (window.newrelic && !this.game.opts.disableTelemetry){
			// Record the current tab name so the charts look pretty in the NR UI.
			// Normally this is inferred by route changes, but we don't do that, so we
			// need to give the browser agent some hints

			// Set the `browserInteractionName` on BrowserInteraction events
			var interaction = window.newrelic.interaction();
			window.newrelic.setCurrentRouteName(name);
			interaction.save();

			// Make a new PageAction event
			this.logEvent("routeChange", { 'name': name });
		}
	}
});


/**
 * Server is a mediator between client and KGNet
 * It supports fetching data about saves, syncing using info, etc
 * 
 * Please see toolbar.jsx.js#WLogin widget for rendering part
 */

var Server = dojo.declare("classes.game.Server", null, {

	// Server datas
	//---->
	showMotd: true,
	/** @type {string} */
	motdTitle: null,
	/** @type {string} */
	motdContent: null,
	//<----

	/**
	 * Last known real-world b-coin price, used by hodl mode (game.opts.hodl).
	 */
	bcoinPrice: 63918,

	/** @type {GamePage} */
	game: null,
	/** @type {string} */
	motdContentPrevious: null,
	motdFreshMessage: false,

	//chiral stuff

	/**
	 * KGNet user profile
	 * Represents an active session, if not null, all XHR calls will be made
	 * using session cookies
	 * @type {{uid: string, id: string} & Record<string, any>}
	 */
	userProfile: null,
	/** @type {string} last chiral client state, kept as pretty-printed JSON for display */
	chiral: null,

	/**
	 * When was the last time save was uploaded to the cloud. (Unix timestamp)
	 * @type {number}
	 */
	lastBackup: null,

	/**
	 * Current client snapshot of the save data
	 * All operations with the cloud saves should return the save snapshot?
	 * @type {any}
	 */
	saveData: null,

	/**
	 * If KS settings are detected in the save, this will be set to true.
	 */
	isKSDetected: false,

	/** @param {GamePage} game */
	constructor: function(game){
		this.game = game;
	},

	/** @param {{uid: string, id: string} & Record<string, any>} userProfile */
	setUserProfile: function(userProfile){
		this.userProfile = userProfile;
	},

	/**
	 * Terminate the current KGNet session and clear local session state.
	 * Returns the jqXHR so callers can chain UI updates.
	 */
	logout: function(){
		var self = this;

		return this._xhr("/user/logout/", "POST", {}).always(function(){
			self.userProfile = null;
			self.saveData = null;
		});
	},

    getServerUrl: function(){
		if (this.game.isMobile()){
			return "https://kittensgame.com";
		}
		var host = window.location.hostname;
		var isLocalhost = window.location.protocol == "file:" || host == "localhost" || host == "127.0.0.1";
        if (isLocalhost && !this.game.isMobile()){
            //if you are running chilar locally you should know what you are doing
            return "http://localhost:7780";
        }
        return "https://kittensgame.com";
    },

	refresh: function(){
		var self = this;

		console.log("Loading server settings...");
		$.ajax({
			cache: false,
			url: "server.json",
			dataType: "json",
			success: function(json) {
				self.showMotd = json.showMotd;
				self.motdTitle = json.motdTitle;
				self.motdContent = json.motdContent;
			}
		}).done(function() {
			if (self.motdContentPrevious != self.motdContent) {
				self.motdContentPrevious = self.motdContent;
				self.motdFreshMessage = true;
			}
		}).fail(function(err) {
			console.log("Unable to parse server.json configuration:", err);
		});

		//-- fetch UID from KGNet if HTTP session is established ---
		if (!this.userProfile){
			this.syncUserProfile();
		}
		
	},

	/**
	 * Make an XHR request to KGNet server.
	 * Callers attach their own .done/.fail/.always to the returned jqXHR.
	 *
	 * @param {string} url - relative endpoint URL
	 * @param {"GET"|"POST"} [method] - defaults to "GET"
	 * @param {object} [data] - post data
	 * @returns {any} the jqXHR
	 */
	_xhr: function(url, method, data){
		var self = this;
		return $.ajax({
            cache: false,
            type: method || "GET",
            dataType: "JSON",
			url: this.getServerUrl() + url,
			xhrFields: {
				withCredentials: true
			},
			data: data
		}).fail(function(jqXHR, textStatus){
			console.error("KGNet request failed:", method || "GET", url, "status:", jqXHR.status, textStatus);
			if (jqXHR.status == 403){
				//the HTTP session is gone (expired or revoked), the cached profile no longer reflects reality
				self.setUserProfile(null);
			}
		});
	},

	/**
	 * Show a failed KGNet operation in the game log with a human-readable reason.
	 * 403 means the session expired; status 0 means the server could not be reached at all.
	 *
	 * @param {string} i18nKey - operation message with a {0} placeholder for the reason
	 * @param {*} jqXHR
	 */
	_notifyRequestError: function(i18nKey, jqXHR){
		var reason;
		if (jqXHR.status == 403){
			reason = $I("ui.kgnet.error.auth");
		} else if (jqXHR.status > 0){
			reason = $I("ui.kgnet.error.status", [jqXHR.status]);
		} else {
			reason = $I("ui.kgnet.error.network");
		}
		this.game.msg($I(i18nKey, [reason]), "alert");
	},

	/**
	 * Fetch user profile from the chiral server, 
	 * User must be logged in and session cookie should be set beforehead
	 */
	syncUserProfile: function(){
		var self = this;

		this._xhr("/user/", "GET", {}).done(function(resp){
			if (resp && resp.id){
				self.setUserProfile(resp);
				self.syncSaveData();
			}
		});
	},

	syncSaveData: function(){
		var self = this;
		return this._xhr("/kgnet/save/", "GET", {}).done(function(resp){
			self.saveData = resp;
		});
	},

	pushSave: function(){
		var self = this,
			game = this.game;

		if (game.isReadOnly()){
			return;
		}

		game.lastBackup = new Date().getTime();

		var saveData = this.game.save();
		this._xhr("/kgnet/save/upload/", "POST",
		{
			//pre-parsing guid to avoid checking it on the backend side
			guid: this.game.telemetry.guid,
			saveData: this.game.compressLZData(JSON.stringify(saveData, this.game.JSONreplacer), true),
			metadata: {
				calendar: {
					year: game.calendar.year,
					day: game.calendar.day
				}
			}
		}).done(function(resp){
			game.lastBackup = new Date().getTime();
			self.saveData = resp;
			self.game.msg($I("save.export.msg"));
		}).fail(function(jqXHR){
			self._notifyRequestError("save.export.fail", jqXHR);
		});
	},

	/**
	 * @param {string} guid - identifies which cloud save to update
	 * @param {{archived?: boolean, label?: string}} metadata
	 */
	pushSaveMetadata: function(guid, metadata){
		var self = this;
		if (this.game.isReadOnly()){
			return $.Deferred().reject().promise();
		}
		return this._xhr("/kgnet/save/update/", "POST",
		{
			//pre-parsing guid to avoid checking it on the backend side
			guid: guid,
			metadata: metadata
		}).done(function(resp){
			self.saveData = resp;
		}).fail(function(jqXHR){
			self._notifyRequestError("save.update.fail", jqXHR);
		});
	},

	/**
	 * Fetch your own cloud save without applying it anywhere (see also downloadPreview)
	 * loadSave() layers the "overwrite my game with it" part on top.
	 * @param {string} guid
	 * @returns {any} the jqXHR, resolving to {data: string, metadata?: object}
	 */
	downloadSave: function(guid){
		return this._xhr("/kgnet/save/" + guid + "/download/", "GET", {});
	},

	/**
	 * Fetch public save based on its shareId
	 * 
	 * @param {string} shareId
	 * @returns {any} the jqXHR, resolving to {data: string, metadata?: object}
	 */
	downloadPreview: function(shareId){
		return this._xhr("/preview/" + shareId + "/save/", "GET", {});
	},

	/**
	 * Public sharable URL that goes through KGNET and generates openhost preview card
	 * @param {string} shareId
	 */
	getPreviewUrl: function(shareId){
		//generate redirect url, backend will verify the host
		var returnPath = window.location.pathname.replace(/[^/]*$/, "");
		return this.getServerUrl() + "/preview/" + shareId + "?r=" + encodeURIComponent(returnPath);
	},

	/** @param {string} guid */
	loadSave: function(guid){
		var self = this;
		if (this.game.isReadOnly()){
			return;
		}
		this.downloadSave(guid).done(function(resp){
			if (!resp || !resp.data){
				console.error("unable to load game data", resp);
				self.game.msg($I("save.import.fail", [$I("ui.kgnet.error.nodata")]), "alert");
				return;
			}
			var data = resp.data;
			LCstorage["com.nuclearunicorn.kittengame.savedata"] = data;
			console.log("load successful?");

			self.game.load();
			self.game.msg($I("save.import.msg"));

			self.game.render();
		}).fail(function(jqXHR){
			self._notifyRequestError("save.import.fail", jqXHR);
		});
	},

	/**
	 * "hodl" mode price feed.
	 * Fetches the current real-world b-coin price and caches it in this.bcoinPrice
	 * (which is persisted in the save file). On any failure we simply keep the last
	 * known price, so the feature degrades gracefully when offline or rate-limited.
	 *
	 * Plain $.ajax, not _xhr: the latter sends credentials, which a wildcard CORS API rejects.
	 * 
	 * @param {(price: number) => void} [handler] - optional callback invoked with the fresh price
	 */
	fetchBcoinPrice: function(handler){
		var self = this;
		return $.ajax({
			cache: false,
			type: "GET",
			dataType: "json",
			url: "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"
		}).done(function(resp){
			var price = resp && resp.bitcoin && resp.bitcoin.usd;
			if (typeof price === "number" && price > 0){
				self.bcoinPrice = price;
				if (handler){
					handler(price);
				}
			}
		}).fail(function(err){
			console.log("Unable to fetch b-coin price, keeping last known value", self.bcoinPrice, err);
		});
	},

	/** @param {SaveData} saveData */
	save: function(saveData) {
		saveData.server = {
			motdContent: this.motdContent,
			bcoinPrice: this.bcoinPrice
		};
	},

	//TOOD: separate getting chiral client status and sending command to a separate component
	/** @param {string} command */
	sendCommand: function(command){
		var self = this;
		if (this.game.isReadOnly()){
			return;
		}
		this._xhr("/kgnet/chiral/game/command/", "POST", {
			command: command
		}).done(function(resp){
			if (resp.clientState){
                self.setChiral(resp);
			}
		});
	},

	setChiral: function(data){
		this.chiral = JSON.stringify(data, null, 2);
	}
});

/**
 * Undo Change state. Represents a change in one or multiple managers
 */
var UndoChange = dojo.declare("classes.game.UndoChange", null, {
	_static:{
		DEFAULT_TTL : 20
	},
	ttl: 0,
	/** @type {UndoEvent[]} */
	events: null,

	constructor: function(){
		this.events = [];
	},

	/**
	 * Adds an "event" (game-action) to the list of "things that will un-happen if you push the undo button."
	 * Note to the dev: We gotta come up with a shorter name for that list.
	 * 
	 * Usage:
	 * Call this function whenever the player performs an action that can be undone.
	 * Supply (as arguments) all the relevant data to reconstruct that action, or, if necessary, undo it.
	 * 
	 * @param {string} managerId	Which manager class will handle the relevant undo operation.
	 * 						Typically corresponds to which subsystem of the game is associated with that action.
	 * @param {any} data	Any relevant data to reconstruct the action to be undone.
	 * 					For example, if the action is "build 10 Log Houses," then the data would somehow specify
	 * 						that Log Houses are involved & that there are 10 of them.
	 * 					The UndoChange system doesn't understand the data here--it is specific to the associated manager.
	 * 					This allows each different manager to track all the data they care about & nothing more.
	 * @param {string} description	An i18n string containing a general human-language description of this undo action.
	 * 						The idea is that this would be displayed somewhere in the UI so the player will know
	 * 							what is being undone before they commit to undoing an action.
	 */
	addEvent: function(managerId, data, description){
		var event = {
			managerId: managerId,
			data: data,
			description: description
		};

		this.events.push(event);
	},

	/**
	 * Converts an event object into a short, human-language description of what it is.
	 * @param {UndoEvent} event	An object describing an event, like what would be created from the addEvent function.
	 * @returns {string}	If the event is valid, it's an i18n string which describes said event, ideally using concise language.
	 * 				If the event is not valid, it's a debug string which hopefully the devs can make use of.
	 */
	getEventDescription: function(event) {
		if (typeof(event) !== "object" || !event) {
			return "Error in getEventDescription: event is invalid.";
		}
		if (typeof(event.description) !== "string") {
			return "Error in getEventDescription: the event has no description defined.\nTell the developers it is from the \"" + event.managerId + "\" manager.";
		}
		//Else, the event exists & its description is a string.
		return event.description;
	}
});

/*
 * Effects metadata manager
 */
var EffectsManager = dojo.declare("com.nuclearunicorn.game.EffectsManager", null, {
	/** @type {GamePage} */
	game: null,

	/** @param {GamePage} game */
	constructor: function(game){
		this.game = game;
	},

	/**
	 * Derives display metadata for the resource-flavoured effects (`woodPerTick`,
	 * `catnipMax`, ...) by splitting the effect name into a resource prefix and a
	 * known suffix.
	 * @param {string} effectName
	 * @returns {EffectMeta | 0} 0 when the name matches no resource, which is the
	 *   signal for `getEffectMeta` to fall back to the statics table.
	 */
	effectMeta: function(effectName) {
		var game = this.game;
		for (var i = 0; i < game.resPool.resources.length; i++) {
			var res = game.resPool.resources[i];
			if (effectName.indexOf(res.name) == 0) {
				var resname = res.name;
				var restitle = res.title || resname;
				restitle = restitle.charAt(0).toUpperCase() + restitle.substring(1, restitle.length);
				var type = effectName.substring(resname.length, effectName.length);
				break;
			}
		}

		switch (true){
			/* Worker pseudoeffect */
			case type == "":
				return {
					//title to be displayed for effect, id if not defined
					title: restitle,
					//effect will be hidden if resource is not unlocked
					resName: resname,
					//value will be affected by opts.usePerSecondValues
					type: "perTick"
				};
			case type == "PerTick":
				return {
					title: restitle,
					resName: resname,
					type: "perTick"
				};
			case type == "PerTickRatio":
				return {
					title: $I("effectsMgr.type.resRatio", [restitle]),
					resName: resname,
					type: "ratio"
				};
			case type == "ConsumptionAmbassadors":
				return {
					title: $I("effectsMgr.type.villageConsumption", [restitle]),
					resName: resname,
					type: "perTick"
				};
			case type == "Max":
				return {
					title: $I("effectsMgr.type.resMax", [restitle]),
					resName: resname
				};
			case type == "MaxChallenge": //for when challenges change Max of resources; LDR to all other sources of Max
				return {
					title: $I("effectsMgr.type.resMax", [restitle]),
					resName: resname
				};
			case type == "Ratio":
				return {
					title: $I("effectsMgr.type.resRatio", [restitle]),
					resName: resname,
					type: "ratio"
				};
			case type == "DemandRatio":
				return {
					title: $I("effectsMgr.type.resDemandRatio", [restitle]),
					resName: resname,
					type: "ratio"
				};
			case (type == "PerTickBase" || type == "PerTickBaseSpace"):
				return {
					title: $I("effectsMgr.type.resProduction", [restitle]),
					resName: resname,
					type: "perTick"
				};
			case (type == "PerTickCon" || type == "PerTickAutoprod" || type == "PerTickProd" || type == "PerTickSpace" || type == "PerTickAutoprodSpace"):
				return {
					title: $I("effectsMgr.type.resConversion", [restitle]),
					resName: resname,
					type: "perTick"
				};
			case type == "CraftRatio":
				return {
					title: $I("effectsMgr.type.resCraftRatio", [restitle]),
					resName: resname,
					type: "ratio"
				};
			case type == "GlobalCraftRatio":
				return {
					title: $I("effectsMgr.type.resGlobalCraftRatio", [restitle]),
					resName: resname,
					type: "ratio"
				};
			case type == "MaxRatio":
				return {
					title: $I("effectsMgr.type.resMaxRatio", [restitle]),
					resName: resname,
					type: "ratio"
				};
			default:
				return 0;
		}
	},

	statics: {
		//Every effect that `effectMeta` can't derive from a resource name needs an
		//entry here, or it falls through to a bare `{title: effectName}`.
		/** @type {Record<string, EffectMeta>} */
		effectMeta: {
			// Specials meta of resources
			"catnipJobRatio" : {
				title: $I("effectsMgr.statics.catnipJobRatio.title"),
				resName: "catnip",
				type: "ratio"
			},

			"catnipDemandWorkerRatioGlobal": {
				title: $I("effectsMgr.statics.catnipDemandWorkerRatioGlobal.title"),
				resName: "catnip",
				type: "ratio"
			},

			"woodJobRatio" : {
				title: $I("effectsMgr.statics.woodJobRatio.title"),
				resName: "wood",
				type: "ratio"
			},

			"manpowerJobRatio" : {
				title: $I("effectsMgr.statics.manpowerJobRatio.title"),
				resName: "manpower",
				type: "ratio"
			},

			"coalRatioGlobal" : {
				title: $I("effectsMgr.statics.coalRatioGlobal.title"),
				resName: "coal",
				type: "ratio",
				calculation: "nonProportional"
			},

			"coalRatioGlobalReduction" : {
				title: $I("effectsMgr.statics.coalRatioGlobalReduction.title"),
				resName: "coal",
				type: "ratio"
			},

			"oilReductionRatio" : {
				title: $I("effectsMgr.statics.oilReductionRatio.title"),
				type: "ratio"
			},

			"catpowerReductionRatio" : {
				title: $I("effectsMgr.statics.catpowerReductionRatio.title"),
				type: "ratio"
			},

			"embassiesPerAmbassadorSlot": {
				type: "hidden"
			},

			//kittens

			"maxKittens" : {
				title: $I("effectsMgr.statics.maxKittens.title")
			},

			"maxKittensRatio" : {
				title: $I("effectsMgr.statics.maxKittensRatio.title"),
				type: "ratio"
			},

			"simScalingRatio" : {
				title: $I("effectsMgr.statics.simScalingRatio.title"),
				type: "ratio"
			},

			"antimatterProduction": {
				title: $I("effectsMgr.statics.antimatterProduction.title"),
				type: "perYear"
			},

			"temporalFluxProduction": {
				title: $I("effectsMgr.statics.temporalFluxProduction.title"),
				type: "perYear"
			},

			"temporalFluxProductionChronosphere": {
				title: $I("effectsMgr.statics.temporalFluxProductionChronosphere.title"),
				type: "perYear"
			},

			// Miscellaneous

			"observatoryRatio" : {
                title: $I("effectsMgr.statics.observatoryRatio.title"),
                type: "ratio"
            },

			"magnetoBoostRatio" : {
				title: $I("effectsMgr.statics.magnetoBoostRatio.title"),
				resName: "oil",				//this is sort of hack to prevent early spoiler on magnetos
				type: "ratio"
			},

			"skillXP" : {
				title: $I("effectsMgr.statics.skillXP.title"),
				type: "perTick"
			},

			"refineRatio": {
				title: $I("effectsMgr.statics.refineRatio.title"),
				type: "ratio"
			},

			"craftRatio": {
				title: $I("effectsMgr.statics.craftRatio.title"),
				type: "ratio"
			},

			"happiness": {
				title: $I("effectsMgr.statics.happiness.title")
			},

			"unhappinessRatio": {
				title: $I("effectsMgr.statics.unhappinessRatio.title"),
				type: "ratio"
			},

			"tradeRatio": {
				title: $I("effectsMgr.statics.tradeRatio.title"),
				type: "ratio"
			},
			"tradeVolume": {
				title: $I("effectsMgr.statics.tradeVolume.title"),
				type: "ratio"
			},
			"standingRatio": {
				title: $I("effectsMgr.statics.standingRatio.title"),
				type: "ratio"
			},
			//Ambassador effects
			"embassyEffectCap": {
				title: $I("effectsMgr.statics.embassyEffectCap.title"),
				type: "ratio"
			},
			"tradeBlueprintChance": {
				title: $I("effectsMgr.statics.tradeBlueprintChance.title"),
				type: "ratio"
			},
			"tradeSpiceChance": {
				title: $I("effectsMgr.statics.tradeSpiceChance.title"),
				type: "ratio"
			},
			"tradeNormalResChance": {
				title: $I("effectsMgr.statics.tradeNormalResChance.title"),
				type: "ratio"
			},
			"ambassadorBoostPerRank": {
				title: $I("effectsMgr.statics.jobBoostPerRank.title", [$I("village.job.ambassador")]),
				type: "ratio"
			},

			"resStasisRatio": {
				title: $I("effectsMgr.statics.resStasisRatio.title"),
				type: "ratio"
			},

			"beaconRelicsPerDay": {
				title: $I("effectsMgr.statics.beaconRelicsPerDay.title"),
				type: "perDay"
			},

			"relicPerDay": {
				title: $I("effectsMgr.statics.relicPerDay.title"),
				type: "perDay"
			},

			"routeSpeed": {
				title: $I("effectsMgr.statics.routeSpeed.title"),
				type: "fixed"
			},

			"festivalRatio":{
				title: $I("effectsMgr.statics.festivalRatio.title"),
				type: "ratio"
			},

			"festivalArrivalRatio":{
				title: $I("effectsMgr.statics.festivalArrivalRatio.title"),
				type: "ratio"
			},

			// energy

			"energyProduction": {
				title: $I("effectsMgr.statics.energyProduction.title"),
				type: "energy"
			},
			"energyConsumption": {
				title: $I("effectsMgr.statics.energyConsumption.title"),
				type: "energy",
				calculation: "nonProportional"
            },

			"energyProductionRatio": {
				title: $I("effectsMgr.statics.energyProductionRatio.title"),
				type: "ratio"
			},
			"energyConsumptionRatio": {
				title: $I("effectsMgr.statics.energyConsumptionRatio.title"),
				type: "ratio"
			},
			"energyConsumptionIncrease": {
				title: $I("effectsMgr.statics.energyConsumptionIncrease.title"),
				type: "ratio"
            },

			//production

            "productionRatio" : {
                title: $I("effectsMgr.statics.productionRatio.title"),
                type: "ratio"
            },

            "magnetoRatio" : {
                title: $I("effectsMgr.statics.magnetoRatio.title"),
                type: "ratio"
            },

            "spaceRatio" : {
				title: $I("effectsMgr.statics.spaceRatio.title"),
				type: "ratio"
			},

			"prodTransferBonus": {
				title: $I("effectsMgr.statics.prodTransferBonus.title"),
				type: "ratio"
			},

            //starEvent

            "starEventChance" : {
                title: $I("effectsMgr.statics.starEventChance.title"),
                type: "ratio"
            },

            "starAutoSuccessChance" : {
                title: $I("effectsMgr.statics.starAutoSuccessChance.title"),
                type: "ratio"
            },

            //in the tab workshop
            "lumberMillRatio" : {
                title: $I("effectsMgr.statics.lumberMillRatio.title"),
                type: "ratio"
            },

            "barnRatio" : {
                title: $I("effectsMgr.statics.barnRatio.title"),
                type: "ratio"
            },

            "warehouseRatio" : {
                title: $I("effectsMgr.statics.warehouseRatio.title"),
                type: "ratio"
            },

            "acceleratorRatio" : {
                title: $I("effectsMgr.statics.acceleratorRatio.title"),
                type: "ratio"
            },

            "harborRatio" : {
                title: $I("effectsMgr.statics.harborRatio.title"),
                type: "ratio"
            },

            "harborCoalRatio" : {
                title: $I("effectsMgr.statics.harborCoalRatio.title"),
                type: "ratio"
            },

            "hunterRatio" : {
                title: $I("effectsMgr.statics.hunterRatio.title"),
                type: "ratio"
            },

            "solarFarmRatio" : {
                title: $I("effectsMgr.statics.solarFarmRatio.title"),
                type: "ratio"
            },

            "shipLimit" : {
                title: $I("effectsMgr.statics.shipLimit.title"),
                type: "ratio"
            },

            "hutPriceRatio" : {
                title: $I("effectsMgr.statics.hutPriceRatio.title"),
                type: "ratio"
            },

            "coalSuperRatio" : {
                title: $I("effectsMgr.statics.coalSuperRatio.title"),
                type: "ratio"
            },

            "smelterRatio" : {
                title: $I("effectsMgr.statics.smelterRatio.title"),
                type: "ratio"
            },

            "calcinerRatio" : {
                title: $I("effectsMgr.statics.calcinerRatio.title"),
                type: "ratio"
            },

            "calcinerSteelRatio" : {
                title: $I("effectsMgr.statics.calcinerSteelRatio.title"),
                type: "ratio"
            },

            "calcinerSteelCraftRatio" : {
                title: $I("effectsMgr.statics.calcinerSteelCraftRatio.title"),
                type: "ratio"
            },

            "calcinerSteelReactorBonus" : {
                title: $I("effectsMgr.statics.calcinerSteelReactorBonus.title"),
                type: "ratio"
            },

            "libraryRatio" : {
                title: $I("effectsMgr.statics.libraryRatio.title"),
                type: "ratio"
            },

            "hydroPlantRatio" : {
                title: $I("effectsMgr.statics.hydroPlantRatio.title"),
                type: "ratio"
            },

            "spaceScienceRatio" : {
                title: $I("effectsMgr.statics.spaceScienceRatio.title"),
                type: "ratio"
            },

            "oilWellRatio" : {
                title: $I("effectsMgr.statics.oilWellRatio.title"),
                type: "ratio"
            },

            "unicornsGlobalRatio" : {
                title: $I("effectsMgr.statics.unicornsGlobalRatio.title"),
                type: "ratio"
            },

            "biofuelRatio" : {
                title: $I("effectsMgr.statics.biofuelRatio.title"),
                type: "ratio"
            },

            "cadBlueprintCraftRatio" : {
                title: $I("effectsMgr.statics.cadBlueprintCraftRatio.title"),
                type: "ratio"
            },

            "skillMultiplier" : {
                title: $I("effectsMgr.statics.skillMultiplier.title"),
                type: "ratio"
            },

            "masterSkillMultiplier" : {
                title: $I("effectsMgr.statics.masterSkillMultiplier.title"),
                type: "ratio"
            },

            "uraniumRatio" : {
                title: $I("effectsMgr.statics.uraniumRatio.title"),
                type: "ratio"
            },

            "reactorEnergyRatio" : {
                title: $I("effectsMgr.statics.reactorEnergyRatio.title"),
                type: "ratio"
            },

			"reactorThoriumPerTick" : {
                title: $I("effectsMgr.statics.reactorThoriumPerTick.title"),
                type: "perTick"
            },

            "starchartGlobalRatio" : {
                title: $I("effectsMgr.statics.starchartGlobalRatio.title"),
                type: "ratio"
            },

            "satnavRatio" : {
                title: $I("effectsMgr.statics.satnavRatio.title"),
                type: "ratio"
            },

            "broadcastTowerRatio" : {
                title: $I("effectsMgr.statics.broadcastTowerRatio.title"),
                type: "ratio"
            },

            "lunarOutpostRatio" : {
                title: $I("effectsMgr.statics.lunarOutpostRatio.title"),
                type: "ratio"
            },

            "crackerRatio" : {
                title: $I("effectsMgr.statics.crackerRatio.title"),
                type: "ratio"
            },

            "factoryRefineRatio" : {
                title: $I("effectsMgr.statics.factoryRefineRatio.title"),
                type: "ratio"
            },

            "timeRatio" :  {
                title: $I("effectsMgr.statics.timeRatio.title"),
                type: "ratio"
            },

			"temporalParadoxChance": {
				type: "hidden"
			},

            "temporalParadoxVoid" :  {
                title: $I("effectsMgr.statics.temporalParadoxVoid.title"),
                type: "perDay"
            },

            "temporalParadoxDay" :  {
                title: $I("effectsMgr.statics.temporalParadoxDay.title"),
                type: "fixed"
            },

            "temporalParadoxDayBonus" :  {
                title: $I("effectsMgr.statics.temporalParadoxDayBonus.title"),
                type: "fixed"
            },

			"unicornsRatioReligion" :  {
                title: $I("effectsMgr.statics.unicornsRatioReligion.title"),
                type: "ratio"
            },

			"riftChance" :  {
                title: $I("effectsMgr.statics.riftChance.title"),
                type: "ratio"
            },

			"ivoryMeteorChance" :  {
                title: $I("effectsMgr.statics.ivoryMeteorChance.title"),
                type: "ratio"
            },

            "ivoryMeteorRatio" :  {
                title: $I("effectsMgr.statics.ivoryMeteorRatio.title"),
                type: "ratio"
            },

			"alicornChance" :  {
                title: $I("effectsMgr.statics.alicornChance.title"),
                type: "ratio"
            },

			"tcRefineRatio" :  {
                title: $I("effectsMgr.statics.tcRefineRatio.title"),
                type: "ratio"
            },

			"corruptionRatio" :  {
                title: $I("effectsMgr.statics.corruptionRatio.title"),
                type: "ratio"
            },

			"cultureMaxRatioBonus" :  {
                title: $I("effectsMgr.statics.cultureMaxRatioBonus.title"),
                type: "ratio"
            },

			"faithRatioReligion" :  {
                title: $I("effectsMgr.statics.faithRatioReligion.title"),
                type: "ratio"
            },

            "solarRevolutionLimit" : {
                title: $I("effectsMgr.statics.solarRevolutionLimit.title"),
                type: "ratio"
            },

            "solarRevolutionRatio" : {
                title: $I("effectsMgr.statics.solarRevolutionRatio.title"),
                type: "ratio"
            },

            "faithSolarRevolutionBoost" : {
                title: $I("effectsMgr.statics.faithSolarRevolutionBoost.title"),
                type: "ratio"
            },

			"relicRefineRatio" :  {
                title: $I("effectsMgr.statics.relicRefineRatio.title"),
                type: "ratio"
            },

			"blsLimit" :  {
                title: $I("effectsMgr.statics.blsLimit.title"),
                type: "integerRatio"
            },

			"globalResourceRatio" :  {
                title: $I("effectsMgr.statics.globalResourceRatio.title"),
                type: "ratio"
            },

            "timeImpedance" :  {
                title: $I("effectsMgr.statics.timeImpedance.title"),
                type: "fixed"
            },

            "shatterTCGain" :  {
                title: $I("effectsMgr.statics.shatterTCGain.title"),
                type: "ratio"
            },

            "rrRatio" :  {
                title: $I("effectsMgr.statics.rrRatio.title"),
                type: "ratio"
            },

            "shatterYearBoost":{
                title: $I("effectsMgr.statics.shatterYearBoost.title")
            },

			"priceRatio" :  {
                title: $I("effectsMgr.statics.priceRatio.title"),
                type: "ratio"
            },

			"kittenGrowthRatio" :  {
                title: $I("effectsMgr.statics.kittenGrowthRatio.title"),
                type: "ratio"
            },

			"t1CraftRatio" :  {
                title: $I("effectsMgr.statics.t1CraftRatio.title"),
                type: "fixed"
            },

			"t2CraftRatio" :  {
                title: $I("effectsMgr.statics.t2CraftRatio.title"),
                type: "fixed"
            },

			"t3CraftRatio" :  {
                title: $I("effectsMgr.statics.t3CraftRatio.title"),
                type: "fixed"
            },

			"t4CraftRatio" :  {
                title: $I("effectsMgr.statics.t4CraftRatio.title"),
                type: "fixed"
            },

			"t5CraftRatio" :  {
                title: $I("effectsMgr.statics.t5CraftRatio.title"),
                type: "fixed"
            },
			"queueCap": {
				title: $I("effectsMgr.statics.queueCap"),
				type: "fixed"
			},
			"queueCapRatio": {
				title: $I("effectsMgr.statics.queueCapRatio"),
				type: "ratio"
			},
			//Spaceports
			"moonBaseStorageBonus": {
				title: $I( "effectsMgr.statics.moonBaseStorageBonus.title" ),
				type: "ratio"
			},
			"planetCrackerStorageBonus": {
				title: $I( "effectsMgr.statics.planetCrackerStorageBonus.title" ),
				type: "ratio"
			},
			"cryostationStorageBonus": {
				title: $I( "effectsMgr.statics.cryostationStorageBonus.title" ),
				type: "ratio"
			},
			// cycleEffects
			"spaceElevator-prodTransferBonus": {
                title: $I("effectsMgr.statics.spaceElevator-prodTransferBonus.title"),
                type: "ratio"
            },

			"sattelite-starchartPerTickBaseSpace": {
                title: $I("effectsMgr.statics.sattelite-starchartPerTickBaseSpace.title"),
                type: "ratio"
            },

			"sattelite-observatoryRatio": {
                title: $I("effectsMgr.statics.sattelite-observatoryRatio.title"),
                type: "ratio"
            },

			"spaceStation-scienceRatio": {
                title: $I("effectsMgr.statics.spaceStation-scienceRatio.title"),
                type: "ratio"
            },

			"moonOutpost-unobtainiumPerTickSpace": {
                title: $I("effectsMgr.statics.moonOutpost-unobtainiumPerTickSpace.title"),
                type: "ratio"
            },

			"planetCracker-uraniumPerTickSpace": {
                title: $I("effectsMgr.statics.planetCracker-uraniumPerTickSpace.title"),
                type: "ratio"
            },

			"hydrofracturer-oilPerTickAutoprodSpace": {
                title: $I("effectsMgr.statics.hydrofracturer-oilPerTickAutoprodSpace.title"),
                type: "ratio"
            },

			"researchVessel-starchartPerTickBaseSpace": {
                title: $I("effectsMgr.statics.researchVessel-starchartPerTickBaseSpace.title"),
                type: "ratio"
            },

			"sunlifter-energyProduction": {
                title: $I("effectsMgr.statics.sunlifter-energyProduction.title"),
                type: "ratio"
            },

                        "cryostation-woodMax": {
                title: $I("effectsMgr.statics.cryostation-woodMax.title"),
                type: "ratio"
            },

                        "cryostation-mineralsMax": {
                title: $I("effectsMgr.statics.cryostation-mineralsMax.title"),
                type: "ratio"
            },

                        "cryostation-ironMax": {
                title: $I("effectsMgr.statics.cryostation-ironMax.title"),
                type: "ratio"
            },

                        "cryostation-coalMax": {
                title: $I("effectsMgr.statics.cryostation-coalMax.title"),
                type: "ratio"
            },

                        "cryostation-uraniumMax": {
                title: $I("effectsMgr.statics.cryostation-uraniumMax.title"),
                type: "ratio"
            },

                        "cryostation-titaniumMax": {
                title: $I("effectsMgr.statics.cryostation-titaniumMax.title"),
                type: "ratio"
            },

                        "cryostation-oilMax": {
                title: $I("effectsMgr.statics.cryostation-oilMax.title"),
                type: "ratio"
            },

                        "cryostation-unobtainiumMax": {
                title: $I("effectsMgr.statics.cryostation-unobtainiumMax.title"),
                type: "ratio"
            },

			"spaceBeacon-starchartPerTickBaseSpace": {
                title: $I("effectsMgr.statics.spaceBeacon-starchartPerTickBaseSpace.title"),
                type: "ratio"
            },

			"hydroponics-catnipRatio": {
                title: $I("effectsMgr.statics.hydroponics-catnipRatio.title"),
                type: "ratio"
            },

                        "hrHarvester-energyProduction": {
                title: $I("effectsMgr.statics.hrHarvester-energyProduction.title"),
                type: "ratio"
            },

                        "entangler-gflopsConsumption": {
                title: $I("effectsMgr.statics.entangler-gflopsConsumption.title"),
                type: "ratio"
            },
			"hrProgress": {
				title: $I("effectsMgr.statics.entangler-hrProgress.title"),
				type: "ratio",
				calculation: "nonProportional"
			},

			"aiLevel" :  {
				title: $I("effectsMgr.statics.aiLevel.title"),
				type: "fixed",
				calculation: "nonProportional"
			},

			"gflopsConsumption" :  {
				title: $I("effectsMgr.statics.gflopsConsumption.title"),
				type: "perTick"
			},

			"hashrate" :  {
				title: $I("effectsMgr.statics.hashrate.title"),
				type: "fixed",
				calculation: "nonProportional"
			},

			"nextHashLevelAt" :  {
				title: $I("effectsMgr.statics.nextHashLevelAt.title"),
				type: "fixed",
				calculation: "nonProportional"
			},

			"hashRateLevel" :  {
				title: $I("effectsMgr.statics.hashrateLevel.title"),
				type: "fixed",
				calculation: "nonProportional"
			},

			"corruptionBoostRatio": {
				title: $I("effectsMgr.statics.corruptionBoostRatio.title"),
				type: "ratio"
			},

			"corruptionBoostRatioChallenge": {
				title: $I("effectsMgr.statics.corruptionBoostRatioChallenge.title"),
				type: "ratio"
			},

			"bskSattelitePenalty" : {
				title: $I("effectsMgr.statics.bskSattelitePenalty.title"),
				type: "ratio"
			},

			"blsCorruptionRatio": {
				title: $I("effectsMgr.statics.blsCorruptionRatio.title"),
				type: "ratio"
			},

			"baseMetalMaxRatio": {
				title: $I("effectsMgr.statics.baseMetalMaxRatio.title"),
				type: "ratio"
			},

			"scienceMaxCompendia": {
				title: $I("effectsMgr.statics.scienceMaxCompendia.title"),
				type: "fixed"
			},

			"uplinkDCRatio": {
				title: $I("effectsMgr.statics.uplinkDCRatio.title"),
				type: "ratio"
			},

			"uplinkLabRatio": {
				title: $I("effectsMgr.statics.uplinkLabRatio.title"),
				type: "ratio"
			},

			"dataCenterAIRatio": {
				title: $I("effectsMgr.statics.dataCenterAIRatio.title"),
			},

			"compendiaTTBoostRatio": {
				title: $I("effectsMgr.statics.compendiaTTBoostRatio.title"),
				type: "ratio"
			},

			"blackLibraryBonus": {
				title: $I("effectsMgr.statics.blackLibraryBonus.title"),
				type: "ratio"
			},

			"solarFarmSeasonRatio": {
				title: $I("effectsMgr.statics.solarFarmSeasonRatio.title"),
				type: "fixed"
			},

			"tectonicBonus": {
				title: $I("effectsMgr.statics.tectonicBonus.title"),
				type: "ratio"
			},

			"umbraBoostRatio": {
				title: $I("effectsMgr.statics.umbraBoostRatio.title"),
				type: "ratio"
			},

			"eludiumAutomationBonus": {
				title: $I("effectsMgr.statics.eludiumAutomationBonus.title"),
				type: "ratio"
			},

			"heatMax": {
				title: $I("effectsMgr.statics.heatMax.title"),
				type: "ratio"
			},

			"heatPerTick": {
				title: $I("effectsMgr.statics.heatPerTick.title"),
				type: "perTick"
			},

			"heatMaxExpansion": {
				title: $I("effectsMgr.statics.heatMaxExpansion.title"),
				type: "fixed",
				calculation: "nonProportional"
			},

			"voidResonance": {
				title: $I("effectsMgr.statics.voidResonance.title"),
				type: "ratio"
			},

			"terraformingMaxKittensRatio": {
				title: $I("effectsMgr.statics.terraformingMaxKittens.title"),
				type: "ratio",
				calculation: "nonProportional"
			},
			//age 1 policy effects
			"happinessKittenProductionRatio": {
				title: $I("effectsMgr.statics.happinessKittenProductionRatio.title"),
				type: "ratio"
			},
			"cultureFromManuscripts": {
				title: $I("effectsMgr.statics.cultureFromManuscripts.title"),
				type: "ratio"
			},
			"manuscriptParchmentCost": {
				title: $I("effectsMgr.statics.manuscriptCost.title", [$I("resources.parchment.title")]),
				type: "fixed"
			},
			"manuscriptCultureCost": {
				title: $I("effectsMgr.statics.manuscriptCost.title",[$I("resources.culture.title")]),
				type: "fixed"
			},
			//age 2 policy effects
			"rankLeaderBonusConversion": {
				title: $I("effectsMgr.statics.rankLeaderBonusConversion.title"),
                type: "ratio"
			},
			"boostFromLeader": {
                title: $I("effectsMgr.statics.boostFromLeader.title"),
                type: "ratio"
			},
			//age 3 policy effects
			"goldCostReduction": {
                title: $I("effectsMgr.statics.goldCostReduction.title"),
                type: "ratio"
			},
			"factoryCostReduction":{
                title: $I("effectsMgr.statics.factoryCostReduction.title"),
                type: "ratio"
			},
			"logHouseCostReduction":{
                title: $I("effectsMgr.statics.logHouseCostReduction.title"), //yes, it is log house!
                type: "ratio"
			},
			"communismProductionBonus":{
                title: $I("effectsMgr.statics.communismProductionBonus.title"),
                type: "ratio"
			},
			//age 4 policy effects
			"technocracyScienceCap":{
                title: $I("effectsMgr.statics.technocracyScienceCap.title"),
                type: "ratio"
			},
			//age 5 policy effects
			"aiCoreProductivness":{
                title: $I("effectsMgr.statics.aiCoreProductivity.title"),
                type: "ratio"
			},
			"aiCoreUpgradeBonus":{
				title: $I("effectsMgr.statics.aiCoreUpgradeBonus.title"),
				type: "ratio"
			},
			"blsProductionBonus":{
                title: $I("effectsMgr.statics.blsProductionBonus.title"),
                type: "ratio"
			},
			"leviathansEnergyModifier":{
                title: $I("effectsMgr.statics.leviathansEnergyModifier.title"),
                type: "ratio"
			},
			"holyGenocideBonus":{
                title: $I("effectsMgr.statics.holyGenocideBonus.title"),
                type: "ratio"
			},
            //foreign policy effects
            "tradeCatpowerDiscount":{
                title: $I("effectsMgr.statics.tradeCatpowerDiscount.title"),
                type: "fixed"
            },
            "tradeGoldDiscount":{
                title: $I("effectsMgr.statics.tradeGoldDiscount.title"),
                type: "fixed"
            },
            "zebraRelationModifier":{
                title: $I("effectsMgr.statics.zebraRelationModifier.title"),
                type: "fixed"
            },
            "nonZebraRelationModifier":{
                title: $I("effectsMgr.statics.nonZebraRelationModifier.title"),
                type: "fixed"
            },
            "sharedKnowledgeBonus":{
                title: $I("effectsMgr.statics.sharedKnowledgeBonus.title"),
                type: "ratio"
            },
            "culturalExchangeBonus":{
                title: $I("effectsMgr.statics.culturalExchangeBonus.title"),
                type: "ratio"
            },
            "embassyCostReduction":{
                title: $I("effectsMgr.statics.embassyCostReduction.title"),
                type: "ratio"
            },
            "onAHillCultureCap":{
                title: $I("effectsMgr.statics.onAHillCultureCap.title"),
                type: "ratio"
            },
            "satelliteSynergyBonus":{
                title: $I("effectsMgr.statics.satelliteSynergyBonus.title"),
                type: "ratio"
            },
            "globalRelationsBonus":{
            title: $I("effectsMgr.statics.globalRelationsBonus.title"),
                type: "fixed"
            },
			"harborLimitRatioPolicy":{
				title: $I("effectsMgr.statics.harborLimitRatioPolicy.title"),
				type: "ratio"
			},
			"neutralRaceEmbassyStanding": {
				title: $I("effectsMgr.statics.neutralRaceEmbassyStanding.title"),
				type: "ratio"
			},
			"raceSpecificStanding": { //Used only in tooltips to communicate with the player (has no gameplay effect)
				title: $I("effectsMgr.statics.raceSpecificStanding.title"),
				type: "ratio"
			},
			"calcinerSteelRatioBonus":{
				title: $I("effectsMgr.statics.calcinerSteelRatioBonus.title"),
				type: "ratio"
			},
			"magnetoBoostBonusPolicy":{
				title: $I("effectsMgr.statics.magnetoBoostBonusPolicy.title"),
				type: "ratio"
			},
			"faithFromManuscripts":{
				title: $I("effectsMgr.statics.faithFromManuscripts.title"),
                type: "ratio" 
			},
			"quarrySlabCraftBonus":{
				title: $I("effectsMgr.statics.quarrySlabCraftBonus.title"),
                type: "ratio" 
			},
			"zigguratTempleEffectPolicy":{
				title: $I("effectsMgr.statics.zigguratTempleEffectPolicy.title"),
				type: "ratio" 
			},
			"refinePolicyRatio":{
				title: $I("effectsMgr.statics.refinePolicyRatio.title"),
				type: "ratio"
			},
			"biolabEnergyRatio":{
				title: $I("effectsMgr.statics.biolabEnergyRatio.title"),
				type: "ratio"
			},
			"breweryPolicyManpowerRatio":{
				title: $I("effectsMgr.statics.breweryPolicyManpowerRatio.title"),
				type: "ratio"
			},
			"biolabBiofuelScienceMaxRatio": {
				title: $I("effectsMgr.statics.biolabBiofuelScienceMaxRatio.title"),
				type: "ratio"
			},
			"religionUpgradesDiscount":{
				title: $I("effectsMgr.statics.religionUpgradesDiscount.title"),
				type: "ratio"
			},
			"nagaBlueprintTradeChance":{
				title: $I("effectsMgr.statics.nagaBlueprintTradeChance.title"),
				type: "ratio"
			},			
			"starchartPolicyRatio":{
				title: $I("effectsMgr.statics.starchartPolicyRatio.title"),
				type: "ratio"
			},
			"mintIvoryRatio": {
				title: $I("effectsMgr.statics.mintIvoryRatio.title"),
				type: "ratio"
			},
			"huntCatpowerDiscount": {
				title: $I("effectsMgr.statics.huntCatpowerDiscount.title"),
				type: "fixed"
			},
            //philosophy
            "luxuryDemandRatio":{
                title: $I("effectsMgr.statics.luxuryDemandRatio.title"),
                type: "ratio"
            },
			"breweryConsumptionRatio":{
                title: $I("effectsMgr.statics.breweryConsumptionRatio.title"),
                type: "ratio"
			},
            "luxuryHappinessBonus":{
                title: $I("effectsMgr.statics.luxuryHappinessBonus.title"),
                type: "fixed"
            },
            "rationalityBonus":{
                title: $I("effectsMgr.statics.rationalityBonus.title"),
                type: "ratio"
            },
        	"mysticismBonus":{
        	    title: $I("effectsMgr.statics.mysticismBonus.title"),
               type: "ratio"
            },
			"festivalLuxuryConsumptionRatio":{
            	title: $I("effectsMgr.statics.festivalLuxuryConsumptionRatio.title"),
            	type: "ratio"
			},"consumableLuxuryHappiness":{
                title: $I("effectsMgr.statics.consumableLuxuryHappiness.title"),
                type: "fixed"
			},
			 "hapinnessConsumptionRatio":{
                title: $I("effectsMgr.statics.hapinnessConsumptionRatio.title"),
                type: "ratio"
			},
			 "mintRatio":{
                title: $I("effectsMgr.statics.mintRatio.title"),
                type: "ratio"
			},
             //environment policy
            "environmentMineralBonus":{
                title: $I("effectsMgr.statics.environmentMineralBonus.title"),
                type: "ratio"
            },
            "environmentWoodBonus":{
				title: $I("effectsMgr.statics.environmentWoodBonus.title"),
				type: "ratio"
            },
            "environmentHappinessBonus":{
                title: $I("effectsMgr.statics.environmentHappinessBonus.title"),
                type: "fixed"
            },
            "environmentUnhappiness":{
                title: $I("effectsMgr.statics.environmentUnhappiness.title"),
                type: "fixed"
            },
            "environmentFactoryCraftBonus":{
				title: $I("effectsMgr.statics.environmentFactoryCraftBonus.title"),
				type: "ratio"
			},
            "coalPolicyRatio":{
				title: $I("effectsMgr.statics.coalPolicyRatio.title"),
				type: "ratio"
            },
            "ironPolicyRatio":{
				title: $I("effectsMgr.statics.ironPolicyRatio.title"),
				type: "ratio"
            },
            "titaniumPolicyRatio":{
				title: $I("effectsMgr.statics.titaniumPolicyRatio.title"),
				type: "ratio"
            },
            "faithPolicyRatio":{
				title: $I("effectsMgr.statics.faithPolicyRatio.title"),
				type: "ratio"
            },
            "unobtainiumPolicyRatio":{
				title: $I("effectsMgr.statics.unobtainiumPolicyRatio.title"),
				type: "ratio"
            },
			"antimatterPolicyRatio":{
				title: $I("effectsMgr.statics.antimatterPolicyRatio.title"),
				type: "ratio"
			},
            "sciencePolicyRatio":{
				title: $I("effectsMgr.statics.sciencePolicyRatio.title"),
				type: "ratio"
            },
            "culturePolicyRatio":{
				title: $I("effectsMgr.statics.culturePolicyRatio.title"),
				type: "ratio"
            },
            "mineralsPolicyRatio":{
				title: $I("effectsMgr.statics.mineralsPolicyRatio.title"),
				type: "ratio"
            },
			"oilPolicyRatio":{
				title: $I("effectsMgr.statics.oilPolicyRatio.title"),
				type: "ratio"
            },
            "woodPolicyRatio":{
				title: $I("effectsMgr.statics.woodPolicyRatio.title"),
				type: "ratio"
            },
            "goldPolicyRatio":{
				title: $I("effectsMgr.statics.goldPolicyRatio.title"),
				type: "ratio"
			},
			//Necrocorn-related Policy effects
			"smallDebtPunishmentExemption": {
				title: $I("effectsMgr.statics.smallDebtPunishmentExemption.title"),
				type: "fixed"
			},
			"repayDebtOnNecrocornGeneration": {
				title: $I("effectsMgr.statics.repayDebtOnNecrocornGeneration.title"),
				type: "fixed"
			},
			"feedEldersEfficiencyRatio": {
				title: $I("effectsMgr.statics.feedEldersEfficiencyRatio.title"),
				type: "ratio"
			},
			"necrocornCorruptionInterference": {
				title: $I("effectsMgr.statics.necrocornCorruptionInterference.title"),
				type: "ratio"
			},
			"pactNecrocornUpfrontCost": {
				title: $I("effectsMgr.statics.necrocornUpfrontCost.title"),
				type: "fixed"
			},
			//challenges
			"springCatnipRatio": {
				title: $I("effectsMgr.statics.springCatnipRatio.title"),
				type: "ratio"
			},
            "summerSolarFarmRatio": {
                title: $I("effectsMgr.statics.summerSolarFarmRatio.title"),
				type: "ratio"
            },
            "shatterCostReduction": {
                title: $I("effectsMgr.statics.shatterCostReduction.title"),
                type: "ratio"
			},
            "temporalPressCap": {
                title: $I("effectsMgr.statics.temporalPressCap.title"),
                type: "fixed"
			},
            "heatEfficiency": {
                title: $I("effectsMgr.statics.heatEfficiency.title"),
                type: "ratio"
			},
			"heatCompression":{
                title: $I("effectsMgr.statics.heatCompression.title"),
                type: "ratio"
			},
            "shatterCostIncreaseChallenge": {
                title: $I("effectsMgr.statics.shatterCostIncreaseChallenge.title"),
                type: "ratio"
			},
			"coldChance": {
                title: $I("effectsMgr.statics.coldChance.title"),
                type: "ratio"
			},
			"coldHarshness": {
                title: $I("effectsMgr.statics.coldHarshness.title"),
                type: "ratio"
			},
			"kittenLaziness": {
                title: $I("effectsMgr.statics.kittenLaziness.title"),
                type: "ratio"
			},
			"shatterVoidCost":{
                title: $I("effectsMgr.statics.shatterVoidCost.title"),
                type: "fixed"
			},
			"challengeHappiness":{
                title: $I("effectsMgr.statics.challengeHappiness.title")
			},
			"tradeKnowledge":{
				title: $I("effectsMgr.statics.tradeKnowledge.title")
			},
			"tradeKnowledgeRatio" :  {
				title: $I("effectsMgr.statics.tradeKnowledgeRatio.title"),
				type: "ratio",
				calculation: "nonProportional"
			},
			"steamworksFakeBought":{
				title: $I("effectsMgr.statics.steamworksFakeBought.title")
			},
			"embassyFakeBought":{
				title: $I("effectsMgr.statics.embassyFakeBought.title")
			},
			"policyFakeBought":{
				title: $I("effectsMgr.statics.policyFakeBought.title")
			},
			"weaponEfficency":{
				title: $I("effectsMgr.statics.weaponEfficency.title"),
				type: "ratio"
			},
			"bonfireTearsPriceRatioChallenge": {
				title: $I("effectsMgr.statics.bonfireTearsPriceRatioChallenge.title"),
				type: "ratio",
				calculation: "nonProportional"
			},
			"scienceTearsPricesChallenge": {
				title: $I("effectsMgr.statics.scienceTearsPricesChallenge.title"),
				type: "ratio"
			},
			"workshopTearsPricesChallenge": {
				title: $I("effectsMgr.statics.workshopTearsPricesChallenge.title"),
				type: "ratio"
			},
			"zigguratIvoryPriceRatio": {
				title: $I("effectsMgr.statics.zigguratIvoryPriceRatio.title"),
				type: "ratio"
			},
			"cryochamberSupport":{
				title: $I("effectsMgr.statics.cryochamberSupport.title"),
			},
			"arrivalSlowdown":{
				title: $I("effectsMgr.statics.arrivalSlowdown.title"),
				type: "ratio"
			},
			"mausoleumBonus":{
				title: $I("effectsMgr.statics.mausoleumBonus.title"),
				type: "ratio"
			},
			//pacts
			"pactNecrocornConsumption": {
				title: $I("effectsMgr.statics.necrocornPerDay.pact.title"),
				type: "perDay"
			},
            "pactsAvailable":{
				title: $I("effectsMgr.statics.pactsAvailable.title"),
				type: "fixed"
			},
            "kittensKarmaPerMinneliaRatio":{
				title: $I("effectsMgr.statics.kittensKarmaPerMinneliaRatio.pact.title"),
				type: "ratio"
			},
            "necrocornPerDay":{
				title: $I("effectsMgr.statics.necrocornPerDay.pact.title"),
				type: "perDay"
			},
            "pactGlobalResourceRatio":{
				title: $I("effectsMgr.statics.pactGlobalResourceRatio.title"),
				type: "ratio"
			},
            "pactGlobalProductionRatio":{
				title: $I("effectsMgr.statics.pactGlobalProductionRatio.title"),
				type: "ratio"
			},
            "pactFaithRatio":{
				title: $I("effectsMgr.statics.pactFaithRatio.title"),
				type: "ratio"
			},
			"pyramidGlobalResourceRatio":{
				title: $I("effectsMgr.statics.pyramidGlobalResourceRatio.title"),
				type: "ratio"
			},
			"pyramidGlobalProductionRatio":{
				title: $I("effectsMgr.statics.pyramidGlobalProductionRatio.title"),
				type: "ratio"
			},
			"deficitRecoveryRatio":{
				title: $I("effectsMgr.statics.deficitRecoveryRatio.title"),
				type: "ratio"
			},
			"pyramidFaithRatio":{
				title: $I("effectsMgr.statics.pyramidFaithRatio.title"),
				type: "ratio"
			},
			"pyramidSpaceCompendiumRatio":{
				title: $I("effectsMgr.statics.pyramidSpaceCompendiumRatio.title"),
				type: "ratio"
			},
			"pyramidPerYearRatio": {
				title: $I("effectsMgr.statics.pyramidPerYearRatio.title"),
				type: "ratio"
			},
			"pactBlackLibraryBoost":{
				title: $I("effectsMgr.statics.pactBlackLibraryBoost.title"),
				type: "ratio"
			},
			"pactDeficitRecoveryRatio":{
				title: $I("effectsMgr.statics.pactDeficitRecoveryRatio.title"),
				type: "ratio"
			},
			"UniversalKnowHow" :  {
                title: $I("effectsMgr.statics.UniversalKnowHow.title"),
                type: "fixed"
            },
			"pactSpaceCompendiumRatio":{
				title: $I("effectsMgr.statics.pactSpaceCompendiumRatio.title"),
				type: "ratio"
			},
			"pactcraftRatio": {
				title: $I("effectsMgr.statics.pactcraftRatio.title"),
				type: "ratio"
			},
			"pactPerYearRatio": {
				title: $I("effectsMgr.statics.pactPerYearRatio.title"),
				type: "ratio"
			},
			"pactUniversalKnowHow":{
				title: $I("effectsMgr.statics.pactUniversalKnowHow.title"),
				type: "fixed"
			},
			"pacttimeRatio":{
				title: $I("effectsMgr.statics.pacttimeRatio.title"),
				type: "ratio"
			},
			//pollution
			"cathPollutionPerTickProd":{
				type: "hidden"
			},
			"cathPollutionPerTickCon":{
				type: "hidden"
			},
			"cathPollutionRatio":{
				title:  $I("effectsMgr.statics.pollutionRatio.title"),
				type: "ratio"
			},
			"cathPollutionPerTearOvercapped": {
				type: "hidden"
			},
            //zebra workshop upgrades
            "zebraPreparations": {
                title: $I("effectsMgr.statics.zebraPreparations.title"),
                type: "fixed"
			},
			"preparationRatio": {
                title: $I("effectsMgr.statics.preparationRatio.title"),
                type: "ratio"
			},
			"academyMeteorBonus": {
                title: $I("effectsMgr.statics.academyMeteorBonus.title"),
                type: "ratio"
			},
			"activeHG":{
				title: $I("effectsMgr.statics.activeHG.title"),
				type: "fixed",
				calculation: "nonProportional"

			},
			"milleninumParagon":{
				title: $I("effectsMgr.statics.milleninumParagon.title"),
				type: "fixed",
			},
			"missingZebraPreparations":{
				title: $I("effectsMgr.statics.missingZebraPreparations.title"),
				type: "fixed",
				calculation: "nonProportional"
			}
		}
	}
});

/**
 * Main game class, can be accessed globally as a 'gamePage' variable
 */

var GamePage = dojo.declare("com.nuclearunicorn.game.ui.GamePage", null, {

	/** @type {string} id of the container DOM node */
	id: null,

	/** @type {any[]} */
	tabs: null,

	//components:
	//Managers and tabs live in js/*.js, which are not checked yet, so they stay
	//`any` for now. Give one a real type as soon as its file is opted in.

	/** @type {any} */
	resPool: null,
	/** @type {any} */
	calendar: null,
	/** @type {any} */
	bld: null,
	/** @type {any} */
	village: null,
	/** @type {any} */
	science: null,
	/** @type {any} */
	workshop: null,
	/** @type {any} */
	diplomacy: null,
	/** @type {any} */
	achievements: null,

	//the rest of the managers, installed by the `managers` loop in the constructor
	/** @type {any} */
	challenges: null,
	/** @type {any} */
	religion: null,
	/** @type {any} */
	space: null,
	/** @type {any} */
	time: null,
	/** @type {any} */
	prestige: null,
	/** @type {any} */
	stats: null,
	/** @type {any} */
	void: null,
	/** @type {any} */
	settings: null,

	//tab handles, installed by the `tabRegistry` loop in the constructor
	/** @type {any} */
	bldTab: null,
	/** @type {any} */
	villageTab: null,
	/** @type {any} */
	libraryTab: null,
	/** @type {any} */
	workshopTab: null,
	/** @type {any} */
	diplomacyTab: null,
	/** @type {any} */
	religionTab: null,
	/** @type {any} */
	spaceTab: null,
	/** @type {any} */
	timeTab: null,
	/** @type {any} */
	challengesTab: null,
	/** @type {any} */
	achievementTab: null,
	/** @type {any} */
	statsTab: null,
	/** @type {any} */
	queueTab: null,
	/** @type {any} */
	settingsTab: null,

	/** @type {any} com.nuclearunicorn.game.log.Console, see core.js */
	console: null,
	/** @type {any} Telemetry - loose to break the back-reference cycle, see the typedefs above */
	telemetry: null,
	/** @type {any} Server - loose to break the back-reference cycle, see the typedefs above */
	server: null,
	/** @type {any} Preview - owns read-only KGNet save previews, see js/preview.js */
	preview: null,

	/**
	 * True while we are displaying somebody else's KGNet save (?saveId=...).
	 * Set by classes.game.Preview before the save is even fetched. Nothing that mutates
	 * game state, storage or the cloud may run while this is up - see isReadOnly().
	 */
	previewMode: false,
	/** @type {any} com.nuclearunicorn.game.Math, see js/math.js */
	math: null,

	/** @type {Worker} */
	worker: null,			//web worker driving the update loop off the main thread
	/** @type {number} */
	_lastFrameTimestamp: null,
	/** @type {number} */
	lastBackup: null,		//timestamp of the last KGNet save upload
	isKSDetected: false,	//true if the Kitten Scientists mod is present

	//global cache
	/** @type {Record<string, number>} */
	globalEffectsCached: {},

	//how much ticks are performed per second (5 ticks per second, 200 ms per tick)
	ticksPerSecond: 5,

	//I wonder why someone may need this
	isPaused: false,

	isCMBREnabled: false,

	ticksBeforeSave: 400,	//80 seconds ~

	//in ticks
	autosaveFrequency: 400,


	//current building selected in the Building tab by a mouse cursor, should affect resource table rendering
	//TODO: move me to UI
	/** @type {any} */
	selectedBuilding: null,
	/** @type {HTMLElement} */
	selectedBuildingDomNode: null,
	/**
	 * @param {any} object - building metadata, or null to clear the selection
	 * @param {HTMLElement} [domNode]
	 */
	setSelectedObject: function(object, domNode) {
		this.selectedBuilding = object;
		this.selectedBuildingDomNode = domNode;
		this._publish("ui/update", this);
	},
	clearSelectedObject: function() {
		this.selectedBuilding = null;
		this.selectedBuildingDomNode = null;
		this._publish("ui/update", this);
	},

	//=============================
	//		option settings
	//=============================
	colorScheme: "",
	/** @type {string[]} ids of the themes the player has unlocked */
	unlockedSchemes: null,

	/** @type {Timer} */
	timer: null,
	/** @type {number} */
	_mainTimer: null,	//main timer loop

	//===========================================
	//game-related flags that will go to the save
	//===========================================

	//on a side note, I hate those flags. Could we use gamePage.opts = []/{}; ?
	karmaKittens: 0,	//counter for karmic reincarnation
	karmaZebras: 0,
	deadKittens: 0,
	ironWill: true,		//true if player has no kittens or housing buildings

	saveVersion: 15,

	//FINALLY
	//Booleans default in settings.js, so anything may be missing here; keep it open.
	/** @type {{notation: string, batchSize: number} & Record<string, any>} */
	opts: null,

	/** @type {number} */
	gatherTimeoutHandler: null,	//timeout till resetting gather counter, see below
	gatherClicks: 0,	//how many clicks in a row was performed on a gather button
	cheatMode: false,	//flag triggering Super Unethical Climax achievement
	systemShockMode: false,	//flag triggering System Shock achievement
	startedWithoutChronospheres: true, //Flag for achievements

	ticks: 0,				//how many ticks passed since the start of the game
	totalUpdateTime: [0, 0, 0, 0, 0],	//total time spent on update cycle in milliseconds, useful for debug/fps counter. 1 ticks per second have more calculations
	totalUpdateTimeTicks: 5,
	totalUpdateTimeCurrent : 0,
	/** @type {Record<string, number>} */
	fps: null,	//fps breakdows of a render cycle

	pauseTimestamp: 0, //time of last pause

	/** @type {string} */
	lastDateMessage: null,  //Stores the most recent date message to prevent header spam

	/** @type {any} EffectsManager - loose to break the back-reference cycle, see the typedefs above */
	effectsMgr: null,

	/** @type {any[]} every TabManager instantiated by the `managers` loop, in order */
    managers: null,

    //TODO: this can potentially be an array
	/** @type {UndoChange} */
    undoChange: null,

    //ui communication layer
	/** @type {any} see js/ui.js */
    ui: null,

	/*
		Whether the game is in developer mode or no
	 */
	isLocalhost: false,
	devMode: false,
	mobileSaveOnPause: true,

	// whether loading the save from localstorage failed.
	// used to prevent overwriting the potentially-broken save data in
	// localstorage with definitely-broken data from a partial save load.
	currentSaveIsBroken: false,

	//should this go to the res pool?
	winterCatnipPerTick: 0,

	//====== Feature Flags =======

	//a quick way of disabling particular feature on mainline/beta without maintaining boolean flags in the code
	//there is still no simple way to figure out on WHICH branch we are, especially on local, but we can parse URL

	/** @type {Record<string, {beta: boolean, main: boolean, mobile: boolean}>} */
	featureFlags: {
		VILLAGE_MAP: {
			beta: true,
			main: false,
			mobile: false
		},
		SPACE_EXPL: {
			beta: false,
			main: false,
			mobile: false
		},
		MAUSOLEUM_PACTS:{
			beta: true,
			main: true,
			mobile: true
		},
		QUEUE:{
			beta: true,
			main: true,
			mobile: true
		},
		QUEUE_REDSHIFT: {
			beta: true,
			main: true,
			mobile: true
		},
		UNICORN_TEARS_CHALLENGE: {
			beta: true,
			main: true,
			mobile: true
		},
		DARK_PARACOSM: {
			beta: true,
			main: true,
			mobile: true
		}
	},

	/**
	 * Build platform, from version.json: "web" | "mobile" | "steam".
	 * Single source of truth - never fork this per platform, ship a different version.json instead.
	 * @returns {"web" | "mobile" | "steam"}
	 */
	getPlatform: function(){
		return (window.KGVersion && window.KGVersion.platform) || "web";
	},

	/** @returns {boolean} */
	isMobile: function(){
		return this.getPlatform() == "mobile";
	},

	/** @param {string} containerId - id of the DOM node the game renders into */
	constructor: function(containerId){
		this.id = containerId;

		this.fps = {};
		this.tabs = [];
        this.managers = [];

		this.opts = {
			//All default values for booleans are now handled in settings.js.
			notation: "si",
			batchSize: 10
		};

		this.console = new com.nuclearunicorn.game.log.Console(this);
		this.telemetry = new classes.game.Telemetry(this);
		this.server = new classes.game.Server(this);
		this.preview = new classes.game.Preview(this);
		this.math = new com.nuclearunicorn.game.Math();

		this.resPool = new classes.managers.ResourceManager(this);
		this.calendar = new com.nuclearunicorn.game.Calendar(this, dojo.byId("calendarDiv"));

		this.village = new classes.managers.VillageManager(this);
		this.resPool.setVillage(this.village);

        var managers = [
		{ id: "challenges",     class:  "ChallengesManager" }, //challenges must be *before* space for a certain policy to work.
            { id: "workshop",       class:  "WorkshopManager"   },
            { id: "diplomacy",      class:  "DiplomacyManager"  },
            { id: "bld",            class:  "BuildingsManager"  },
            { id: "science",        class:  "ScienceManager"    },
            { id: "achievements",   class:  "Achievements"      },
            { id: "religion",       class:  "ReligionManager"   },
            { id: "space",          class:  "SpaceManager"      },
			{ id: "time",           class:  "TimeManager"       },
            { id: "prestige",       class:  "PrestigeManager"   },
            { id: "stats",       	class:  "StatsManager"      },
			{ id: "void",       	class:  "VoidManager"      },
			{ id: "settings",		class: "SettingsManager" }
        ];

        for (var i in managers){
            var manager = managers[i];
			if (!window["classes"]["managers"][manager.class]){
				throw "Unable to load tab manager '" + manager.class + "'";
			}

            this[manager.id] = new window["classes"]["managers"][manager.class](this);
			var managerRef = this[manager.id];
			managerRef.id = manager.id;
            this.managers.push(managerRef);
        }

		//very sloppy design, could we just use an array for tab managers?

		var tabRegistry = [
			{class: com.nuclearunicorn.game.ui.tab.BuildingsModern,
				name: "buildings.tabName",
				id: "Bonfire",
				prop: "bldTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.Village,
				name: "village.tab.title.smallvillage",
				id: "Village",
				prop: "villageTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.Library,
				name: "tab.name.science",
				id: "Science",
				prop: "libraryTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.Workshop,
				name: "tab.name.workshop",
				id: "Workshop",
				prop: "workshopTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.Diplomacy,
				name: "tab.name.trade",
				id: "Trade",
				prop: "diplomacyTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.ReligionTab,
				name: "tab.name.religion",
				id: "Religion",
				prop: "religionTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.SpaceTab,
				name: "tab.name.space",
				id: "Space",
				prop: "spaceTab"
			},
			{class: classes.tab.TimeTab,
				name: "tab.name.time",
				id: "Time",
				prop: "timeTab"
			},
			{class: classes.tab.ChallengesTab,
				name: "tab.name.challenges",
				id: "Challenges",
				prop: "challengesTab"
			},
			{class: com.nuclearunicorn.game.ui.tab.AchTab,
				name: "tab.name.achievements",
				id: "Achievements",
				prop: "achievementTab"
			},
			{class: classes.tab.StatsTab,
				name: "tab.name.stats",
				id: "Stats",
				prop: "statsTab"
			}
		];

		if (this.isMobile()){
			tabRegistry.push(
				{
					class: classes.tab.QueueTab,
					name: "tab.name.queue",
					id: "Queue",
					prop: "queueTab"
				}
			);
		}

		var game = this;
		dojo.forEach(tabRegistry, function(tab){
			var tabProp = new tab.class({
				name: $I(tab.name),
				id: tab.id
			}, game);
			tabProp.visible = true;
			game[tab.prop] = tabProp;
			//TODO: please don't rely on game.xxxTab, it's a candidate for removal

			game.addTab(tabProp);
		});

		//SettingsTab goes in a separate spot in the UI from normal tabs like Bonfire, Village, Science, etc.
		game.settingsTab = new com.nuclearunicorn.game.ui.tab.SettingsTab({
			name: $I("menu.options"),
			id: "Settings"
		}, game);

		//vvvv do not forget to toggle tab visibility below (see load method)

		this.timer = new classes.game.Timer();

		//Update village resource production.
		//Since this method is CPU heavy and rarely used, we will call with some frequency, but not on every tick
		this.timer.addEvent(dojo.hitch(this, function(){
			this.village.updateResourceProduction();
		}), 10);	//every 2 seconds

		this.timer.addEvent(dojo.hitch(this, function(){
			this.updateCaches();
		}), 5);		//once per 5 ticks

		//Update descriptions of some policies where it's a pain to call game.upgrade every time something changes.
		this.timer.addEvent(dojo.hitch(this, function() {
			var policies = ["upfrontPayment", "sharkRelationsMerchants"];
			for (var i = 0; i < policies.length; i++) {
				var thePolicy = game.science.getPolicy(policies[i]);
				thePolicy.calculateEffects(thePolicy, this);
			}
		}), 25);		//every 5 seconds

		var ONE_MIN = this.ticksPerSecond * 60;
		this.timer.addEvent(dojo.hitch(this, function(){ this.achievements.update(); }), 50);	//once per 50 ticks, we hardly need this
		this.timer.addEvent(dojo.hitch(this, function(){ this.server.refresh(); }), ONE_MIN * 10);	//reload MOTD and server info every 10 minutes
		this.timer.addEvent(dojo.hitch(this, function(){ if (this.opts.hodl){ this.server.fetchBcoinPrice(); } }), ONE_MIN * 5);	//refresh real-world b-coin price every 5 min
		this.timer.addEvent(dojo.hitch(this, function(){ this.heartbeat(); }), ONE_MIN * 10);	//send heartbeat every 10 min	//TODO: 30 min eventually
		this.timer.addEvent(dojo.hitch(this, function(){ this.updateWinterCatnip(); }), 25);	//same as achievements, albeit a bit more frequient
		this.timer.addEvent(dojo.hitch(this, function(){ this.ui.checkForUpdates(); }), ONE_MIN * 5);	//check new version every 5 min
		this.timer.addEvent(dojo.hitch(this, function(){ this.time.updateQueue(); }), 10 );

		this.effectsMgr = new com.nuclearunicorn.game.EffectsManager(this);
	},

	/**
	 * @param {string} flagId - key into `featureFlags`
	 * @returns {boolean} always true on localhost, so devs see everything
	 */
	getFeatureFlag: function(flagId){
		if (this.isMobile()){
			return this.featureFlags[flagId]["mobile"];
		}
		var host = window.location.hostname;
		var isLocalhost = window.location.protocol == "file:" || host == "localhost" || host == "127.0.0.1" || host.startsWith("192.168");

		if (isLocalhost){
			return true;
		}

		var isBeta = (window.location.href.indexOf("beta") >= 0);
		return this.featureFlags[flagId][isBeta ? "beta" : "main"];
	},

	//update winter catnip consumption for the UI every 5-10 seconds to avoid calculating it every tick
	updateWinterCatnip: function(){
		this.winterCatnipPerTick = this.calcResourcePerTick("catnip", { modifiers:{
			"catnip" : 0.25
		}});	//calculate estimate winter per tick for catnip;
	},

	heartbeat: function(){
		if (this.isReadOnly()){
			return;
		}
		this.telemetry.logEvent("heartbeat", {
			opts: this.opts,
			year: this.calendar.year
		});
	},

	/**
	 * Management of effects
	 * @param {string} effectName
	 * @returns {EffectMeta} never null - unknown effects fall back to `{title: effectName}`
	 */
	getEffectMeta: function(effectName) {
		// Try to create Meta automatically, if it fails, check statics, if it fails, by default
		var effectMetaDynamic = this.effectsMgr.effectMeta(effectName);
		if (effectMetaDynamic != 0) {
			return effectMetaDynamic;
		} else {
			var effectMetaStatic = this.effectsMgr.statics.effectMeta[effectName];
			if (typeof(effectMetaStatic) != "undefined") {
				return this.effectsMgr.statics.effectMeta[effectName];
			} else {
				return { title: effectName };
			}
		}
	},
	/**
	 * @param {string} effectName
	 * @returns {number} 0 for effects nothing contributes to
	 */
	getEffect: function(effectName){
		 return this.globalEffectsCached[effectName] || 0;
	},

	updateCaches: function() {
		this.globalEffectsCached = {};

		this.workshop.updateEffectCached();
		this.religion.updateEffectCached();
		this.bld.updateEffectCached();
		this.challenges.updateEffectCached();
		this.prestige.updateEffectCached();
		this.space.updateEffectCached();
		this.time.updateEffectCached();
		this.village.updateEffectCached();
        this.science.updateEffectCached();
		
		this.bld.cacheCathPollutionPerTick();

		this.updateResources();

	},

	// Limited Diminishing Return
	//getHyperbolicEffect
	/**
	 * @param {number} effect
	 * @param {number} limit - the value the result asymptotically approaches
	 * @returns {number} same sign as `effect`
	 */
	getLimitedDR: function(effect, limit) {
		var absEffect = Math.abs(effect);

		var maxUndiminished = 0.75 * limit; //first 75% is free from diminishing returns

		if (absEffect <= maxUndiminished) {
			//Not high enough for diminishing returns to apply
			return effect < 0 ? -absEffect : absEffect;
		}

		var diminishedPortion = absEffect - maxUndiminished;

		var delta = 0.25 * limit; //Lower values will approach 1 more quickly.

		// The last 25% will approach .25 but cannot actually reach it
		var diminishedEffect = (1 - (delta / (diminishedPortion + delta))) * delta;

		var totalEffect = maxUndiminished + diminishedEffect;

		return effect < 0 ? -totalEffect : totalEffect;
	},

	/**
	 * Display a message in the console. Returns a <span> node of a text container
	 * @param {string} message
	 * @param {string} [type] - log filter class, e.g. "important" or "notice"
	 * @param {string} [tag] - filter id, lets the player mute this kind of message
	 * @param {boolean} [noBullet]
	 * @returns {HTMLElement}
	 */
	msg: function(message, type, tag, noBullet){
		return this.console.msg(message, type, tag, noBullet);
	},

	clearLog: function(){
		dojo.empty("gameLog");
		this.console.clear();
		this.lastDateMessage = null;
	},

	saveUI: function(){
		if (this.isReadOnly()){
			return;
		}
		this.save();

		dojo.style(dojo.byId("saveTooltip"), "opacity", "1");
		dojo.animateProperty({
			node:"saveTooltip",
			properties: {
				opacity: 0
			},
			duration: 1200
		}).play();
	},

	resetState: function(){
		this.colorScheme = "";
		this.unlockedSchemes = this.ui.defaultSchemes;
		this.karmaKittens = 0;
		this.karmaZebras = 0;
		this.ironWill = true;
		this.deadKittens = 0;
		this.cheatMode = false;
		this.systemShockMode = false;
		this.startedWithoutChronospheres = true;
		this.isCMBREnabled = false;

		this.isKSDetected = false;

		if (this.pauseTimestamp){
			this.pauseTimestamp = Date.now();
		}

		this.opts = {
			//All default values for booleans are now handled in settings.js.
			notation: "si",
			batchSize: 10
		};

		this.resPool.resetState();
		this.village.resetState();
		this.calendar.resetState();
		this.ui.resetConsole();

		for (var i in this.managers){
			this.managers[i].resetState();
		}

		for (var i in this.tabs){
			if (this.tabs[i].tabId != "Bonfire"){
				this.tabs[i].visible = false;
			}
		}

		this.globalEffectsCached = {};

		this.undoChange = null;
		this._publish("server/undoStateChanged");
	},

	/**
	 * dojo 1.6 wants the args wrapped in an array, later versions don't.
	 * @param {string} topic
	 * @param {any} [arg]
	 */
	_publish: function(topic, arg){
		if (dojo.version.minor == 6) {
			dojo.publish(topic, [arg]);
		} else {
			dojo.publish(topic, arg);
		}
	},

	/**
	 * Gate for every mutating entry point: save, load, reset, wipe, cloud sync, buttons.
	 * Callers short-circuit silently - a preview refusing to do things is the
	 * advertised behaviour, not something worth logging about.
	 * @returns {boolean} true while a read-only save preview is on screen
	 */
	isReadOnly: function(){
		return this.previewMode;
	},

	reload: function(){
		if (this.isReadOnly()){
			return;
		}
		this.save();
		window.location.reload();
	},



	/**
	 * Do not serialize properties with undefined values even if they exist on the metadata
	 * @param {string} key
	 * @param {any} value
	 * @returns {any}
	 */
	JSONreplacer: function(key, value) {
		return (value == undefined)
			? undefined
			: value;
	},

	/**
	 * Collect every manager's state, write it to localStorage, and hand the
	 * un-stringified blob back - callers (export, KGNet upload) expect the object.
	 * @returns {SaveData}
	 */
	save: function(){
		if (this.previewMode) {
			// read-only preview: hand back what we are showing, serialize nothing, store nothing
			return this._parseLSSaveData();
		}

		if (this.currentSaveIsBroken) {
			// if the save is broken, we return the original save that we tried to import.
			// (unfortunately we need to parse it a little bit, since callers of save() expect the unserialized data...)
			return this._parseLSSaveData(LCstorage["com.nuclearunicorn.kittengame.savedata"]);
		}

		this.ticksBeforeSave = this.autosaveFrequency;

		var saveData = {
			saveVersion: this.saveVersion
		};

		this.server.save(saveData);
		this.resPool.save(saveData);
		this.village.save(saveData);
		this.calendar.save(saveData);
		this.console.save(saveData);
		this.telemetry.save(saveData);

		for (var i in this.managers){
			this.managers[i].save(saveData);
		}

		saveData.game = {
			isCMBREnabled: this.isCMBREnabled,
			colorScheme: this.colorScheme,
			unlockedSchemes: this.unlockedSchemes,
			karmaKittens: this.karmaKittens,
			karmaZebras: this.karmaZebras,
			ironWill : this.ironWill,
			deadKittens: this.deadKittens,
			cheatMode: this.cheatMode,
			startedWithoutChronospheres: this.startedWithoutChronospheres,

			opts : this.opts,
			lastBackup: this.lastBackup
		};

		var preparedSaveData = this._prepareSaveData(saveData);
		var saveDataString = this._saveDataToString(preparedSaveData);
		try {
			LCstorage["com.nuclearunicorn.kittengame.savedata"] = saveDataString;
			console.log("Game saved");
		} catch (e) {
			//most likely the localStorage quota is exceeded (or storage is blocked, e.g. private browsing)
			console.error("Unable to save the game:", e);
			this.msg($I("save.fail"), "alert");
		}

		this.ui.save();

		return preparedSaveData;
	},

	/**
	 * @param {SaveData} saveData
	 * @returns {SaveData} the same object - external `game/beforesave` listeners may have mutated it
	 */
	_prepareSaveData: function(saveData) {
		// Allow external scripts to consume the `game/beforesave` event to manipulate
		// this save data state.
		// This event is currently entirely for external consumers.
		this._publish("game/beforesave", saveData);

		return saveData;
	},

	/**
	 * @param {SaveData} saveData
	 * @returns {string} raw JSON, or an LZ blob once it outgrows the 5mb localStorage limit
	 */
	_saveDataToString: function(saveData) {
		var saveDataString = JSON.stringify(saveData, this.JSONreplacer);
		//5mb limit workaround
		if (saveDataString.length > 5000000 || this.opts.forceLZ) {
			console.log("compressing the save file...");
			saveDataString = this.compressLZData(saveDataString, true);
		}
		return saveDataString;
	},

	_wipe: function(){
		this.timer.scheduleEvent(dojo.hitch(this, function() {
			this.mobileSaveOnPause = false;
			delete(LCstorage["com.nuclearunicorn.kittengame.savedata"]);
			delete(LCstorage["com.nuclearunicorn.kittengame.language"]);// it is the only way to clear it up
			window.location.reload();
		}));
	},

	wipe: function() {
		var game = this;
		if (this.isReadOnly()){
			return;
		}
		this.ui.confirm($I("wipe.confirmation.title"), $I("wipe.confirmation.msg1"), function() {
			game.ui.confirm($I("wipe.confirmation.title"), $I("wipe.confirmation.msg2"), function() {
				game._wipe();
			});
		});
	},

	closeOptions: function() {
		$("#optionsDiv").hide();
		this.render();
	},

	/** @param {string} themeId */
	toggleScheme: function(themeId){
		this.colorScheme = themeId;
		this.updateOptionsUI();
	},

	togglePause: function(){
		if (this.isReadOnly()){
			return;
		}
		var pauseBtn = dojo.byId("pauseBtn");
		this.isPaused = !this.isPaused;
		pauseBtn.innerHTML = this.isPaused ? $I("ui.unpause") : $I("ui.pause");

		if (this.isPaused){
			this.pauseTimestamp = Date.now();
		} else if (this.pauseTimestamp){
			this.time.gainTemporalFlux(this.pauseTimestamp);
			this.pauseTimestamp = 0;
		}
	},

	updateOptionsUI: function(){
		this.ui.updateOptions();
        this._publish("game/options", this);
	},

	/**
	 * Returns a save data JSON from a base64 or utf16 compressed lz blob
	 * Use this instead of LZString.decompressX
	 * @param {string} lzData
	 * @returns {string}
	 */
	decompressLZData: function(lzData) {
		var decompressedAsBase64 = LZString.decompressFromBase64(lzData);
		return decompressedAsBase64 && decompressedAsBase64[0] == "{"
			? decompressedAsBase64
			: LZString.decompressFromUTF16(lzData);
	},

	/**
	 * @param {string} json
	 * @param {boolean} [useUTF16] - utf16 packs denser, base64 survives copy-paste
	 * @returns {string}
	 */
	compressLZData: function(json, useUTF16) {
		//todo check game compatibility flags
		//console.log("base64 length:", LZString.compressToBase64(json).length, "utf-16 length:", LZString.compressToUTF16(json).length);
		return useUTF16
			? LZString.compressToUTF16(json)
			: LZString.compressToBase64(json);
	},

	/**
	 * @param {string} [lsData] - raw save blob; defaults to the one in localStorage
	 * @returns {SaveData}
	 */
	_parseLSSaveData: function(lsData){
		var data = null;
		var localStorageData = (lsData !== undefined)
			? lsData
			: LCstorage["com.nuclearunicorn.kittengame.savedata"];

		if (localStorageData && localStorageData[0] == "{"){
			data = localStorageData;
		} else {
			data = this.decompressLZData(localStorageData);
		}
		var saveData = JSON.parse(data);

		//console.log("Parse _parseLSSaveData complete, data:", data, "saveData:", saveData);
		return saveData;
	},

	/**
	 * Reset to a pristine state, then replay the localStorage save over it.
	 * @returns {boolean} false if the blob failed to parse - the caller must NOT
	 *   save over localStorage afterwards, or the broken save is made permanent.
	 */
	load: function(){
		var data = LCstorage["com.nuclearunicorn.kittengame.savedata"];
		this.resetState();
		this.currentSaveIsBroken = false;
		if (!data){
			this.calculateAllEffects();
			this.updateOptionsUI();
			return;
		}
		var success = true;

		try {
			var saveData = this._parseLSSaveData();
			if (saveData){

				console.log("game#load - Successfully parsed local storage data, loading tab managers...");

				if (saveData.server){
					this.server.motdContentPrevious = saveData.server.motdContent;
					if (typeof saveData.server.bcoinPrice === "number"){
						this.server.bcoinPrice = saveData.server.bcoinPrice; //last known "hodl" mode price
					}
				}

				if (!saveData.saveVersion || saveData.saveVersion != this.saveVersion) {
					this.migrateSave(saveData);
				}

				this.resPool.load(saveData);
				this.village.load(saveData);
				this.calendar.load(saveData);
				this.console.load(saveData);
				this.telemetry.load(saveData);
				this.ui.renderFilters();

				for (var i in this.managers) {
					console.log("game#load - Processing", this.managers[i].id, "...");
					this.managers[i].load(saveData);
				}
				//Do a second pass for features which require communication between game systems.
				this.managers.forEach( function(manager) {
					if (typeof(manager.afterLoad) === "function") {
						console.log("game#load - Processing (afterLoad) " + manager.id + " ...");
						manager.afterLoad();
					}
				});
				
				this._publish("server/load", saveData);
			}
		} catch (ex) {
			console.error("Unable to load game data: ", ex);
			if (dojo.version.minor == 6) {
				console.log(new Error().stack);
			} else {
				console.trace();
			}

			this.msg("Unable to load save data. Contact the devs and provide the faulty save file.", "important");
			success = false;
			this.currentSaveIsBroken = true;
		}


		if (saveData && saveData.game){
			var data = saveData.game;

			//something should really be done with this mess there
			this.colorScheme = data.colorScheme ? data.colorScheme : null;
			this.unlockedSchemes = data.unlockedSchemes ? data.unlockedSchemes : this.ui.defaultSchemes;

			this.karmaKittens = (data.karmaKittens !== undefined) ? data.karmaKittens : 0;
			this.karmaZebras = (data.karmaZebras !== undefined) ? data.karmaZebras : 0;
			this.deadKittens = (data.deadKittens !== undefined) ? data.deadKittens : 0;
			this.ironWill = (data.ironWill !== undefined) ? data.ironWill : true;

			this.cheatMode = (data.cheatMode !== undefined) ? data.cheatMode : false;
			this.startedWithoutChronospheres = (data.startedWithoutChronospheres !== undefined) ? data.startedWithoutChronospheres : false; //false for existing games

			this.isCMBREnabled = (data.isCMBREnabled !== undefined) ? data.isCMBREnabled : true;	//true for all existing games
			this.lastBackup = data.lastBackup || new Date().getTime();

			// ora ora
			if (data.opts) {
				for (var opt in data.opts) {
					this.opts[opt] = data.opts[opt];
				}
				if (data.opts.tooltipsInRightColumn == undefined) {
					this.opts.tooltipsInRightColumn = this.colorScheme == "sleek";
				}
				if (data.opts.fontSize == undefined){
					this.opts.fontSize = 14;
				}
			}

			//Opt out existing saves, opt in all new games
			if (!data.opts || data.opts.hodl === undefined) {
				this.opts.hodl = false;
			}

			this.updateOptionsUI();
		}
		// Calculate effects (needs to be done after all managers and save data are loaded)
		this.calculateAllEffects();
		this.resPool.updateMaxValueAll();
		//------------------------------------

		this.villageTab.visible = this.villageTab.evaluateLocks();
		this.libraryTab.visible = (this.bld.get("library").on > 0 || this.science.get("calendar").researched || this.science.get("chronophysics").researched);
		this.workshopTab.visible = (this.bld.get("workshop").on > 0);
		this.achievementTab.visible = (this.achievements.hasUnlocked());
		this.statsTab.visible = (this.karmaKittens > 0 || this.science.get("math").researched);

		this.diplomacyTab.visible = (this.diplomacy.hasUnlockedRaces());
		this.religionTab.visible = (
			this.resPool.get("faith").value > 0 || 
			this.challenges.isActive("atheism") && 
			this.bld.get("ziggurat").val > 0);

		this.spaceTab.visible = (this.science.get("rocketry").researched);
		this.timeTab.visible = (
			this.science.get("calendar").researched || 
			this.time.getVSU("usedCryochambers").val > 0);
			
		this.challengesTab.visible = (
			this.prestige.getPerk("adjustmentBureau").researched || 
			this.prestige.getPerk("adjustmentBureau").reserve);

		this.ui.load();
		this.village.updateHappines();
		this.village.updateResourceProduction();
		this.updateCaches();

		return success;
	},


	//btw, ie11 is horrible crap and should not exist
	saveExport: function(){
		if (this.isReadOnly()){
			return;
		}
		var data = this.save();
		var dataString = JSON.stringify(data);

        var encodedData = this.compressLZData(dataString);
        this.ui.saveExport(encodedData);

	},

	saveImport: function() {
		var game = this;
		if (this.isReadOnly()){
			return;
		}
		this.ui.confirm("", $I("save.import.confirmation.msg"), function() {
			var data = $("#importData").val().replace(/\s/g, "");
			if (data) {
				game.saveImportText(data, function(error) {
					$("#importDiv").hide();
					$("#optionsDiv").hide();
				});
			}
		});
	},

	/** @param {boolean} [withFullName] - tag the filename with run number and in-game date */
    saveToFile: function(withFullName) {
        if (this.isReadOnly()){
            return;
        }
        var $link = $("#download-link");

        var data = JSON.stringify(this.save());
        var lzdata = this.compressLZData(data);
        var blob = new Blob([lzdata], {type: "text/plain"});
        $link.attr("href", window.URL.createObjectURL(blob));

        var filename = "Kittens Game";
        if (withFullName) {
            filename += " - Run " + (this.stats.getStat("totalResets").val + 1)
                + " - " + $I("calendar.year.full", [this.calendar.year, this.calendar.getCurSeasonTitle(), Math.floor(this.calendar.day)]);
        }
        $link.attr("download", filename + ".txt");

        $link.get(0).dispatchEvent(new MouseEvent("click"));
	},

    saveImportText: function(lzdata, callback){
        this.timer.scheduleEvent(dojo.hitch(this, this._loadSaveJson, lzdata, callback));
    },

	//TODO: add some additional checks and stuff?
	/**
	 * @param {string} lzdata
	 * @param {(error?: any) => void} callback
	 */
	_loadSaveJson: function(lzdata, callback){
        if (this.isReadOnly()){
            callback("read-only preview");
            return;
        }
        try {
			var jsonString = this.decompressLZData(lzdata);
			if (jsonString && jsonString[0] == "{"){
				LCstorage["com.nuclearunicorn.kittengame.savedata"] = lzdata;
			} else {
				throw "Integrity check failure";
			}

			this.load();
			this.msg($I("save.import.msg"));

			this.render();

            callback();
        } catch (e) {
            console.log("Couldn't import the save of the game:", e.stack);
            callback(e);
        }
	},

	/**
	 * Oh brave and noble soul, before adding a line to this method, please read this:
	 * 
	 * My intention for KG was to have a game where you would never have a method called a 'migrate save'
	 * I lost this battle long time ago and here we are.
	 * 
	 * Save migration must be considered as a measure of a last resolve, when everything else fails
	 * Whenever possible, we should resolve to the code being backward compatible. Every time we bump a save version,
	 * god kills a kitten somewhere.
	 *
	 * @param {SaveData} save - mutated in place, one saveVersion step at a time
	 * @returns {SaveData} the same object, now at the current saveVersion
	 */

	migrateSave: function(save) {
		if (save.saveVersion === undefined) {
			save.saveVersion = 1;
		}

		if (save.saveVersion == 1) {
			// Move Lunar Outpost and Moon Base from programs to moon planet
			if (save.space && save.space.programs && save.space.planets) {
				var buildings = [];
				for (var i = 0; i < save.space.programs.length; i++) {
					var program = save.space.programs[i];
					if (program.name == "moonOutpost" || program.name == "moonBase") {
						program.unlocked = true;
						buildings.push(program);
						save.space.programs.splice(i, 1);
						// Next element has moved back into current index because of splice
						i--;
					}
				}
				for (var i = 0; i < save.space.planets.length; i++) {
					if (save.space.planets[i].name == "moon") {
						save.space.planets[i].buildings = buildings;
						break;
					}
				}
			}

			save.saveVersion = 2;
		}

		if (save.saveVersion == 2) {
			// Move !noStackable programs from programs to cath planet
			if (save.space && save.space.programs && save.space.planets) {
				var buildings = [];
				for (var i = 0; i < save.space.programs.length; i++) {
					var program = save.space.programs[i];
					if (program.name == "spaceElevator" || program.name == "sattelite" || program.name == "spaceStation") {
						program.unlocked = true;
						buildings.push(program);
						save.space.programs.splice(i, 1);
						// Next element has moved back into current index because of splice
						i--;
					}
				}
				save.space.planets.push({name: "cath", buildings: buildings});
			}

			save.saveVersion = 3;
		}

		if (save.saveVersion == 3) {
			// Use .on instead of .val and .enabled for all buildings
			if (save.buildings) {
				for (var i = 0; i < save.buildings.length; i++) {
					save.buildings[i].on = save.buildings[i].val;
				}
			}

			save.saveVersion = 4;
		}

		if (save.saveVersion == 4) {
			// Use .on instead of .val and .enabled for all buildings
			if (save.religion && save.religion.ru) {
				for (var i = 0; i < save.religion.ru.length; i++) {
					var saveRU = save.religion.ru[i];
					// Hack to fix old saves
					if (saveRU.researched && (saveRU.val == 0 || saveRU.val == null)) {
						saveRU.val = 1;
					}
					saveRU.on = saveRU.val;
				}
			}
			if (save.space) {
				if (save.space.programs) {
					for (var i = 0; i < save.space.programs.length; i++) {
						if (save.space.programs[i].researched) {
							save.space.programs[i].on = 1;
							save.space.programs[i].val = 1;
						}
					}
				}
				if (save.space.planets) {
					for (i = 0; i < save.space.planets.length; i++){
						var planet = save.space.planets[i];
						if (planet.buildings){
							for (var j = 0; j < planet.buildings.length; j++){
								var building = planet.buildings[j];
								building.on = building.val;
							}
						}
					}
				}
			}

			save.saveVersion = 5;
		}

		if (save.saveVersion == 5) {
			// Move energy into a true resource
			if (save.time && save.time.energy && save.resources) {
				var changement = false;
				for (var i = 0; i < save.resources.length; i++) {
					var res = save.resources[i];
					if (res.name == "temporalFlux") {
						res.value = save.time.energy;
						changement = true;
						break;
					}
				}
				if (!changement) {
					var resTE = {
						name : "temporalFlux",
						title:  $I("resources.temporalFlux.title"),
						description: "",
						type : "exotic",
						craftable: false,
						visible: false,
						persists: true,
						value: save.time.energy
					};
					save.resources.push(resTE);
				}
			}

			save.saveVersion = 6;
		}

		if (save.saveVersion == 6) {
			if (save.religion){
				if (save.religion.zu) {
					for (i = 0; i < save.religion.zu.length; i++){
						save.religion.zu[i].on = save.religion.zu[i].val;
					}
				}
				if (save.religion.tu) {
					for (i = 0; i < save.religion.tu.length; i++){
						save.religion.tu[i].on = save.religion.tu[i].val;
					}
				}
			}
			if (save.time){
				if (save.time.usedCryochambers) {
					for (i = 0; i < save.time.usedCryochambers.length; i++){
						save.time.usedCryochambers[i].on = save.time.usedCryochambers[i].val;
					}
				}
				if (save.time.cfu) {
					for (i = 0; i < save.time.cfu.length; i++){
						save.time.cfu[i].on = save.time.cfu[i].val;
					}
				}
				if (save.time.vsu) {
					for (i = 0; i < save.time.vsu.length; i++){
						save.time.vsu[i].on = save.time.vsu[i].val;
					}
				}
			}

			save.saveVersion = 8;
		}

		if (save.saveVersion == 8) {
			if (typeof(save.challenges) == "undefined"){
				save.challenges = [];
			}
			save.challenges.currentChallenge = null;
			save.saveVersion = 9;
		}

		if (save.saveVersion == 9) {
			if (save.buildings) {
				for (var i = 0; i < save.buildings.length; i++){
					save.buildings[i].unlockable = save.buildings[i].unlocked;
					save.buildings[i].unlocked = false;
				}
			}
			if (save.space && save.space.programs) {
				for (var i = 0; i < save.space.programs.length; i++) {
					if (save.space.programs[i].name == "rorschachMission" && save.space.programs[i].on == 1) {
						var centaurusSystemMission = {
							name: "centaurusSystemMission",
							val: 0,
							on: 0,
							unlocked: true
						};
						save.space.programs.push(centaurusSystemMission);
					}
				}
			}

			save.saveVersion = 10;
		}

		if (save.saveVersion == 10) {
			if (save.resources){
				for (var i = 0; i < save.resources.length; i++){
					save.resources[i].unlocked = false;
				}
			}

			save.saveVersion = 11;
		}

		if (save.saveVersion == 11) {
			if (typeof(save.challenges) == "undefined"){
				save.challenges = [];
			}
			if (save.religion && save.religion.ru) {
				for (var i = 0; i < save.religion.ru.length; i++) {
					if (save.religion.ru[i].name == "transcendence" && save.religion.ru[i].on == 1) {
						var atheism = {
							name: "atheism",
							researched: false,
							unlocked: true
						};
						if (typeof save.challenges.challenges == "undefined") {
							save.challenges.challenges = [];
						}
						save.challenges.challenges.push(atheism);
						break;
					}
				}
			}

			save.saveVersion = 12;
		}

		if (save.saveVersion == 12) {
			if (save.religion && save.religion.tcratio && save.religion.tu) {
				var transcendenceLevel = Math.max(0, Math.round(Math.log(10 * this.getUnlimitedDR(save.religion.tcratio, 0.1))));
				for (var i = 0; i < save.religion.tu.length; i++) {
					if (transcendenceLevel >= this.religion.getTU(save.religion.tu[i].name).tier) {
						save.religion.tu[i].unlocked = true;
					}
				}
			}

			save.saveVersion = 13;
		}

		if (save.saveVersion == 13) {
			if (save.challenges && save.challenges.challenges) {
				for (var i = 0; i < save.challenges.challenges.length; i++) {
					if (save.challenges.challenges[i].name == "atheism") {

						save.challenges.challenges[i].unlocked = false;

						if (save.science && save.science.techs) {
							for (var j = 0; j < save.science.techs.length; j++) {
								if (save.science.techs[j].name == "voidSpace" && save.science.techs[j].researched == true) {
									save.challenges.challenges[i].unlocked = true;
								}
							}
						}

					}
				}
			}

			save.saveVersion = 14;
		}

		if (save.saveVersion == 14) {
			if (save.space && save.space.planets) {
				for (var planetId in save.space.planets){
					var planet = save.space.planets[planetId];
					if (planet.buildings){
						for (var buildingId in planet.buildings) {
							var building = planet.buildings[buildingId];
							if (typeof(building.unlocked) != "undefined") {
								building.unlockable = building.unlocked;
							} else {
								building.unlockable = false;
							}
						}
					}
				}
			}

			save.saveVersion = 15;
		}

		return save;

	},

	/** @param {any} ui - see js/ui.js; the web and mobile builds pass different ones */
    setUI: function(ui){
        this.ui = ui;
        ui.setGame(this);
        this.console.ui = ui;
    },

	render: function(){
        if (!this.ui){
            throw "Unable to render game state, no UI manager";
        }

        this.ui.render();

		// Once we have rendered the page immidiately update it in order to
		// reduce flicker
		this.ui.update();
		this.calendar.update();
	},

	/**
	 * Returns an estimated production amount per tick for a given resource.
	 *
	 * If calcAutomatedEffect is true, it will also estimate the conditional effects for automated structures,
	 * like smelters or calciners. calcAutomatedEffect should be typically off, or you will give DOUBLE resources for auto structures
	 *
	 * If season is provided, the method will use given season modifiers for resource estimation.
	 * Current resource will be used otherwise.
	 */


	//====================== ONE DAY =====================================
	/*getResourcePerTick: function(resName, calcAutomatedEffect, season){
		var stack = this.getResourcePerTickStack(resName, season);
		var perTick = this.getStackPerTick(stack, calcAutomatedEffect, season);

		return perTick;
	},

	getStackPerTick: function(stack, calcAutomatedEffect, season){
		var perTick = 0;

		for (var i = 0; i< stack.length; i++){
			var s = stack[i];

			if (s.length){
				perTick += this.getStackPerTick(s, calcAutomatedEffect, season) || 0;
			}

			if (s.automated && !calcAutomatedEffect){
				continue;
			}

			if (s.type == "fixed"){
				perTick += s.value || 0;
			} else if (s.type == "ratio"){
				perTick *= (1 + s.value || 0);
			}

		}

		if (isNaN(perTick)){
			return 0;
		}
		return perTick;
	}, */

	/**
	 * The authoritative per-tick number for a resource. `getResourcePerTickStack`
	 * below recomputes the same thing as a displayable breakdown - the two must be
	 * kept in step by hand.
	 * @param {string} resName
	 * @param {any} [season] - season override; the current one is used otherwise
	 * @returns {number} 0 rather than NaN when the maths degenerates
	 */
	calcResourcePerTick: function(resName, season){
		var res = this.resPool.get(resName);

		// BUILDING PerTickBase
		var perTick = this.getEffect(res.name + "PerTickBase");

		// SPACE RATIO CALCULATION
		var spaceRatio = 1 + this.getEffect("spaceRatio");
		if (this.workshop.get("spaceManufacturing").researched && res.name != "uranium"){
			var factory = this.bld.get("factory");
			spaceRatio *= (1 + factory.on * factory.effects["craftRatio"] * 0.75);
		}

		// +SPACE PerTickBase
		var perTickBaseSpace = this.getEffect(res.name + "PerTickBaseSpace") * spaceRatio;

		perTick += perTickBaseSpace;

		// *SEASON MODIFIERS
		perTick *= this.calendar.getWeatherMod(res);

		// +VILLAGE JOB PRODUCTION
		var resMapProduction = this.village.getResProduction();
		var resProduction = resMapProduction[res.name] ? resMapProduction[res.name] : 0;
		
		// +HOLY GENOCIDE SCALING BONUS

		//TODO: calculate prod scaling effect differently for HG
		var hgScalingBonus = this.religion.getHGScalingBonus();
		
		//var hgScalingBonus = Math.pow(1.01, this.religion.getTU("holyGenocide").val * 2);
		resProduction = resProduction * hgScalingBonus;

		//resProduction = resProduction * (1 + this.getEffect("simScalingRatio"));
		perTick += resProduction;

		// +VILLAGE JOB PRODUCTION (UPGRADE EFFECTS JOBS)
		var workshopResRatio = this.getEffect(res.name + "JobRatio");
		perTick += resProduction * workshopResRatio;


		// +*BEFORE PRODUCTION BOOST (UPGRADE EFFECTS GLOBAL)
		perTick *= 1 + this.getEffect(res.name + "GlobalRatio");

		// +*BUILDINGS AND SPACE PRODUCTION
		perTick *= 1 + this.getEffect(res.name + "Ratio");

		// +*RELIGION EFFECTS
		perTick *= 1 + this.getEffect(res.name + "RatioReligion");

		// +*AFTER PRODUCTION BOOST (UPGRADE EFFECTS SUPER)
		perTick *= 1 + this.getEffect(res.name + "SuperRatio");

		// +*AFTER PRODUCTION REDUCTION (SPECIAL STEAMWORKS HACK FOR COAL)
		var steamworks = this.bld.get("steamworks");
		var swEffectGlobal = steamworks.effects[res.name + "RatioGlobal"];
		if (steamworks.on > 0 && swEffectGlobal) {
			perTick *= 1 + swEffectGlobal;
		}

		// *PARAGON BONUS
		var paragonProductionRatio = this.prestige.getParagonProductionRatio();
		if (resName == "catnip" && this.challenges.isActive("winterIsComing")) {
			paragonProductionRatio = 0; //winter has come
		}

		perTick *= 1 + paragonProductionRatio;

		// *POLLUTION MODIFIER
		if (res.name == "catnip"){
			perTick *= 1 + this.bld.pollutionEffects["catnipPollutionRatio"];
		}

		//ParagonSpaceProductionRatio definition 1/4
		var paragonSpaceProductionRatio = 1 + paragonProductionRatio * 0.05;

		// +BUILDING AUTOPROD
		var perTickAutoprod = this.getEffect(res.name + "PerTickAutoprod");
		    perTickAutoprod *= paragonSpaceProductionRatio;
			perTickAutoprod *= (1 + this.getEffect("rankLeaderBonusConversion") * ((this.village.leader) ? this.village.leader.rank : 0));
		perTick += perTickAutoprod;

		// *MAGNETOS PRODUCTION BONUS
		if (!res.transient && this.bld.get("magneto").on > 0 && res.name != "catnip"){

			var steamworks = this.bld.get("steamworks");
			var swRatio = steamworks.on > 0 ? (1 + steamworks.effects["magnetoBoostRatio"] * steamworks.on) : 1;
			if (res.name != "oil"){
				perTick *= 1 + (this.getEffect("magnetoRatio") * swRatio);
			}

			//ParagonSpaceProductionRatio definition 2/4
			paragonSpaceProductionRatio += paragonSpaceProductionRatio * this.getEffect("magnetoRatio") * swRatio; //These special cases need to die in a hole

		}

		// +*REACTOR PRODUCTION BONUS
		if (!res.transient && res.name != "uranium" && res.name != "catnip"){
			perTick *= 1 + this.getEffect("productionRatio");

			//ParagonSpaceProductionRatio definition 3/4
			paragonSpaceProductionRatio += paragonSpaceProductionRatio * this.getEffect("productionRatio");
		}

		// +*FAITH BONUS
		perTick *= 1 + this.religion.getSolarRevolutionRatio() * (1 + ((res.name == "wood" || res.name == "catnip")? this.bld.pollutionEffects["solarRevolutionPollution"] : 0));
		
		//+COSMIC RADIATION
		if (!this.opts.disableCMBR && res.name != "coal") {
			perTick *= 1 + this.getCMBRBonus();
		}

		//ParagonSpaceProductionRatio definition 4/4
		paragonSpaceProductionRatio *= 1 + this.religion.getSolarRevolutionRatio();

		// +AUTOMATED PRODUCTION BUILDING
		perTick += this.getEffect(res.name + "PerTickProd");

		// +AUTOMATED PRODUCTION SPACE (FULL BONUS)
		perTick += (this.getEffect(res.name + "PerTickAutoprodSpace") * spaceRatio) * (1 + (paragonSpaceProductionRatio - 1) * this.getEffect("prodTransferBonus"));
		// +AUTOMATED PRODUCTION SPACE (NOT FULL BONUS)
		perTick += this.getEffect(res.name + "PerTickSpace") * spaceRatio;


		//CYCLE EFFECTS
		// Already added because it's space building improvements.

		//CYCLE FESTIVAL EFFECTS

		var effects = {};
		effects[resName] = perTick;
		this.calendar.cycleEffectsFestival(effects);
		perTick = effects[resName];

		// +BUILDING AND SPACE PerTick
		perTick += this.getEffect(res.name + "PerTick") * (1+ this.getEffect(res.name + "PerTickRatio"));

		// -EARTH CONSUMPTION
		var resMapConsumption = this.village.getResConsumption();
		var resConsumption = resMapConsumption[res.name] || 0;
		resConsumption *= 1 + this.getEffect(res.name + "DemandRatio");
		if (res.name == "catnip" && this.village.sim.kittens.length > 0 && this.village.happiness > 1) {
			var hapinnessConsumption = Math.max(this.village.happiness * (1 + this.getEffect("hapinnessConsumptionRatio")) - 1, 0);
			if (this.challenges.isActive("anarchy")) {
				resConsumption += resConsumption * hapinnessConsumption * (1 + this.getEffect(res.name + "DemandWorkerRatioGlobal"));
			} else {
				resConsumption += resConsumption * hapinnessConsumption * (1 + this.getEffect(res.name + "DemandWorkerRatioGlobal")) * (1 - this.village.getFreeKittens() / this.village.sim.kittens.length);
			}
		}
		// +POLICY EFFECTS

		//necrocracy global effect
		perTick *= (1 + (this.resPool.get("sorrow").value * this.getEffect("blsProductionBonus")));
		//pact Global Production Ratio- effect from pacts per pyramid
		var pyramidGlobalProductionRatio = this.getEffect("pyramidGlobalProductionRatio");
		perTick *= 1 + pyramidGlobalProductionRatio;

		//pyramid faith ratio
		if (res.name=="faith"){
			var pyramidFaithRatio = this.getEffect("pyramidFaithRatio");
			perTick *= 1 + pyramidFaithRatio;
		}
		//policy ratio effects
		perTick *= (1 + this.getEffect(res.name + "PolicyRatio"));

		perTick += resConsumption;
		if (isNaN(perTick)){
			return 0;
		}

		return perTick;
	},
	/**
	 * Appends the modifiers that apply to every sub-stack (necrocracy, policy,
	 * destruction) so each nested group totals up the same way the flat maths does.
	 * @param {ResStack} array - mutated in place
	 * @param {string} resName
	 * @returns {ResStack} the same array
	 */
	addGlobalModToStack: function(array, resName){
		var game = this;
		if (game.science.getPolicy("necrocracy").researched){
			array.push({
				name: $I("res.stack.necrocracy"),
				type: "ratio",
				value: game.getEffect("blsProductionBonus") * game.resPool.get("sorrow").value,
			});
		}
		array.push({
			name: $I("res.stack.policy"),
			type: "ratio",
			value: game.getEffect(resName + "PolicyRatio")
		});
		array.push({
			name: $I("res.stack.destruction"),
			type: "ratio",
			value: game.getEffect("pyramidGlobalProductionRatio")
		});
		return array;
	},
	/**
	 * Generates a stack of resource modifiers. (TODO: use it with resource per tick calculation logic)
	 * @param {string} resName
	 * @param {boolean} [calcAutomatedEffect]
	 * @param {any} [season]
	 * @returns {ResStack} undefined for an unknown resource
	 */
	getResourcePerTickStack: function(resName, calcAutomatedEffect, season){
		/** @type {ResStack} */
		var stack = [];

		var res = null;
		for (var i in this.resPool.resources){
			var _res = this.resPool.resources[i];
			if (_res.name == resName){
				res = _res;
				break;
			}
		}

		if (!res){
			//console.error("Unable to fetch resource stack for resName '" + resName + "'");
			return;
		}

		// BUILDING PerTickBase
		stack.push({
			name: $I("res.stack.production"),
			type: "fixed",
			value: this.getEffect(res.name + "PerTickBase")
		});

		// SPACE RATIO CALCULATION
		var spaceRatio = 1 + this.getEffect("spaceRatio");
		if (this.workshop.get("spaceManufacturing").researched && res.name != "uranium"){
			var factory = this.bld.get("factory");
			spaceRatio *= (1 + factory.on * factory.effects["craftRatio"] * 0.75);
		}

		// +SPACE PerTickBase
		var perTickBaseSpaceStack = [];
		//---->
			perTickBaseSpaceStack.push({
				name: $I("res.stack.spaceProduction"),
				type: "fixed",
				value: this.getEffect(res.name + "PerTickBaseSpace")
			});
			perTickBaseSpaceStack.push({
				name: $I("res.stack.spaceProductionBonus"),
				type: "ratio",
				value: spaceRatio - 1
			});
			this.addGlobalModToStack(perTickBaseSpaceStack, resName);
		//<----
		stack.push(perTickBaseSpaceStack);

		// *SEASON MODIFIERS
		stack.push({
			name: $I("res.stack.weather"),
			type: "ratio",
			value: this.calendar.getWeatherMod(res) - 1
		});

		// +VILLAGE JOB PRODUCTION
		var resMapProduction = this.village.getResProduction();
		var hgScalingBonus = this.religion.getHGScalingBonus() - 1;
		var villageStack = [];
		//---->
				villageStack.push({
					name: $I("res.stack.village"),
					type: "fixed",
					value: resMapProduction[res.name] || 0
				});
				villageStack.push({
					name: $I("res.stack.holyGenocide"),
					type: "ratio",
					value: hgScalingBonus
				});
				villageStack.push({
					name: $I("res.stack.tools"),
					type: "ratio",
					value: this.getEffect(res.name + "JobRatio")
				});
		//<----
		stack.push(villageStack);

		// +*BEFORE PRODUCTION BOOST (UPGRADE EFFECTS GLOBAL)
		stack.push({
			name: $I("res.stack.upgrades"),
			type: "ratio",
			value: this.getEffect(res.name + "GlobalRatio")
		});

		// +*BUILDINGS AND SPACE PRODUCTION
		stack.push({
			name: $I("res.stack.buildings"),
			type: "ratio",
			value: this.getEffect(res.name + "Ratio")
		});

		// +*RELIGION EFFECTS
		stack.push({
			name: $I("res.stack.religion"),
			type: "ratio",
			value: this.getEffect(res.name + "RatioReligion")
		});

		// +*AFTER PRODUCTION BOOST (UPGRADE EFFECTS SUPER)
		stack.push({
			name: $I("res.stack.boost"),
			type: "ratio",
			value: this.getEffect(res.name + "SuperRatio")
		});

		// +*AFTER PRODUCTION REDUCTION (SPECIAL STEAMWORKS HACK FOR COAL)
		var steamworks = this.bld.get("steamworks");
		var swEffectGlobal = steamworks.effects[res.name + "RatioGlobal"];
		if (steamworks.on > 0 && swEffectGlobal ){
			stack.push({
				name: $I("res.stack.steamworks"),
				type: "ratio",
				value: swEffectGlobal
			});
		}

		// *PARAGON BONUS
		var paragonProductionRatio = this.prestige.getParagonProductionRatio();
		if (resName == "catnip" && this.challenges.isActive("winterIsComing")) {
			paragonProductionRatio = 0; //winter has come
		}

		stack.push({
			name: $I("res.stack.paragon"),
			type: "ratio",
			value: paragonProductionRatio
		});

		// *POLLUTION MODIFIER
		if (res.name == "catnip"){
			stack.push({
				name: $I("res.stack.pollution"),
				type: "ratio",
				value: this.bld.pollutionEffects["catnipPollutionRatio"]
			});
		}

		//ParagonSpaceProductionRatio definition 1/4
		var paragonSpaceProductionRatio = 1 + paragonProductionRatio * 0.05;
		var rankLeaderBonusConversion = this.getEffect("rankLeaderBonusConversion") * ((this.village.leader) ? this.village.leader.rank : 0);
		// +BUILDING AUTOPROD
		var buildingAutoprod = [];
		// ---->
			buildingAutoprod.push({
				name: $I("res.stack.convProd"),
				type: "fixed",
				value: this.getEffect(res.name + "PerTickAutoprod")
			});
			buildingAutoprod.push({
				name: $I("res.stack.paragon"),
				type: "ratio",
				value: paragonProductionRatio * 0.05
			});
			buildingAutoprod.push({
				name: $I("res.stack.rankLeaderBonusConversion"),
				type: "ratio",
				value: rankLeaderBonusConversion
			});
		//<----
		stack.push(buildingAutoprod);

		// *MAGNETOS PRODUCTION BONUS
		if (!res.transient && this.bld.get("magneto").on > 0 && res.name != "catnip"){

			var steamworks = this.bld.get("steamworks");
			var swRatio = steamworks.on > 0 ? (1 + steamworks.effects["magnetoBoostRatio"] * steamworks.on) : 1;
			if (res.name != "oil"){
				stack.push({
					name: $I("res.stack.magnetos"),
					type: "ratio",
					value: this.getEffect("magnetoRatio") * swRatio
				});
			}

			//ParagonSpaceProductionRatio definition 2/4
			paragonSpaceProductionRatio += paragonSpaceProductionRatio * this.getEffect("magnetoRatio") * swRatio; //These special cases need to die in a hole
		}

		// +*REACTOR PRODUCTION BONUS
		if (!res.transient && res.name != "uranium" && res.name != "catnip") {
			stack.push({
				name: $I("res.stack.reactors"),
				type: "ratio",
				value: this.getEffect("productionRatio")
			});

			//ParagonSpaceProductionRatio definition 3/4
			paragonSpaceProductionRatio += paragonSpaceProductionRatio * this.getEffect("productionRatio");

		}

		// +*FAITH BONUS
		stack.push({
			name: $I("res.stack.solarRevolution"),
			type: "ratio",
			value: this.religion.getSolarRevolutionRatio()
		});
		if ((res.name == "wood" || res.name == "catnip") && this.religion.getSolarRevolutionRatio() > 0){
			stack.push({
				name: $I("res.stack.pollution"),
				type: "ratioIndent",
				value: this.bld.pollutionEffects["solarRevolutionPollution"]
			});
		}

		if (!this.opts.disableCMBR && res.name != "coal") {
			stack.push({
				name: "CMBR",
				type: "ratio",
				value: this.getCMBRBonus()
			});
		}

		//ParagonSpaceProductionRatio definition 4/4
		paragonSpaceProductionRatio *= 1 + this.religion.getSolarRevolutionRatio();
		
        //policy effects:
		//necrocracy global effect
		//TODO: consider moving it to calculateEffects
        if (this.science.getPolicy("necrocracy").researched){
            stack.push({
                name: $I("res.stack.necrocracy"),
                type: "ratio",
                value: this.getEffect("blsProductionBonus") * this.resPool.get("sorrow").value,
            });
		}
		var pyramidGlobalProductionRatio = this.getEffect("pyramidGlobalProductionRatio");
		stack.push({
			name: $I("res.stack.destruction"),
			type: "ratio",
			value: pyramidGlobalProductionRatio
		});
		var pyramidFaithRatio = this.getEffect("pyramidFaithRatio");
		if (res.name == "faith"){
			stack.push({
                name: $I("res.stack.extermination"),
				type: "ratio",
				value: pyramidFaithRatio
			});
		}
		// +*POLICY
		stack.push({
			name: $I("res.stack.policy"),
			type: "ratio",
			value: this.getEffect(res.name + "PolicyRatio")
		});
		
		// +AUTOMATED PRODUCTION BUILDING
		stack.push({
			name: $I("res.stack.convProd"),
			type: "fixed",
			value: this.getEffect(res.name + "PerTickProd")
		});
		stack.push({ // extra-compare with this.calcResourcePerTick
			name: $I("res.stack.convCons"),
			type: "fixed",
			value: this.getEffect(res.name + "PerTickCon")
		});

		// +AUTOMATED PRODUCTION SPACE
		var perTickAutoprodSpaceStack = [];
		var spaceParagonSubStack = [];
		//---->
			perTickAutoprodSpaceStack.push({
				name: $I("res.stack.spaceConvProd"),
				type: "fixed",
				value: this.getEffect(res.name + "PerTickAutoprodSpace")
			});
			this.addGlobalModToStack(perTickAutoprodSpaceStack, resName);
			perTickAutoprodSpaceStack.push({
				name: $I("res.stack.spaceProdBonus"),
				type: "ratio",
				value: spaceRatio - 1
			});
			var transferBonus = this.getEffect("prodTransferBonus");
			// if transferBonus == 0, then it won't show up in the tooltip, but
			// spaceParagon would still show up, which would make the tooltip
			// look very misleading. so we manually hide the paragon line in
			// this case; it's not useful anyways when transferBonus == 0.
			if (transferBonus != 0) {
				spaceParagonSubStack.push({
					name: $I("res.stack.spaceParagon"),
					type: "ratio",
					value: paragonSpaceProductionRatio - 1
				});
			}
			spaceParagonSubStack.push({
				name: $I("res.stack.bonusTransf"),
				type: "multiplier",
				value: transferBonus
			});
			perTickAutoprodSpaceStack.push(spaceParagonSubStack);
		//<----
		stack.push(perTickAutoprodSpaceStack);

		// +AUTOMATED PRODUCTION SPACE
		var perTickSpace = [];
		//---->
			perTickSpace.push({
				name: $I("res.stack.spaceConvProd"),
				type: "fixed",
				value: this.getEffect(res.name + "PerTickSpace")
			});
			perTickSpace.push({
				name: $I("res.stack.spaceProdBonus"),
				type: "ratio",
				value: spaceRatio - 1
			});
			this.addGlobalModToStack(perTickSpace, resName);
		//<----
		stack.push(perTickSpace);

		//CYCLE EFFECT
		// Can't be displayed because it's space building improvements.

		//CYCLE FESTIVAL EFFECTS
		var effects = {};
		effects[res.name] = 1;
		this.calendar.cycleEffectsFestival(effects);
		var cycleEffect = effects[resName] - 1;

		stack.push({
			name: $I("res.stack.festival"),
			type: "ratio",
			value: cycleEffect
		});

		var baselineModifiers = [];
		// +BUILDING AND SPACE PerTick

		//----->
			baselineModifiers.push({
				name: $I("res.stack.baseline"),
				type: "fixed",
				value: this.getEffect(res.name + "PerTick")
			});
			baselineModifiers.push({
				name: $I("res.stack.baselineRatio"),
				type: "ratio",
				value: this.getEffect(res.name + "PerTickRatio")
			});
			this.addGlobalModToStack(baselineModifiers, resName);
		stack.push(baselineModifiers);
		//<----

		// VILLAGE CONSUMPTION (certain jobs)
		var resAmbassadorConsumption = this.diplomacy.getAmbassadorEffect(res.name + "ConsumptionAmbassadors");
		if (resAmbassadorConsumption > 0) {
			stack.push({
				name: $I("res.stack.village"),
				type: "fixed",
				value: -resAmbassadorConsumption
			});
		}

		// +CRAFTING JOB PRODUCTION
		stack.push({
			name: $I("res.stack.engineer"),
			type: "fixed",
			value: this.workshop.getEffectEngineer(res.name, true)
		});
		stack.push({
			name: $I("res.stack.engineer"),
			type: "fixed",
			value: this.workshop.getConsumptionEngineers()[res.name] || 0 
		});
		// -EARTH CONSUMPTION && -SPACE CONSUMPTION
		var resMapConsumption = this.village.getResConsumption();
		var resConsumption = resMapConsumption[res.name] || 0;
		resConsumption *= 1 + this.getEffect(res.name + "DemandRatio");
		if (res.name == "catnip" && this.village.sim.kittens.length > 0 && this.village.happiness > 1) {
			var hapinnessConsumption = Math.max(this.village.happiness * (1 + this.getEffect("hapinnessConsumptionRatio")) - 1, 0);
			if (this.challenges.isActive("anarchy")) {
				resConsumption += resConsumption * hapinnessConsumption * (1 + this.getEffect(res.name + "DemandWorkerRatioGlobal"));
			} else {
				resConsumption += resConsumption * hapinnessConsumption * (1 + this.getEffect(res.name + "DemandWorkerRatioGlobal")) * (1 - this.village.getFreeKittens() / this.village.sim.kittens.length);
			}
		}
		stack.push({
			name: $I("res.stack.demand"),
			type: "fixed",
			value: resConsumption
		});

		// BIOME EXPLORATION
		if (res.name == "manpower"){
			var biome = this.village.getBiome(this.village.map.currentBiome);
			if (biome){
				var exploreCost = this.village.map.getExplorationCost();
				stack.push({
					name: $I("res.stack.exploration"),
					type: "fixed",
					value: -exploreCost
				});
			}
		}

		// TIME extra-compare with this.calcResourcePerTick
		stack.push({
			name: $I("res.stack.time"),
			type: "ratio",
			value: this.timeAccelerationRatio()
		});
		return stack;
	},

	/**
	 * @param {string} resName
	 * @returns {ResStack} undefined for an unknown resource
	 */
	getResourcePerDayStack: function(resName){
		/** @type {ResStack} */
		var stack = [];
		var res = null;
		for (var resId in this.resPool.resources){
			var _res = this.resPool.resources[resId];
			if (_res.name == resName){
				res = _res;
				break;
			}
		}

		if (!res){
			//console.error("Unable to fetch resource stack for resName '" + resName + "'");
			return;
		}
		if (resName == "necrocorn"){
			stack.push({
				name: $I("res.stack.pactsConsumption"),
				type: "perDay",
				value: this.religion.pactsManager.getNecrocornDeficitConsumptionModifier() * this.getEffect("necrocornPerDay")
			});
		} else {
			stack.push({
				name: $I("res.stack.buildings"),
				type: "perDay",
				value: this.getEffect(res.name + "PerDay")
			});
		}
		if (resName == "necrocorn"){
			//ReligionManager keeps data on all corruption-related effects
			var corruptionModifiers = this.religion.corruptionCached || [];
			/** @type {ResStackEntry} */
			var corruptionTotal = {
				name: $I("res.stack.corruptionPerDay"),
				type: "perDay",
				value: (corruptionModifiers.finalCorruptionPerTick || 0) * this.calendar.ticksPerDay
			};
			/** @type {ResStack} */
			var corruptionStack = [];
			corruptionStack.push(corruptionTotal);
			for (var i = 0; i < corruptionModifiers.length; i += 1) {
				var modifier = corruptionModifiers[i];
				switch (modifier.behavior) {
				case "additive":
					//Convert a per-tick effect to a per-day effect.
					corruptionStack.push({
						name: modifier.label,
						type: "perDay",
						value: modifier.value * this.calendar.ticksPerDay
					});
					//Hack to make the total corruption line display if net corruption is 0 due to Siphoning
					if (modifier.value) {
						corruptionTotal.forceDisplay = true;
					}
					break;
				case "multiplicative":
					//Convert a multiplier to a ratio bonus
					corruptionStack.push({
						name: modifier.label,
						type: "ratio",
						value: modifier.value - 1
					});
					break;
				}
			}
			stack.push(corruptionStack);
		}

		return stack;
	},

	/**
	 * @param {string} resName
	 * @returns {ResStack} undefined for an unknown resource
	 */
	getResourceOnYearStack: function(resName){
		/** @type {ResStack} */
		var stack = [];
		var res = null;
		for (var i in this.resPool.resources){
			var _res = this.resPool.resources[i];
			if (_res.name == resName){
				res = _res;
				break;
			}
		}

		if (!res){
			//console.error("Unable to fetch resource stack for resName '" + resName + "'");
			return;
		}
		stack.push({
			name: $I("res.stack.buildings"),
			type: "perYear",
			value: this.getEffect(res.name + "Production")
		});
		if (resName == "antimatter" && this.resPool.energyProd < this.resPool.energyCons){

			stack.push({
				name: $I("ui.energy.tooltip"), //kinda hack text
				type: "perYear",
				value: -this.getEffect(res.name + "Production")
			});
		}
		stack.push({
			name: $I("res.stack.policy"),
			type: "ratio",
			value: this.getEffect(res.name + "PolicyRatio")
		});

		stack.push({
			name: $I("res.stack.chronicler"),
			type: "ratio",
			value: this.getEffect("pyramidPerYearRatio")
		});
		return stack;
	},
	/** @returns {number} */
	getCMBRBonus: function() {
		return this.isCMBREnabled ? 0.2 : 0;
	},

	/**
	 * @param {string} tag - craft category, e.g. "metal"; leaders boost their own
	 * @returns {number}
	 */
	getCraftRatio: function(tag) {
		return this.getEffect("craftRatio") + this.village.getEffectLeader("engineer", 0) + this.village.getEffectLeader(tag, 0);
	},

	/**
	 * @param {string} craftedResName
	 * @returns {number}
	 */
	getResCraftRatio: function(craftedResName) {
		if (craftedResName == "wood") {
			var policyRefineRatio = this.getEffect("refinePolicyRatio");
			var refineRatio =  (policyRefineRatio) + (1 + policyRefineRatio) * this.getEffect("refineRatio");
			return this.ironWill
				? ((1 + refineRatio) * (1 + this.getEffect("woodRatio") + this.getEffect("woodPolicyRatio") / 3)) - 1
				: refineRatio;
		}

		var ratio = this.getCraftRatio(this.resPool.get(craftedResName).tag);

		if (craftedResName == "blueprint") {
			var bpRatio = this.getEffect("cadBlueprintCraftRatio");
			var scienceBldAmt = this.bld.get("library").val + this.bld.get("academy").val + this.bld.get("observatory").val + this.bld.get("biolab").val;
			ratio += scienceBldAmt * bpRatio;
		}

		if (craftedResName == "kerosene") {
			var fRatio = 0.75 * this.getEffect("factoryRefineRatio");	//25% penalty
			var amt = this.bld.get("factory").on;
			ratio *= 1 + amt * fRatio;
		}

		//get resource specific craft ratio (like factory bonus)
		ratio += this.getEffect(craftedResName + "CraftRatio") || 0;
		ratio *= 1 + this.getEffect(craftedResName + "GlobalCraftRatio") || 0;

		return ratio;
	},

	/**
	 * Update all tab managers, resources and UI controls
	 */
	update: function(){
		this.ticksBeforeSave--;

		if (this.ticksBeforeSave == 0){
			this.save();

			this.ui.displayAutosave();
		}

		this.timer.beforeUpdate();

		//hack hack hack
		this.updateModel();
		if (this.time.isAccelerated && this.ticks % 2 == 0){
			this.updateModel();
		}

		//hack end
		this.time.update();

        //--------------------
        //  Update UI state
        //--------------------
        this.ui.update();

		this.timer.afterUpdate();
	},

	/** @returns {number} the effective tick rate, so countdowns respect time acceleration */
	getTicksPerSecondUI: function() {
		return this.ticksPerSecond * (1 + this.timeAccelerationRatio());
	},

	/** @returns {number} */
	timeAccelerationRatio: function() {
		return this.time.isAccelerated ? 0.5 : 0;
	},

	/**
	 * How should it be:
	 *
	 * a) we need to use smaller tick intervals (10 per second instead of 5 per second)
	 * b) in accelerated time we will update models more often
	 * c) but we will keep ui update in a old steady rate
	 *
	 * How it works now:
	 *
	 * update method can just kick twice in the accelerated mode
	 *
	 */
	updateModel: function(){

		this.resPool.update();

		this.bld.update();
		//this.science.update();

		//business logic goes there
		//maybe it will be a good idea to move it elsewhere?

		//for example, here kitten resources are calculated per effect, this logic could be unified
		this.village.maxKittens = Math.floor(this.getEffect("maxKittens"));

		this.village.update();
		this.workshop.update();
		this.diplomacy.update();
		this.religion.update();
		this.space.update();
		this.challenges.update();

		/*for (i in this.managers){
		 if (this.managers[i].update){
		 this.managers[i].update();
		 }
		 }*/

		this.resPool.resConsHackForResTable();

		//pollution per tick
		this.bld.cathPollution += this.bld.cathPollutionPerTick;
		if (this.bld.cathPollution < 0) {this.bld.cathPollution = 0;}

		//nah, kittens are not a resource anymore (?)
		var kittens = this.resPool.get("kittens");
		kittens.value = this.village.getKittens();	//just a simple way to display them
		kittens.maxValue = this.village.sim.maxKittens; //for HG

		this.timer.update();
	},

	/** @param {Event} event */
	huntAll: function(event){
		event.preventDefault();
		this.village.huntAll();
	},

	/** @param {Event} event */
	praise: function(event){
		event.preventDefault();
		this.religion.praise();
	},

	/** @param {Event} event */
	sacrificeAllUnicorns: function(event){
		event.preventDefault();
		this.religion.sacrificeAllUnicorns();
	},

	/**
	 * Updates a perTickValue of resource for UI
	 */
	updateResources: function(){
		/**
		* Updating per tick value is actually a heavy operation. Why don't we do it per 3 tick and cache values?
		*/
		for (var i = 0; i < this.resPool.resources.length; i++){
			var res = this.resPool.resources[i];
			if (res.calculatePerTick) {
				res.perTickCached = this.fixFloatPointNumber(this.calcResourcePerTick(res.name));
			}
		}
	},

	/**
	 * Reads the value cached by `updateResources`, so this is cheap to call per frame.
	 * @param {string} resName
	 * @param {boolean} [withConversion] - fold in what converters (smelters, ...) consume
	 * @returns {number}
	 */
	getResourcePerTick: function(resName, withConversion){
		var res = this.resPool.get(resName);
		if (res.calculatePerTick) {
			return withConversion ? res.perTickCached + this.getResourcePerTickConvertion(res.name) : res.perTickCached;
		} else {
			return 0;
		}
	},

	/**
	 * @param {string} resName
	 * @returns {number}
	 */
	getResourcePerDay: function(resName){
		if (resName == "necrocorn"){
			return (this.religion.pactsManager.getNecrocornDeficitConsumptionModifier() * this.getEffect(resName + "PerDay") +
			this.religion.getCorruptionPerTick() * this.calendar.ticksPerDay);
		}
		return this.getEffect(resName + "PerDay");
	},
	/**
	 * @param {string} resName
	 * @returns {number}
	 */
	getResourceOnYearProduction: function(resName){
		if (resName == "antimatter"){
			if (this.resPool.energyProd < this.resPool.energyCons){
				return 0;
			}
		}
		return this.getEffect(resName + "Production") * (1 + this.getEffect(resName + "PolicyRatio")) * (1 + this.getEffect("pyramidPerYearRatio"));
	},
	//Returns a negative value if something consumes the resource each tick (such as a Smelter)
	/**
	 * @param {string} resName
	 * @returns {number}
	 */
	getResourcePerTickConvertion: function(resName) {
		return this.fixFloatPointNumber(this.getEffect(resName + "PerTickCon") -
			/*use subtraction because getAmbassadorEffect returns positive value*/
			this.diplomacy.getAmbassadorEffect(resName + "ConsumptionAmbassadors"));
	},

	/**
	 * @param {string} resName
	 * @param {number} value - how many batches to craft
	 */
	craft: function(resName, value){
		this.workshop.craft(resName, value);
		this.updateResources();
	},

	/** @param {string} resName */
	craftAll: function(resName){
		if (resName == "wood"){
			var game = this;
			// some way to protect people from refining all catnip during the winter
			if (this.getResourcePerTick("catnip", true) < 0){
				this.ui.confirm($I("kittens.craft.confirmation.title"), $I("kittens.craft.confirmation.msg"), function() {
					game.workshop.craftAll(resName);
					game.updateResources();
				});
				return;
			}
			var calendar = this.calendar,
                winterDays = calendar.daysPerSeason -
                (calendar.getCurSeason().name === "winter" ? calendar.day : 0);
            var catnipPerTick = game.winterCatnipPerTick;
			// adviser will advise against spending so much catnip that you couldn't survive the winter!
			if ((0 + winterDays * catnipPerTick * calendar.ticksPerDay) <= 0){
				this.ui.confirm($I("kittens.craft.confirmation.title"), $I("general.food.advisor.text"), function() {
					game.workshop.craftAll(resName);
					game.updateResources();
				});
				return;
			}
		}
		this.workshop.craftAll(resName);
		this.updateResources();
	},

	/**
	 * @param {any} bld - any metadata with a `prices` array
	 * @returns {string[]} the names of the resources it costs
	 */
	getRequiredResources: function(bld){
		var res = [];
		if (bld && bld.prices) {
			for (var i = 0; i < bld.prices.length; i++){
				res.push(bld.prices[i].name);
			}
		}
		return res;
	},

	/**
	 * Attaches onMouseOver/onMouseOut events to a given DOM node in order to display tooltip.
	 * All tooltips will reuse the same container.
	 *
	 * @param {HTMLElement} container
	 * @param {any} resRef - the resource this node stands for
	 */
	attachResourceTooltip: function(container, resRef){
		UIUtils.attachTooltip(this, container, 0, 100, function() {
			if (this.getResourcePerTick(resRef.name, false) != 0
				|| this.getResourcePerTickConvertion(resRef.name) != 0
				|| this.workshop.getEffectEngineer(resRef.name) != 0
				|| this.getResourcePerDay(resRef.name) != 0
				|| (this.getResourceOnYearProduction(resRef.name) != 0 || resRef.name == "antimatter")
				|| (resRef.name == "kittens" && this.village.sim.kittens.length < this.village.sim.maxKittens)
				|| this.workshop.getConsumptionEngineers()[resRef.name]
			){
				return this.getDetailedResMap(resRef);
			}

            return '';
		});

		dojo.connect(container, "onmouseover", this, function(){
			dojo.style(container, "fontWeight", "bold");
		});

		dojo.connect(container, "onmouseout", this, function(){
			dojo.style(container, "fontWeight", "normal");
		});
	},

	/**
	 * Returns a flat map of resource production
	 * @param {any} res
	 * @returns {string} the rendered tooltip body
	 */
	getDetailedResMap: function(res){
		if (res.calculatePerDay){
			var resStack = this.getResourcePerDayStack(res.name),
				resString = this.processResourcePerTickStack(resStack, res, 0, false), //processResourcePerTickStack can work with perDay stack
				resPerDay = this.getResourcePerDay(res.name);
				if (this.opts.usePercentageResourceValues){
					resString += "<br> " + $I("res.netGain") + ": " + this.getDisplayValueExt(resPerDay, true, true);
				}
			if (resPerDay < 0) {
				var resourceValue = res.value;
				var fractionOfCurrentDayElapsed = this.calendar.day - Math.floor(this.calendar.day);
				if (res.name == "necrocorn") {
					//Fast-forward a fractional amount of days' worth of pacts consumption:
					var perDayConsumption = this.religion.pactsManager.getNecrocornDeficitConsumptionModifier() * this.getEffect("necrocornPerDay");
					resourceValue += fractionOfCurrentDayElapsed * perDayConsumption;
					//Count corruption as fractional necrocorns:
					resourceValue += this.religion.corruption;

					//This isn't completely accurate; it doesn't account for if we reach 0 necrocorns before next corruption.
					//It also doesn't account for if we run out of alicorns to corrupt.
				}

				var toZero = this.calendar.ticksPerDay * resourceValue / (-resPerDay * this.getTicksPerSecondUI());
				if (res.value == 0) {
					toZero = 0;
				}
				resString += "<br>" + $I("res.toZero") + ": " + this.toDisplaySeconds(toZero.toFixed());
			}
			if (res.name == "necrocorn"){
				var toNextNecrocorn = (1 - this.religion.corruption)/(this.religion.getCorruptionPerTick() * this.getTicksPerSecondUI());
				if (toNextNecrocorn > 0){
					resString += "<br>" + $I("res.toNextNecrocorn") + ": " + this.toDisplaySeconds(toNextNecrocorn.toFixed());
				}
			}
			return resString;
		} else if (res.calculateOnYear){
			var resStack = this.getResourceOnYearStack(res.name),
				resString = this.processResourcePerTickStack(resStack, res, 0, false), //processResourcePerTickStack can work with perDay stack
				resPerYear = this.getResourceOnYearProduction(res.name);
				if (this.opts.usePercentageResourceValues){
					resString += "<br> " + $I("res.netGain") + ": " + this.getDisplayValueExt(resPerYear, true, true);
				}
				if (res.name == "antimatter" && resPerYear && this.resPool.energyWinterProd < this.resPool.energyCons){
					resString += "<br> " + $I("effectsMgr.winterEnergy.warning.title");
				}
			return resString;
		}
		if (res.name == "kittens"){
			var nextKittenProgress = this.village.sim.nextKittenProgress;
			var kittensPerTick = this.village.calculateKittensPerTick();
			var resString =  " [" + ( nextKittenProgress * 100 ).toFixed()  + "%]";
			resString += "<br>" + $I("res.toNextKitten") + " " + this.toDisplaySeconds(
				(1 - nextKittenProgress)/(kittensPerTick * this.getTicksPerSecondUI()));
			return resString;
		}
		var resStack = this.getResourcePerTickStack(res.name),
			resString = this.processResourcePerTickStack(resStack, res, 0, false),
			resPerTick = this.getResourcePerTick(res.name, true);

		if (this.opts.usePercentageResourceValues){
			resString += "<br> " + $I("res.netGain") + ": " + this.getDisplayValueExt(resPerTick, true, true);
		}

		if (resPerTick < 0) {
			var toZero = res.value / (-resPerTick * this.getTicksPerSecondUI());
			resString += "<br>" + $I("res.toZero") + ": " + this.toDisplaySeconds(toZero.toFixed());
		} else {
			if (res.maxValue && res.value < res.maxValue) {
				var toCap = (res.maxValue - res.value) / (resPerTick * this.getTicksPerSecondUI());
				if (toCap){
					resString += "<br>" + $I("res.toCap") + ": " + this.toDisplaySeconds(toCap.toFixed());
				}
			}
		}
		return resString;
	},

	/**
	 * Walks the (nested) stack and renders the rows worth showing. Ratio rows are
	 * suppressed until a fixed row has been emitted, otherwise they modify nothing.
	 * @param {ResStack} resStack
	 * @param {any} res
	 * @param {number} depth - nesting level, drives indentation
	 * @param {boolean} [hasFixed] - whether a fixed row was already emitted above
	 * @returns {string}
	 */
	processResourcePerTickStack: function(resStack, res, depth, hasFixed) {
		var resString = "";
		if (depth < 2) {
			hasFixed = false;
		}

		for (var i = 0; i < resStack.length; i++) {
			var stackElem = resStack[i];

			if (Array.isArray(stackElem)) {
				var subStack = this.processResourcePerTickStack(stackElem, res, depth + 1, hasFixed);
				if (subStack.length) {
					resString += subStack;
					hasFixed = true;
				}
				continue;
			}

			if (!stackElem.forceDisplay) { //Hack to make necrocorn corruption display properly in some situations
				if (!stackElem.value || (stackElem.type != "fixed" && stackElem.type != "perDay" &&
				stackElem.type != "perYear" && !hasFixed)) {
					//If hasFixed is false, no need to display ratio effects
					continue;
				}
			}

			resString += this.getStackElemString(stackElem, res, i == 0 ? depth - 1 : depth);
			if (stackElem.type == "fixed" || stackElem.type == "perDay" || stackElem.type == "perYear") {
				//Below this point, display all ratio effects
				hasFixed = true;
			}
		}

		return resString;
	},

	/**
	 * A single row of the resource breakdown. The cells are formatted here, but laying them
	 * out is up to the UI: the web tooltip is a flat text blob, mobile builds real rows.
	 * @param {ResStackEntry} stackElem
	 * @param {any} res
	 * @param {number} indent nesting depth of the stack element, 0 or less for a top level row
	 * @returns {string}
	 */
	getStackElemString: function(stackElem, res, indent){
		return this.ui.formatStackRow(this.formatStackLabel(stackElem, indent), this.formatStackValue(stackElem));
	},

	/**
	 * Label cell: the tree indentation prefix, then the name of the effect.
	 * @param {ResStackEntry} stackElem
	 * @param {number} indent
	 * @returns {string}
	 */
	formatStackLabel: function(stackElem, indent){
		var label = "";

		for (var j = 0; j < indent - 1; j++) {
			label += "<span style='visibility: hidden;'>|-> </span>";
		}
		if (indent > 0) {
			label += "|-> ";
		}
		if (stackElem.type == "ratioIndent") {
			label += "|->";
		}

		return label + stackElem.name + ":";
	},

	/**
	 * Value cell, formatted according to the stack element type.
	 * @param {ResStackEntry} stackElem
	 * @returns {string} empty for a type with no display form
	 */
	formatStackValue: function(stackElem){
		if (stackElem.type == "fixed") {
			return this.getDisplayValueExt(stackElem.value, true, true);
		} else if (stackElem.type == "ratio" || stackElem.type == "ratioIndent") {
			//Percentages are rounded here and handed over as a string on purpose:
			//getDisplayValue passes a non-number straight through rather than
			//re-rounding it. Keep the cast until that pass-through is retired.
			return this.getDisplayValueExt(/** @type {any} */ ((stackElem.value * 100).toFixed()), true) + "%";
		} else if (stackElem.type == "multiplier") {
			return "×" + this.getDisplayValueExt(/** @type {any} */ ((stackElem.value * 100).toFixed())) + "%";
		} else if (stackElem.type == "perDay") {
			return (stackElem.value > 0 ? "+" : "") + this.getDisplayValueExt(stackElem.value) + "/" + $I("res.per.day");
		} else if (stackElem.type == "perYear") {
			return (stackElem.value > 0 ? "+" : "") + this.getDisplayValueExt(stackElem.value) + "/" + $I("res.per.year");
		}

		return "";
	},

	/**
	 * Outputs a formatted representation of time.  If the input is negative or NaN, treats it as zero instead.
	 * @param {number|string} secondsRaw Either a number or a string representing a number.
	 * @returns {string} For the sake of consistency, all whitespace is trimmed from beginning & end.
	 */
	toDisplaySeconds : function (secondsRaw) {
		if (secondsRaw == Infinity) {
			return "&infin;";
		}
		//We parseFloat because sometimes the numbers are so huge they end up being converted to scientific notation
		var sec_num = Math.floor(parseFloat(String(secondsRaw)));
		if (isNaN(sec_num) || sec_num < 1) {
			return "0" + $I("unit.s");
		}

		var year_secs = 86400 * 365;

		var years = Math.floor(sec_num / year_secs);
		var days = 0;
		var hours = 0;
		var minutes = 0;
		var seconds = 0;
		if (years < 1e6) {
			//At certain large values, we get weird behavior caused by floating-point rounding errors.
			//Avoid these by only calculating these if the number of years is small.
			days    = Math.floor((sec_num - (years * year_secs)) / 86400);
			hours   = Math.floor((sec_num - (years * year_secs) - (days * 86400)) / 3600);
			minutes = Math.floor((sec_num - (years * year_secs) - (days * 86400 + hours * 3600)) / 60);
			seconds = sec_num - (years * year_secs) - (days * 86400) - (hours * 3600) - (minutes * 60);
		}

        //years is a count above and a formatted string below, so it gets its own variable
        var yearsFormatted = years > 0 ? this.getDisplayValueExt(years) : "";

	    var timeFormated = "";
        if ( yearsFormatted ) { timeFormated = yearsFormatted + $I("unit.y") + " "; }
	    if ( days ) { timeFormated += days + $I("unit.d") + " "; }
        if ( !yearsFormatted ){
            if ( hours ) {  timeFormated += hours + $I("unit.h") + " "; }
            if ( minutes) { timeFormated += minutes + $I("unit.m") + " "; }
            if ( seconds ) { timeFormated += seconds + $I("unit.s") + " "; }
        }

	    return timeFormated.trim();
	},

	/**
	 * The same as toDisplaySeconds, but converts ingame days into xYears xDays
	 * Just for aestetical pleasness
	 * @param {number|string} daysRaw
	 * @returns {string}
	 */
	toDisplayDays: function(daysRaw){
		var daysNum = Math.floor(parseFloat(String(daysRaw)));
		if (isNaN(daysNum) || daysNum < 1) {
			return "0" + $I("unit.d");
		}

		var daysPerYear = this.calendar.daysPerSeason * this.calendar.seasonsPerYear;
		var years = Math.floor(daysNum / daysPerYear);
		var days = 0;
		if (years < 1e9) {
			//Avoid weird floating-point behavior by only calculating days if the number of years is small.
			days = daysNum - years * daysPerYear;
		}

		//years is a count above and a formatted string below, so it gets its own variable
		var yearsFormatted = years > 0 ? this.getDisplayValueExt(years) : "";

		var timeFormatted = "";
		if ( yearsFormatted ) { timeFormatted = yearsFormatted + $I("unit.y") + " "; }
		if ( days ) { timeFormatted += days + $I("unit.d") + " "; }

		return timeFormatted.trim();
	},

	/**
	 * @param {number} percentage - a ratio, i.e. 0.5 renders as "50"
	 * @param {number} precision - decimal places; ignored unless precisionFixed
	 * @param {boolean} [precisionFixed] - honour `precision` instead of picking one
	 * @returns {string} no trailing "%" - callers append it
	 */
	toDisplayPercentage: function(percentage, precision, precisionFixed) {
		percentage *= 100;
		if (precisionFixed) {
			// Prevent 100% whereas it's not really reached
			percentage -= 1 / Math.pow(10, precision);
			if (percentage < 0) {
				percentage = 0;
			}
		} else {
			percentage = this.fixFloatPointNumber(percentage);
			// Seek optimal precision
			if (percentage - Math.floor(percentage) != 0) {
				precision = 1;
				if (percentage * 10 - Math.floor(percentage * 10) != 0) {
					precision = 2;
					if (percentage * 100 - Math.floor(percentage * 100) != 0) {
						precision = 3;
						if (percentage * 1000 - Math.floor(percentage * 1000) != 0) {
							precision = 4;
							if (percentage * 10000 - Math.floor(percentage * 10000) != 0) {
								precision = 5;
								if (percentage * 100000 - Math.floor(percentage * 100000) != 0) {
									precision = 6;
									if (percentage * 1000000 - Math.floor(percentage * 1000000) != 0) {
										precision = 7;
										if (percentage * 10000000 - Math.floor(percentage * 10000000) != 0) {
											precision = 8;
										}
									}
								}
							}
						}
					}
				}
			}
		}

		return percentage.toFixed(precision);
	},

	//shamelessly copied from Sandcastle Builder code
	//Ordered largest first - getDisplayValueExt takes the first limit it clears.
	/** @type {{limit: number, divisor: number, postfix: [string, string]}[]} */
	postfixes: [
		{limit:1e210,divisor:1e210,postfix:["Q"," Quita"]},
		{limit:1e42,divisor:1e42,postfix:["W"," Wololo"]},
		{limit:1e39,divisor:1e39,postfix:["L"," Lotta"]},
		{limit:1e36,divisor:1e36,postfix:["F"," Ferro"]},
		{limit:1e33,divisor:1e33,postfix:["H"," Helo"]}, //or Ballard
		{limit:1e30,divisor:1e30,postfix:["S"," Squilli"]},
		{limit:1e27,divisor:1e27,postfix:["U"," Umpty"]},

		{limit:1e24,divisor:1e24,postfix:["Y"," Yotta"]},
		{limit:1e21,divisor:1e21,postfix:["Z"," Zeta"]},
		{limit:1e18,divisor:1e18,postfix:["E"," Exa"]},
		{limit:1e15,divisor:1e15,postfix:["P"," Peta"]},
		{limit:1e12,divisor:1e12,postfix:["T"," Tera"]},
		{limit:1e9,divisor:1e9,postfix:["G"," Giga"]},
		{limit:1e6,divisor:1e6,postfix:["M"," Mega"]},
		{limit:9e3,divisor:1e3,postfix:["K"," Kilo"]} //WHAT
	],

	/**
	 * Determines the display name & display value (formatting it as per second, or as a percentage, etc.) of a given effect.
	 * @param {string} effectName	The internal name of the effect.
	 * @param {number} effectValue	The value of the effect.
	 * @param {boolean} [showIfZero]	Determines whether we still show an effect with zero value, or if that effect remains hidden.
	 * 					I added it just in case someone wants to use it in the future.
	 * 					If the effect would be hidden for any other reason, then this flag doesn't do anything.
	 * @returns {{displayEffectName: string, displayEffectValue: string}}
	 * 			null if the effect shouldn't be displayed (because it's hidden or because it's zero).
	 * 			Otherwise, returns a table with the following keys:
	 * 			displayEffectName = the localized title;
	 * 			displayEffectValue = the value of the effect, formatted & localized properly
	 */
	getEffectDisplayParams: function(effectName, effectValue, showIfZero) {
		var effectMeta = this.getEffectMeta(effectName);
		if (effectMeta.type === "hidden") {
			return null;	//Don't display because it's a hidden effect.
		}
		if (effectMeta.resName && !this.resPool.get(effectMeta.resName).unlocked) {
			return null;	//hide resource-related effects if we did not unlocked this effect yet
		}
		if (!effectValue && !showIfZero) {
			return null;	//Don't display because the size of the value is zero & the flag is set to hide things that are zero.
		}
		var displayEffectName = effectMeta.title;
		var displayEffectValue = "";
		//This code was copy-pasted from core.js with minor changes.
		//display resMax values with global ratios like Refrigeration and Paragon
		if (effectName.substr(-3) === "Max" ) {
			var res = this.resPool.get(effectMeta.resName || effectName.slice(0, -3));
			if (res) { // If res is a resource and not just a variable
				effectValue = this.resPool.addResMaxRatios(res, effectValue);
			}
		}
		if (effectName.substr(-12) === "MaxChallenge") {
			var res = this.resPool.get(effectMeta.resName || effectName.slice(0, -12));
			if (res) { // If res is a resource and not just a variable
				//This is the code used in resources.js to apply LDR to how Challenges affect resource storage.
				var maxValue = this.resPool.addResMaxRatios(res, this.getEffect(res.name + "Max") || 0);
				effectValue = this.getLimitedDR(this.resPool.addResMaxRatios(res, effectValue), maxValue - 1 - this.bld.effectsBase[res.name +'Max']||0);
			}
		}
		if (effectMeta.type === "perTick" && this.opts.usePerSecondValues) {
			// avoid mantisa if we can, later on this can be changed to show scaled up values, e.g. minutes, hours
			var tempVal = Math.abs(effectValue * this.ticksPerSecond), precision;
			if (tempVal >= 0.001) {
				precision = tempVal < 0.01 ? 3 : 2;
				displayEffectValue = this.getDisplayValueExt(
				effectValue * this.ticksPerSecond, false, false, precision) + "/" + $I("unit.sec");
			} else {
				displayEffectValue = this.getDisplayValueExt(
					effectValue * this.ticksPerSecond * 3600, false, false, 2) + "/" + $I("unit.h");
			}
		} else if (effectMeta.type === "perDay"){
			displayEffectValue = this.getDisplayValueExt(effectValue) + "/" + $I("unit.day");
		} else if (effectMeta.type === "perYear"){
			displayEffectValue = this.getDisplayValueExt(effectValue) + "/" + $I("unit.year");
		} else if ( effectMeta.type === "ratio" ) {
			displayEffectValue = this.toDisplayPercentage(effectValue, 2 , false) + "%";
		} else if ( effectMeta.type === "integerRatio" ){
			displayEffectValue = this.getDisplayValueExt(effectValue) + "%";
		} else if ( effectMeta.type === "energy" ){
			//Multiply the displayed values of energy production & consumption by relevant multipliers.
			if (effectName === "energyProduction") {
				effectValue *= this.resPool.getEnergyProductionRatio();
			} else if (effectName === "energyConsumption") {
				effectValue *= this.resPool.getEnergyConsumptionRatio();
			}
			displayEffectValue = this.getDisplayValueExt(effectValue) + $I("unit.watt");
		} else {
			displayEffectValue = this.getDisplayValueExt(effectValue);
		}
		return {
				displayEffectName: displayEffectName,
				displayEffectValue: displayEffectValue
			};
	},

	/**
	 * Converts raw resource value (e.g. 12345.67890) to a formatted representation (i.e. 12.34K)
	 * If 'prefix' flag is true, positive value will be prefixed with '+', e.g. ("+12.34K")
	 * @param {number} value
	 * @param {boolean} [prefix] - prefix positive values with '+'
	 * @param {boolean} [usePerTickHack] - rescale to per-second and append the unit
	 * @param {number} [precision] - decimal places; defaults from opts.forceHighPrecision
	 * @param {string} [postfix] - carried through the "si" recursion, not for callers
	 * @returns {string}
	 */
	getDisplayValueExt: function(value, prefix, usePerTickHack, precision, postfix){

		if (!value){ return "0"; }
		if (value === Infinity) {
			return prefix ? "+∞" : "∞";
		}
		if (value === -Infinity) {
			return "-∞";
		}

		//was a bitwise &=, which coerced the flag to 0/1; same truthiness, no coercion
		usePerTickHack = Boolean(usePerTickHack && this.opts.usePerSecondValues);
		if (usePerTickHack) {
			value = value * this.ticksPerSecond;
		}
		postfix = postfix || "";

		var absValue = Math.abs(value);
		var l = Math.floor(Math.log10(absValue));

		switch (this.opts.notation) {
			case "e":
				if (l >= 4) {
					value /= Math.pow(10, l);
					postfix = "e" + l;
				}
				break;
			case "sie":
				if (l >= 15) {
					value /= Math.pow(10, l);
					postfix = "e" + l;
					break;
				}
				// otherwise, fall through to "si"
			case "si":
			default:
				for (var i = 0; i < this.postfixes.length; i++) {
					var p = this.postfixes[i];
					if (absValue >= p.limit){
						if (usePerTickHack) { // Prevent recursive * this.ticksPerSecond;
							value = value / this.ticksPerSecond;
						}
						return this.getDisplayValueExt(value / p.divisor, prefix, usePerTickHack, precision, postfix + p.postfix[0]);
					}
				}
				break;
		}

		var _value = this.getDisplayValue(value, prefix, precision);
		return _value + postfix + (usePerTickHack ? "/" + $I("unit.sec") : "");
	},

	/**
	 * Formats float value to x.xx or x if value is integer
	 * @param {number} floatVal - anything without .toFixed is returned as-is, see formatStackValue
	 * @param {boolean} [plusPrefix] - prefix positive values with '+'
	 * @param {number} [precision] - defaults from opts.forceHighPrecision
	 * @returns {string}
	 */
	getDisplayValue: function(floatVal, plusPrefix, precision){

		var plusSign = "+";
		if (floatVal <= 0 || !plusPrefix){
			plusSign = "";
		}

		if (!floatVal.toFixed){
			return plusSign + floatVal;
		}

		if (precision === undefined){
			precision = this.opts.forceHighPrecision ? 3 : 2;
		}

		var mantisa = "";

		if (floatVal != 0) {
			var absVal = Math.abs(floatVal);
			if (absVal < 0.01 && precision == 2 || absVal < 0.001 && precision == 3) {
				mantisa = "(...)";
			}
		}

		if (floatVal % 1 === 0){
			var toFixed = floatVal.toFixed();
			return plusSign + toFixed;
		} else {
			var toFixed = floatVal.toFixed(precision);
			return plusSign + toFixed + mantisa;
		}
	},

	/**
	 * @param {number} number
	 * @returns {number} rounded to 7 decimal places, killing float drift
	 */
	fixFloatPointNumber: function(number) {
		// Adjust value because of floating-point error
		var numberAdjusted = Math.floor(number * 10000000) / 10000000;
		if (Math.round((number - numberAdjusted) * 10000000)) {
			numberAdjusted = Math.floor((number + 0.000000000000010) * 10000000) / 10000000;
		}
		return numberAdjusted;
	},

	/** @param {any} tab */
	addTab: function(tab){
		this.tabs.push(tab);
		tab.game = this;
	},

	/** @returns {boolean} */
	isWebWorkerSupported: function(){
		var config = new classes.KGConfig();
		if (config.statics.disableWebWorkers) {
			return false;
		}

		return !dojo.isIE && !!window.Worker;
	},

	/** @returns {number} monotonic where available, wall clock otherwise */
	timestamp: function() {
		return window.performance && window.performance.now ? window.performance.now() : new Date().getTime();
	},

	start: function(){
		if (this.isReadOnly()){
			//a preview is a snapshot: no worker, no interval, no time passing at all
			this.villageTab.updateTab();
			this.workshopTab.updateTab();
			return;
		}

		if (this.isWebWorkerSupported() && this.opts.useWorkers){	//IE10 has a nasty security issue with running blob workers
			console.log("starting web worker...");
			var blob = new Blob([
				"onmessage = function(e) { setInterval(function(){ postMessage('tick'); }, 1000 / " + this.ticksPerSecond + "); }"]);	//no shitty external js
			var blobURL = window.URL.createObjectURL(blob);

			this.worker = new Worker(blobURL);
			this.worker.addEventListener("message", dojo.hitch(this, function(e) {
				this.tick();
			}));
			this.worker.postMessage("tick");
		} else {
			console.log("starting js timer...");
			//some older browser, perhaps IE. Have a nice idling.
			// setInterval function set a fixed interval and if the event was delayed due some browser activity, e.g. rendering/scrolling then two or more events will be put into a queue
			// The problem is that UI looks unresponsive and there are glitches.
			// We have 2 options:
			// 1. Skip events which are really close
			// 2. Use setTimeout function and reset the interval
			// In both cases it will result to drop of number of ticks.
			// One way is to handle it on UI by queuing the update requests.

			/*
				Would still work bad during the scroll
			 */
			clearInterval(this._mainTimer);
			this._mainTimer = setInterval(dojo.hitch(this, this.tick), (1000 / this.ticksPerSecond));

			this._lastFrameTimestamp = this.timestamp();
		}
		// Ensure free kitten markers are up-to-date.
		this.villageTab.updateTab();
		this.workshopTab.updateTab();
		this._publish("game/start");
	},

	/**
	 * Here is a magic
	 * Don't even try to understand it, madness lies here
	 */
	frame: function(){
		var now = this.timestamp(),
			delta = now - this._lastFrameTimestamp;

		if (delta > (1000 / this.ticksPerSecond)) {
			/*dojo.hitch(this, this.tick)();*/
			console.log("tick!");
			this.tick();
		}
		requestAnimationFrame(this.frame);
	},


	tick: function(){
		// Even if the game is paused, scheduler should still be able to obtain a focus
		// to handle cases like save/load/reset
		this.timer.updateScheduledEvents();

		if (this.undoChange) {
			// "Undo button" countdown should still tick while pawsed
			this.undoChange.ttl--;
			if (this.undoChange.ttl <= 0) {
				this.undoChange = null;
				this._publish("server/undoStateChanged");
			}
		}
		if (this.isPaused) {
			// Still update UI if the player gathers catnip while pawsed or something
			this.ui.update();
			return;
		}

		var timestampStart = Date.now();

		this.update();
		this.calendar.tick();
		this.ticks++;

		var timestampEnd = Date.now();

		this.totalUpdateTimeTicks++;

		var tsDiff = timestampEnd - timestampStart;
		this.totalUpdateTime[this.totalUpdateTimeCurrent] += tsDiff;
		this.totalUpdateTimeCurrent = this.totalUpdateTimeCurrent == 4 ? 0 : this.totalUpdateTimeCurrent + 1;

		var avg = (this.totalUpdateTime[0] + this.totalUpdateTime[1] + this.totalUpdateTime[2] + this.totalUpdateTime[3] + this.totalUpdateTime[4]) / this.totalUpdateTimeTicks;
		var avg0 = this.totalUpdateTime[0] / Math.floor((this.totalUpdateTimeTicks - 1) / 5);
		var avg1 = this.totalUpdateTime[1] / Math.floor((this.totalUpdateTimeTicks - 2) / 5);
		var avg2 = this.totalUpdateTime[2] / Math.floor((this.totalUpdateTimeTicks - 3) / 5);
		var avg3 = this.totalUpdateTime[3] / Math.floor((this.totalUpdateTimeTicks - 4) / 5);
		var avg4 = this.totalUpdateTime[4] / Math.floor((this.totalUpdateTimeTicks - 5) / 5);

		if (tsDiff < 10) {
			tsDiff = 10;
		}
		this.fps = {
			ms: tsDiff,
			avg: avg,
			avg0: avg0,
			avg1: avg1,
			avg2: avg2,
			avg3: avg3,
			avg4: avg4
		};

		// Collect fps info every minute or so
		if (this.ticks % (this.ticksPerSecond * 60) == 0 && this.telemetry) {
			var memory = null;
			if (window.performance && window.performance.memory) {
				memory = performance.memory.usedJSHeapSize;
			}

			this.telemetry.logEvent("fps", {
				ms: this.fps.ms,
				avg: this.fps.avg,
				memory: memory
			});
		}
	},

	restartFPSCounters: function() {
        this.totalUpdateTime[0] = 0;
        this.totalUpdateTime[1] = 0;
        this.totalUpdateTime[2] = 0;
        this.totalUpdateTime[3] = 0;
        this.totalUpdateTime[4] = 0;
        this.totalUpdateTimeCurrent = 0;
        this.totalUpdateTimeTicks = 5;
	},

	reset: function(){
		if (this.isReadOnly()){
			return;
		}
		var msg = $I("reset.confirmation.title") + "\n\n"
		        + $I("reset.confirmation.msgbase");
		if (this.resPool.get("kittens").value > 70) {
			msg += " " + $I("reset.confirmation.msg70");
		} else if (this.resPool.get("kittens").value > 60) {
			msg += " " + $I("reset.confirmation.msg60");
		} else if (this.resPool.get("kittens").value <= 35) {
			msg += " " + $I("reset.confirmation.msg35");
		}
		if (this.workshop.get("tachyonModerator").researched) {
			//Add a warning if there is enough stored chrono furnace fuel to get more paragon points
			var toNextMillennium = 1000 - this.calendar.year % 1000; //Measured in years, from 1 to 1000.
			if (this.time.getCFU("blastFurnace").heat >= toNextMillennium * 100) {
				msg += "\n\n" + $I("reset.confirmation.stored.chrono.fuel");
			}
		}
		var game = this;
		game.ui.confirm($I("reset.confirmation.title"), msg, function() {
			game.challenges.onRunReset();
			if (game.calendar.day < 0) {
				game.achievements.unlockBadge("abOwo");
			}
			for (var i = 0; i < game.challenges.challenges.length; i++){
				game.challenges.challenges[i].pending = false;
			}
			if (game.village.loadoutController.loadouts){
				if (game.village.loadoutController.loadouts.length == 0){
					game.village.loadoutController.toggleDefaultLoadouts();
				}
			}
			game.resetAutomatic();
		});
	},

	resetAutomatic: function() {
		this.timer.scheduleEvent(dojo.hitch(this, function(){
			this._resetInternal();
			this.mobileSaveOnPause = false;
			window.location.reload();
		}));
	},

	discardParagon: function() {
		var game = this;
		var confirmDiscard = false;

		if (game.resPool.get("paragon").value <= 100) {
			game.ui.confirm("", $I("discardParagon.confirmation.msg1"), function() {
				game.doDiscardParagon();
			});
		} else {
			game.ui.confirm("", $I("discardParagon.confirmation.msg1"), function() {
				game.ui.confirm("", $I("discardParagon.confirmation.msg2"), function() {
					if (!game.ironWill || game.achievements.get("spaceOddity").starUnlocked) {
						game.doDiscardParagon();
					} else {
						game.ui.confirm("", $I("discardParagon.confirmation.msgIW"), function() {
							game.doDiscardParagon();
						});
					}
				});
			});
		}
	},

	doDiscardParagon: function() {
		this.resPool.get("burnedParagon").value += this.resPool.get("paragon").value;
		this.resPool.get("paragon").value = 0;
		this.ironWill = Boolean(this.ironWill && this.achievements.get("spaceOddity").starUnlocked);
		//TODO: add some special hidden effect for this mechanics
	},

	/**
	 * @param {number} kittens - population at the moment of the reset
	 * @returns {number} karma kittens earned, on a rising scale past 35 kittens
	 */
    _getKarmaKittens: function(kittens){
        var karmaKittens = 0;

        if (this.challenges.getChallenge("anarchy").researched) {
		kittens = kittens * 2;
        }

        if (kittens > 35){
			karmaKittens += (kittens - 35);
		}

		if (kittens > 60){
			karmaKittens += (kittens - 60) * 3;
		}

		if (kittens > 100){
			karmaKittens += (kittens - 100) * 4;
		}

		if (kittens > 150){
			karmaKittens += (kittens - 150) * 5;
		}

		if (kittens > 300){
			karmaKittens += (kittens - 300) * 10;
		}

		if (kittens > 750){
			karmaKittens += (kittens - 750) * 15;
		}

        return karmaKittens;
    },

	/** @returns {number} bonus karma zebras, scaled off total science spent */
	_getBonusZebras: function(){
		var totalScience = 0;
		var bonusZebras = 0;

		var anachronomancy = this.prestige.getPerk("anachronomancy");
		if (this.science.get("archery").researched && this.karmaZebras < 10){
			bonusZebras = 1;
		}
		for (var i = 0; i < this.science.techs.length; i++){
			var tech = this.science.techs[i];
			if (tech.name == "chronophysics" && anachronomancy.researched){
				continue;
			}
			if (tech.researched){
				for (var j in tech.prices){
					if (tech.prices[j].name == "science"){
						totalScience += tech.prices[j].val;
						break;
					}
				}
			}
		}
		bonusZebras += Math.floor(this.getLimitedDR(totalScience / 10000, 100));
		return bonusZebras;
	},

	/**
	 * What a reset would pay out right now. Read-only - safe to call for the UI.
	 * @returns {{karmaKittens: number, paragonPoints: number}}
	 */
	getResetPrestige: function(){
		var kittens = Math.round(
			this.resPool.get("kittens").value * (1 + this.getEffect("simScalingRatio"))
			//this.resPool.get("kittens").value * ((this.village.maxKittensRatioApplied)?(1 + this.getEffect("simScalingRatio")):1)
		);

		var karmaKittens = this.karmaKittens;
		if (kittens > 35){
			karmaKittens += this._getKarmaKittens(kittens);
		}

		var paragonPoints = 0;
		if (kittens > 70){
			paragonPoints = (kittens - 70);
		}
		return {
			karmaKittens: karmaKittens,
			paragonPoints: paragonPoints
		};
	},

	/**
	 * Builds the post-reset save from scratch - what survives a reset is decided
	 * here and nowhere else - writes it to localStorage and pauses the game so no
	 * autosave can land before the caller reloads the page.
	 * @returns {SaveData}
	 */
	_resetInternal: function(){
		var _prestige = this.getResetPrestige();

		var karmaKittens = _prestige.karmaKittens,
			paragonPoints = _prestige.paragonPoints;

		var addRes = {
			"paragon": paragonPoints
		};

		var karmaZebras = parseInt(String(this.karmaZebras));	//hack
		//that's all folks

		var addStats = {
			"totalParagon": paragonPoints,
			"totalResets": 1
		};

		this.telemetry.logEvent("reset", this.stats.getStat("totalResets").val + 1);

        var stats = [];
        for (var i = 0; i < this.stats.stats.length; i++){
            var stat = this.stats.stats[i];

            var val = stat.val;
            if (addStats[stat.name] > 0){
                val += addStats[stat.name];
            }
            stats.push({
                name: stat.name,
                val: val
            });
        }

        var statsCurrent = [];
        for (var i = 0; i < this.stats.statsCurrent.length; i++){
            statsCurrent.push({
                name: this.stats.statsCurrent[i].name,
                val: 0
            });
        }


		//-------------------------- very confusing and convoluted stuff related to karma zebras ---------------
		var bonusZebras = this._getBonusZebras();
		if (this.resPool.get("zebras").value > 0 && this.ironWill){
			karmaZebras += bonusZebras;
		}

		//pre-reset faith so people who forgot to do it properly would not be screwed
		var faithRatio = this.religion.faithRatio;
		if (this.religion.getRU("apocripha").on) {
			faithRatio += this.religion.getApocryphaResetBonus(1);
		}
		//------------------------------------------------------------------------------------------------------

		var saveRatio = this.bld.get("chronosphere").val > 0 ? this.getEffect("resStasisRatio") : 0; // resStasisRatio excepted when challenge
		if (saveRatio > 1) {
			this.achievements.unlockBadge("wheredThisComeFrom");
		}

		// Trigger a save to make sure we're working with most recent data
		this.save();

		var lsData = this._parseLSSaveData();
		if (!lsData){
			lsData = {
				game: {},
				stats: {},
				statsCurrent: {},
				achievements: {}
			};
		}

		dojo.mixin(lsData.game, {
			karmaKittens: 		karmaKittens,
			karmaZebras: 		karmaZebras,
			ironWill : 			(saveRatio > 0 || this.time.getVSU("cryochambers").on > 0) ? false : true,			//chronospheres or cryochaimbers will disable IW. Post Apocalypse allows cryochaimbers to work without chronospheres working.
			startedWithoutChronospheres: saveRatio == 0 && this.time.getVSU("cryochambers").on == 0,
			deadKittens: 		0,
			isCMBREnabled:		false
		});

		//------------ we can now carry some of the resources through reset ------------
		var newResources = [];

		var anachronomancy = this.prestige.getPerk("anachronomancy");
		var fluxCondensator = this.workshop.get("fluxCondensator");
		for (var resId in this.resPool.resources) {
			var res = this.resPool.resources[resId];

			// undefined is NOT falsy here
			if (res.persists === false
			 || (res.craftable && res.name != "wood" && !fluxCondensator.researched)) {
				continue;	//>:
			}
			var value = 0;

			if (res.name == "timeCrystal") {
				if (anachronomancy.researched) {
					value = res.value;
				}
			} else if (res.persists) {
				value = res.value;
			} else {
				if (!res.craftable || res.name == "wood") {
					value = res.value * saveRatio;
					if (res.name == "void") {
						value = Math.floor(value);
					}
				} else if (res.value > 0) {
					value = Math.sqrt(res.value) * saveRatio * 100;
				}
			}

			if (addRes[res.name] > 0) {
				value += addRes[res.name];
			}

			if (value > 0) {
				var newRes = this.resPool.createResource(res.name);
				newRes.value = Math.min(value, Number.MAX_VALUE);
				newResources.push(newRes);
			}
		}

		var newKittens = [];
		var cryochambers = this.time.getVSU("cryochambers").on;

		var cathPollution = 0;

		if (cryochambers > 0) {
			this.village.sim.sortKittensByExp();
			this.village.sim.sortKittensByFavorite();
			newKittens = this.village.sim.kittens.slice(-cryochambers);
			for (var kittenId in newKittens) {
				delete newKittens[kittenId].job;
				delete newKittens[kittenId].engineerSpeciality;
				newKittens[kittenId].favorite = true;
			}
			var usedCryochambers_reset = this.time.filterMetadata([this.time.getVSU("usedCryochambers")], ["name", "val", "on"]);
			usedCryochambers_reset[0]["val"] = cryochambers;
			usedCryochambers_reset[0]["on"] = cryochambers;
		} else {
			var usedCryochambers_reset = this.time.filterMetadata([this.time.getVSU("usedCryochambers")], ["name", "val", "on"]);
			usedCryochambers_reset[0]["val"] = 0;
			usedCryochambers_reset[0]["on"] = 0;
		}
		if (this.challenges.getChallenge("postApocalypse").pending){
			if (newKittens.length > 0){
				var catnip = this.resPool.get("catnip");
				if (!catnip){
					catnip = this.resPool.createResource("catnip");
				}
				catnip.value = newKittens.length * 1000 * (1 + this.resPool.get("karma").value/100);
				newResources.push(catnip);
			}
			cathPollution = (this.challenges.getChallenge("postApocalypse").on + newKittens.length) * 1e+8 + 1e+11;
		}
		var temporalPress_reset = this.time.filterMetadata([this.time.getCFU("temporalPress")], ["name", "val", "on", "isAutomationEnabled"]);
		//temporalPress_reset is an ARRAY with 1 element: the metadata for Temporal Presses.
		var temporalPressSaved = Math.min(temporalPress_reset[0].val, this.getEffect("temporalPressCap"));
		if (temporalPressSaved > 0){
			temporalPress_reset[0].on = Math.min(temporalPress_reset[0].on, temporalPressSaved);
			temporalPress_reset[0].val = Math.min(temporalPressSaved);
		} else {
			temporalPress_reset[0].on = 0;
			temporalPress_reset[0].val = 0;
			temporalPress_reset[0].isAutomationEnabled = null;
		}

/*
		if (newKittens.length > 0) {
			var usedCryochambers_reset = this.time.filterMetadata([this.time.getVSU("usedCryochambers")], ["name", "val", "on"]);
			usedCryochambers_reset[0]["val"] = newKittens.length;
			usedCryochambers_reset[0]["on"] = newKittens.length;
		} else {
			var usedCryochambers_reset = this.time.filterMetadata([this.time.getVSU("usedCryochambers")], ["name", "val", "on"]);
			usedCryochambers_reset[0]["val"] = 0;
			usedCryochambers_reset[0]["on"] = 0;
		}
*/
		// Set the challenge for after reset
		for (var i = 0; i < this.challenges.challenges.length; i++){
			var challenge = this.challenges.challenges[i];
			if (challenge.pending){
				challenge.pending = false;
				challenge.active = true;
			}
			else {
				challenge.active = false;
			}
		}
		var reservesSaveData = this.challenges.reserves.getSaveData();

		var loadouts = [];
		for (var loadoutId in this.village.loadoutController.loadouts){
			var _loadout = this.village.loadoutController.loadouts[loadoutId].save();
			loadouts.push(_loadout);
		}

		var saveData = {
			saveVersion: this.saveVersion,
			game : lsData.game,
			resources: newResources,
			buildings: [],
			calendar: {
				cryptoPrice: this.calendar.cryptoPrice
			},
			challenges: {
				challenges: this.challenges.filterMetadata(this.challenges.challenges, [ "name",
					"researched" /*deprecated, but still kept in savefile for some reason*/,
					"on", "unlocked", "active" ]),
				reserves: reservesSaveData
			},
			diplomacy: {
				races: []
			},
			prestige: lsData.prestige,
			religion: {
				transcendenceTier: this.religion.transcendenceTier,
				faithRatio: faithRatio,
				activeHolyGenocide: this.religion.getTU("holyGenocide").on,
				zu: [],
				ru: [],
				tu: this.religion.filterMetadata(this.religion.transcendenceUpgrades, ["name", "val", "on", "unlocked"]),
				pact: []
			},
			science: {
				hideResearched: this.science.hideResearched,
				policyToggleResearched: this.science.policyToggleResearched,
				policyToggleBlocked: this.science.policyToggleBlocked,
				techs: [],
				policies: []
			},
			space: {
				hideResearched: this.space.hideResearched,
				programs: [],
				planets: []
			},
			time: {
				cfu: [{
					name: "temporalImpedance",
					unlocked: this.time.getCFU("temporalImpedance").unlocked
				},
					temporalPress_reset[0]
				],
				vsu: [],
				usedCryochambers: usedCryochambers_reset,
				timestamp: Date.now(),
				testShatter: this.time.testShatter
			},
			village :{
				kittens: newKittens,
				jobs: [],
				traits: [],
				hadKittenHunters: false,
				loadouts: loadouts
			},
			workshop: {
				hideResearched: this.workshop.hideResearched,
				upgrades: [],
				crafts: [],
				zebraUpgrades: []
			},
			achievements: lsData.achievements,
			ach: lsData.ach,
			stats: stats,
			statsCurrent: statsCurrent,
			telemetry: {
				guid: this.telemetry.guid
			},
			cathPollution: cathPollution
		};

		if (anachronomancy.researched){
			var chronophysicsTech = this.science.get("chronophysics");
			saveData.science.techs.push({
				name: chronophysicsTech.name,
				unlocked: chronophysicsTech.unlocked,
				researched: chronophysicsTech.researched
			});
		}

		var preparedSaveData = this._prepareSaveData(saveData);
		var saveDataString = this._saveDataToString(preparedSaveData);
		LCstorage["com.nuclearunicorn.kittengame.savedata"] = saveDataString;

		// Hack to prevent an autosave from occurring before the reload completes
		this.isPaused = true;

		return saveData;
	},

	//TO BE USED EXTERNALLY
	/**
	 * @param {number} ratio - exclusive upper bound
	 * @returns {number}
	 */
	rand: function(ratio){
		return this.math.uniformRandomInteger(0, ratio);
	},

	//Karma has no menu. You get served what you deserve.
	updateKarma: function(){
		var stripe = 5;	//initial amount of kittens per stripe
		var karma = this.getUnlimitedDR(this.karmaKittens, stripe);

		var karmaRes = this.resPool.get("karma");
		var karmaPrev = karmaRes.value;
		karmaRes.value = karma;

		//Recalculate some effects if karma amount has changed:
		if (karma != karmaPrev) {
			//Do not call game.upgrade here.  It'll have weird knock-on effects if we do that.
			//Instead, we'll just call calculateEffects & wait for another game system to call updateCaches.
			//Worst-case scenario, that function gets called every 5 ticks anyways.
			var bld = this.bld.get("chapel"); bld.calculateEffects(bld, this);
			var ru = this.religion.getRU("frescoes"); ru.calculateEffects(ru, this);
		}
	},

	// Unlimited Diminishing Return
	//getTriValue
	/**
	 * @param {number} value
	 * @param {number} stripe - smaller values diminish faster
	 * @returns {number}
	 */
	getUnlimitedDR: function(value, stripe) {
		var result = (Math.sqrt(1 + (value / stripe) * 8) - 1) / 2;
		return result == Infinity
			? Math.sqrt(value) / Math.sqrt(stripe) * Math.SQRT2
			: result;
	},

	/**
	 * @param {number} value
	 * @param {number} stripe
	 * @returns {number} the input getUnlimitedDR would map back to `value`
	 */
	getInverseUnlimitedDR: function(value, stripe) {
		return stripe / 2 * value * (value + 1);
	},

	/**
	 * @param {string} tabName - lowercase tab id
	 * @returns {any} undefined if no tab matches
	 */
	getTab: function(tabName) {
		for (var i in this.tabs){
			if (this.tabs[i].tabId.toLowerCase() == tabName){
				return this.tabs[i];
			}
		}
		//Hack because QueueTab is a tab that exists only on mobile
		if (tabName == "queue" && !this.isMobile()) {
			//We have to return *something* so it doesn't throw an error
			return { tabName: "dummy tab", tabId: "Queue", visible: false };
		}
	},

	calculateAllEffects: function() {
		// TODO: delegate this to managers? Can't be done in load unfortunately.
		var getName = function(item){return item.name;};
		var metaKeys = {
				tech: this.science.techs.map(getName),
				policies: this.science.policies.map(getName),
				perks: this.prestige.perks.map(getName),
				jobs: this.village.jobs.map(getName),
				crafts: this.workshop.crafts.map(getName),
				upgrades: this.workshop.upgrades.map(getName),
				buildings: this.bld.buildingsData.map(getName),
				spaceMission: this.space.programs.map(getName),
				spaceBuilding: this.space.spaceBuildingsMap,
				planet: this.space.planets.map(getName),
				chronoforge: this.time.chronoforgeUpgrades.map(getName),
				voidSpace: this.time.voidspaceUpgrades.map(getName),
				zigguratUpgrades: this.religion.zigguratUpgrades.map(getName),
				religion: this.religion.religionUpgrades.map(getName),
				transcendenceUpgrades: this.religion.transcendenceUpgrades.map(getName),
				pacts: this.religion.pactsManager.pacts.map(getName),
				challenges: this.challenges.challenges.map(getName)
			};
		this.upgrade({ buildings: ["warehouse"], spaceBuilding: ["hydroponics"]});
		this.upgrade(metaKeys);
		this.upgrade({policies: ["authocracy"]});
	},

	/**
	 * Resolves an id to the metadata object owning it, dispatching on meta type.
	 * @param {any} unlockId - usually a string; "stages" and "schemes" pass richer values
	 * @param {string} type - one of the cases below
	 * @returns {any} undefined for an unknown type or a race with no embassies
	 */
	getUnlockByName: function(unlockId, type){
		switch (type) {
			case "tabs":
				return this.getTab(unlockId);
			case "schemes":
				return unlockId;
			//--- Bonfire tab
			case "buildings":
				return this.bld.get(unlockId);
			case "stages":
				return this.bld.get(unlockId.bld);
			//--- Village tab
			case "jobs":
				return this.village.getJob(unlockId);
			case "biomes":
				return this.village.getBiome(unlockId);
			//--- Science tab
			case "tech":
				return this.science.get(unlockId);
			case "policies":
				return this.science.getPolicy(unlockId);
			case "perks":
				return this.prestige.getPerk(unlockId);
			//--- Workshop tab
			case "upgrades":
				return this.workshop.get(unlockId);
			case "crafts":
				return this.workshop.getCraft(unlockId);
			case "zebraUpgrades":
				return this.workshop.getZebraUpgrade(unlockId);
			//--- Trade tab
			case "embassies":
				if (unlockId === "cheapest") {
					unlockId = this.diplomacy.getCheapestEmbassy();
				}
				var raceObj = this.diplomacy.get(unlockId);
				if (raceObj.embassyPrices) {
					return raceObj;
				}
				//Else, this race has no embassies
				return undefined;
			//--- Religion tab
			case "zigguratUpgrades":
				return this.religion.getZU(unlockId);
			case "religion":
				return this.religion.getRU(unlockId);
			case "transcendenceUpgrades":
				return this.religion.getTU(unlockId);
			case "pacts":
				return this.religion.getPact(unlockId);
			//--- Space tab
			case "spaceMission":
				return this.space.getProgram(unlockId);
			case "planet":
				return this.space.getPlanet(unlockId);
			case "spaceBuilding":
				return this.space.getBuilding(unlockId);
			//--- Time tab
			case "chronoforge":
				return this.time.getCFU(unlockId);
			case "voidSpace":
				return this.time.getVSU(unlockId);
			//--- Challenges tab
			case "challenges":
				return this.challenges.getChallenge(unlockId);
		}
	},

	/**
	 * Unlock a set of metadata elements based on the meta type and item id
	 * e.g:
	 * {
	 * 	buildings: [...],
	 * 	space: [...]
	 * }
	 * See #getUnlockByName for a full list of types
	 * @param {Record<string, any[]>} list - meta type -> ids to unlock
	 *
	 * TODO: clarify `unlockable` vs unlocked for buildings vs other stuff
	 */
	unlock: function(list) {
		var game = this; 
		for (var type in list) {
			if (list[type].length == 0) {
				return;
			}
			for (var i = list[type].length - 1; i >= 0; i--) {
				var unlockId = list[type][i];
				var newUnlock = this.getUnlockByName(unlockId, type);

				/** 
				 * Multi-unlock mechanism:
				 * 
				 * Source provides _SIGNAL_ throught the .unlocks property
				 * 
				 * e.g.:
				 * 
				 * meta1 -> game.unlock() ->	target meta
				 * meta2 -> game.unlock() /
				 * 
				 * by default any unlock() signal from source should mark target meta as unlocked
				 * 
				 * in case there are complex unlock conditions (say policies),
				 * target meta should evaluate the signal through the evaluateLocks()
				 * and return cancel if not all unlock conditions are satisfied
				 * 
				*/
				if (!newUnlock){
					console.trace();
					console.error("unable to evaluate locks for unlockId '" +unlockId +"', type '" + type + "'");
					continue;
				}
				if (newUnlock.evaluateLocks && !newUnlock.evaluateLocks(game)){
					continue;
				}

				if (type == "tabs") {
					newUnlock.visible = true;
				} else if (type == "buildings") {
					newUnlock.unlockable = true;
				} else if (type == "stages") {
					newUnlock.stages[unlockId.stage].stageUnlocked = true;
				} else {
					if (!newUnlock){
						console.warn("unable to evaluate unlock '", unlockId, "', skipping");
						continue;
					}
					newUnlock.unlocked = true;
				}
			}
		}
	},

	/**
	 * Recalculates effects for a set of metadata elements, same shape as #unlock.
	 * Caches are refreshed before and after, so effects that feed each other settle.
	 * @param {Record<string, any[]>} list - meta type -> ids to recalculate
	 */
	upgrade: function(list){
		this.updateCaches();
		for (var type in list) {
			if (list[type].length == 0) {
				return;
			}
			for (var i = list[type].length - 1; i >= 0; i--) {
				var item = this.getUnlockByName(list[type][i], type);
				if (!item){
					console.error("unable to get unlock by [id]", list[type][i], "[type]", type);
					continue;
				}
				if (item.calculateEffects || item.updateEffects){
					//Call calculateEffects or updateEffects, but don't call both.
					if (item.calculateEffects) {
						item.calculateEffects(item, this);
					} else {
						item.updateEffects(item, this);
					}
					if (type == "spaceBuilding") {
						this.calendar.cycleEffectsBasics(item.effects, item.name);
					}
				}
				if (item.unlockScheme && item.val >= item.unlockScheme.threshold) {
					this.ui.unlockScheme(item.unlockScheme.name);
				}
			}
		}

		//Update caches again to include the latest changes:
		this.updateCaches();
	},

	toggleFilters: function(){
		var filtersDiv = $("#logFilters");
		filtersDiv.toggle();

		$("#filterIcon")[0].innerHTML = filtersDiv.is(":visible") ? "-" : "+";
	},

	/**
	 * Finds the manager object with the given ID.
	 * @param {string} managerId
	 * @returns {any} The requested manager object, or null if the requested object could not be found.
	 */
	getManager: function(managerId) {
		if (typeof(managerId) !== "string") {
			console.error("Error in game#getManager: managerId must be a string!  (Got a " + typeof(managerId) + ".)");
			return null;
		}
		//Search the array of managers; return the one that matches
		for (var i = 0; i < this.managers.length; i += 1) {
			var man = this.managers[i];
			if (man.id == managerId) {
				return man;
			}
		}
		//Else, manager not found
		console.error("Error in game#getManager: manager not found!  (Trying to find \"" + managerId + "\" manager.)");
		return null;
	},

	/**
	 * Opens a fresh undo slot, replacing any pending one.
	 * @returns {UndoChange} the caller is expected to addEvent onto it
	 */
    registerUndoChange: function(){
        var undoChange = new classes.game.UndoChange();
        undoChange.ttl = undoChange._static.DEFAULT_TTL * this.ticksPerSecond;

        this.undoChange = undoChange;

		this._publish("server/undoStateChanged");
        return undoChange;
    },

	undo: function() {
		if (this.isReadOnly()){
			return;
		}
		if (!this.undoChange) {
			return;
		}

		for (var i in this.undoChange.events){
			var event = this.undoChange.events[i];
			var mgr = this.getManager(event.managerId);
			if (mgr) {
				if (typeof(mgr.undo) === "function") {
					mgr.undo(event.data);
					//As a neat side effect, any messages generated within mgr.undo will appear *underneath* this one:
					this.msg(this.undoChange.getEventDescription(event), "notice", "undo");
				} else {
					console.error("Error in game#undo--the " + mgr.id + " manager doesn't have an undo function.");
				}
			} else {
				console.error("Error in game#undo--tried to process an event with the", event.managerId, "manager, which doesn't exist.");
			}
		}

		this.undoChange = null;
		this._publish("server/undoStateChanged");
	},

	//-----------------------------------------------------------------
	//TODO: use me on mobile version
	checkEldermass: function(){
		if (this.isEldermass()){
			if (this.resPool.get("elderBox").value == 0){
				this.resPool.get("elderBox").value++;
				this.msg($I("gift.get"), "important");
			}
		} else {
			if (this.resPool.get("elderBox").value > 0 && this.resPool.get("elderBox").value < 1) {
				this.resPool.get("elderBox").value = 1;
				this.msg($I("gift.repaired"), "important");
			}
		}
	},

	redeemGift: function(){
		if (this.resPool.get("elderBox").value == 0) {
			return;
		}

		var gift = "Karma";
		if (this.resPool.get("paragon").value >= 100) {
			gift = "Paragon";
		}
		if (this.resPool.get("timeCrystal").value && this.prestige.getPerk("anachronomancy").researched && this.workshop.get("stasisChambers").researched) {
			gift = "TimeCrystal";
		}
		if (this.resPool.get("sorrow").value / this.resPool.get("sorrow").maxValue < 0.25 && this.prestige.getPerk("megalomania").researched && this.religion.getZU("blackPyramid").val < 3) {
			gift = "BLS";
		}
		if (this.religion.getRU("apocripha").on) {
			gift = "Apocrypha";
		}
		if (this.religion.getRU("transcendence").on && this.religion.transcendenceTier <= 10) {
			gift = "Transcendence";
		}
		if (this.prestige.getPerk("engeneering").researched && !this.prestige.getPerk("renaissance").researched) {
			gift = "Metaphysics";
		}
		if (this.bld.get("chronosphere").on) {
			gift = "Compendiums";
		}
		if (this.diplomacy.get("leviathans").energy == this.diplomacy.getMarkerCap()){
			gift = "BurnedParagon";
		}
		var ucfirst = function (string) { return string.charAt(0).toUpperCase() + string.slice(1); };

		switch (gift) {
			case "Karma":
				if (this.resPool.get("karma").value > 50) {
					var amt = 25 * Math.min(this.karmaKittens, 25000);
				} else {
					var amt = 5000;
				}
				var karmaGained = this.getUnlimitedDR(this.karmaKittens + amt, 5) - this.getUnlimitedDR(this.karmaKittens, 5);
				var msg = $I("gift.resources", [this.getDisplayValueExt(karmaGained), ucfirst($I("resources.karma.title"))]);

				this.karmaKittens += amt;
				break;

			case "Paragon":
				if (this.resPool.get("paragon").value > 500) {
					var amt = Math.min(this.resPool.get("paragon").value, 1000);
				} else {
					var amt = 100;
				}
				var msg = $I("gift.resources", [this.getDisplayValueExt(amt), ucfirst($I("resources.paragon.title"))]);
				this.resPool.addResEvent("paragon", amt);
				break;

			case "TimeCrystal":
				if (this.resPool.get("timeCrystal").value > 100) {
					var amt = Math.min(this.resPool.get("timeCrystal").value, 2000);
				} else {
					var amt = 50;
				}
				var msg = $I("gift.resources", [this.getDisplayValueExt(amt), ucfirst($I("resources.timeCrystal.title"))]);
				this.resPool.addResEvent("timeCrystal", amt);
				break;

			case "BLS" :
				amt = this.resPool.get("sorrow").maxValue - this.resPool.get("sorrow").value;
				var msg = $I("gift.resources", [this.getDisplayValueExt(amt), ucfirst($I("resources.sorrow.full"))]);
				this.resPool.addResEvent("sorrow", amt);
				break;

			case "Apocrypha":
				if (this.religion.faithRatio > 10) {
					var amt = 4 * Math.min(this.religion.faithRatio, 1000);
				} else {
					var amt = 5;
				}
				var pre = this.religion.getApocryphaBonus();
				this.religion.faithRatio += amt;
				var post = this.religion.getApocryphaBonus();
				var apocryphaGained = (post - pre) * 100;
				var msg = $I("gift.apocrypha", [this.getDisplayValueExt(apocryphaGained)]);
				break;

			case "Transcendence":
				this.religion.transcendenceTier += 4;
				var msg = $I("gift.transcendence");
				break;

			case "Metaphysics":
				if (!this.prestige.getPerk("goldenRatio").researched) {
					this.prestige.getPerk("goldenRatio").researched = true;
					this.unlock(this.prestige.getPerk("goldenRatio").unlocks);
					var perk = "Golden Ratio";
				}
				else if (!this.prestige.getPerk("divineProportion").researched) {
					this.prestige.getPerk("divineProportion").researched = true;
					this.unlock(this.prestige.getPerk("divineProportion").unlocks);
					var perk = "Divine Proportion";
				}
				else if (!this.prestige.getPerk("vitruvianFeline").researched) {
					this.prestige.getPerk("vitruvianFeline").researched = true;
					this.unlock(this.prestige.getPerk("vitruvianFeline").unlocks);
					var perk = "Vitruvian Feline";
				}
				else if (!this.prestige.getPerk("renaissance").researched) {
					this.prestige.getPerk("renaissance").researched = true;
					var perk = "Renaissance";
				}
				var msg = $I("gift.metaphysics", [perk]);
				break;

			case "Compendiums":
				if (this.resPool.get("compedium").value > 500000) {
					var amt = 4 * this.resPool.get("compedium").value;
				} else {
					var amt = 100000;
				}
				var unicornGraveyard = this.religion.getZU("unicornGraveyard");
				var unicornNecropolis = this.religion.getZU("unicornNecropolis");
				var getSumOfPrices = function(item, resName){ //this function should return how much of one resource was spent on a stackable
					var priceRatio = item.priceRatio;
					var resPrice = 0;
					var num = item.val;
					for (var i in item.prices){
						if (item.prices[i].name == resName){
							resPrice = item.prices[i].val;
						}
					}
					return resPrice * (Math.pow(priceRatio, num) - 1)/(priceRatio - 1);
				};
				var amt1 = Math.max(getSumOfPrices(unicornGraveyard, "necrocorn") + getSumOfPrices(unicornNecropolis, "necrocorn"), 
				Math.max(this.resPool.get("necrocorn").value, 10));
				var msg = $I("gift.resources", [this.getDisplayValueExt(amt), ucfirst($I("resources.compedium.title"))]);
				msg += $I("gift.resources", [this.getDisplayValueExt(amt1), ucfirst($I("resources.necrocorn.title"))]);
				this.resPool.addResEvent("compedium", amt);
				this.resPool.addResEvent("necrocorn", amt1);
				break;
			case "BurnedParagon":
				if (this.resPool.get("burnedParagon").value > 500){
					var amt = Math.min(this.resPool.get("burnedParagon").value, 1500);
				} else {
					var amt = 150;
				}
				var msg = $I("gift.resources", [this.getDisplayValueExt(amt), ucfirst($I("resources.burnedParagon.title"))]);
				this.resPool.addResEvent("burnedParagon", amt);
			break;
		}

		this.msg(msg);
		this.resPool.addResEvent("elderBox", -1);
		this.resPool.addResEvent("wrappingPaper", 1);
	},

	unlockAll: function(){
		for (var i in this.tabs){
			this.tabs[i].visible = true;
		}

		this.resPool.get("paragon").value = 1;
	},

	/** @returns {boolean} true for the second half of December */
	isEldermass: function(){
		var date = new Date();
		return (date.getMonth() == 11 && date.getDate() >= 15  && date.getDate() <= 31);
	},
	/**
	 * @param {number} [lenConst] - exact length; random 5-10 otherwise
	 * @param {string} [charPool] - alphabet to draw from
	 * @returns {string}
	 */
	createRandomName: function(lenConst, charPool) {
		if (!charPool) {
			charPool = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■◆◆åœ∑ß≈ç∂´®ƒ√∫©†¥˙˜µ∆¨ˆ˚µ≤¬øπ≥…π“æ÷櫧¡™£¢∞§¶•ªº≠"; //◆ 
		}
		var nameLength = Math.floor(Math.random() * 6 + 5);
		if (lenConst) {
			nameLength = lenConst - 1;
		}
		var name = "";
		for (var i = 0; i <= nameLength; i++){
			name += charPool[Math.floor(Math.random() * charPool.length)];
		}
		return name;
	},

	/**
	 * @param {number} [ch1] - percent chance of a non-default colour, default 10
	 * @param {number} [ch2] - percent chance of a rare variety once coloured, default 10
	 * @returns {[number, number]} [color, variety], 0 meaning default
	 */
	createRandomVarietyAndColor: function(ch1, ch2){
		if (ch1 == null) {
			ch1 = 10;
		}
		if (ch2 == null) {
			ch2 = 10;
		}
		function rand(ratio){
			return (Math.floor(Math.random() * ratio));
		}
		var color = 0;
		var variety = 0;
		//10% of chance to generate one of 6 primary colors (rare colors TBD)
		if (rand(100) <= ch1){
			color = rand(6) + 1;

			//10% of chance of colored cat to be one of 5 rare varieties (dual, tabby, torbie, calico, spots)
			if (rand(100) <= ch2){
				variety = rand(4) + 1;
			}
		}
		return [color, variety];
	}
});