After a few other vari­able de­clar­a­tions, we see our first func­tion: init. While this is tech­nic­ally not a func­tion re­quired by the game (which means you can also use let or const for this), it is a bund­ling of man­dat­ory de­clar­a­tions: up­grades, per­man­ent up­grades, mile­stones, achieve­ments, and story chapters. init is called once at the end of the file.

This is the first place where we en­counter what’s known as an ar­row func­tion: var init = () => {…;}. They are men­tioned in Sec­tion 8 of the JavaS­cript tu­torial, and aside from a few dif­fer­ences, they’re mostly identical to nor­mal func­tions covered in Sec­tion 5. An ar­row func­tion’s ar­gu­ments are spe­cified in par­en­theses like nor­mal func­tions, while the func­tion body is writ­ten in­side the code block after the ar­row.

At the be­gin­ning of the func­tion’s body, we see a cur­rency be­ing defined us­ing the­ory.cre­ate­Cur­rency. The cur­rency takes the de­fault sym­bol of the Greek let­ter rho ().

Then, within the Reg­u­lar Up­grade sec­tion, we see two up­grades, each de­clared in a code block: c1 () and c2 (). They are de­clared us­ing the func­tion the­ory.cre­ateUp­grade.

Next, Per­man­ent Up­grades are defined. There are 3 func­tions provided to cre­ate up­grades for Pub­lic­a­tions, Buy All, and Auto-buyer, but you can also cre­ate your own per­man­ent up­grades us­ing the­ory.cre­ate­Per­man­en­t­Up­grade.

In the Mile­stone Up­grades sec­tion, the mile­stone cost is defined us­ing the­ory.set­Mile­stone­Cost, and then there are 2 mile­stones be­ing defined us­ing the­ory.cre­ateMile­stone­Up­grade: c1­Exp and c2­Exp.

Next, 2 Achieve­ments and 2 Story chapters are defined. They are, most of the time, pretty easy to set up com­pared to the up­grades and mile­stones.

Fi­nally, up­dateAvail­ab­il­ity is called. You can see that it is called be­fore it is ac­tu­ally defined be­low. This is a concept known as hoist­ing, covered in Sec­tion 17 of the JavaS­cript tu­torial. up­dateAvail­ab­il­ity is also a re­quired func­tion, as it is of­ten used to dis­play and hide up­grades de­pend­ing on play­er’s pro­gres­sion or other con­di­tions. It needs to be defined as a var so the game can ac­cess it within init.

The next func­tion, tick, is where everything im­port­ant hap­pens. Terms get re­cal­cu­lated, cur­ren­cies in­crease, bins get re­packed, and re­act­ors scream. Ten times a second, this func­tion is called by the game, with two ar­gu­ments:

• elapsed­Time: elapsed time, in seconds. When in-game, it is most of­ten 0.1, and oc­ca­sion­ally 0.2 or more if the pro­cessing could­n’t catch up with the pre­vi­ous tick. When off­line, this ar­gu­ment can be of any value de­pend­ing on your off­line time and the off­line ac­cel but­ton.
• mul­ti­plier: usu­ally 1, this ar­gu­ment be­comes 1.5 when the ad boost is act­ive.

The the­ory util­izes three for­mu­lae:

• The primary (up­per) equa­tion, through getPrimaryEqua­tion. It needs to be re­freshed manu­ally every time you want to re­flect a change (e.g. new mile­stone or term un­locked), us­ing the­ory.in­val­id­ateP­rimaryEqua­tion.
• The sec­ond­ary (middle) equa­tion, through get­Sec­ond­aryEqua­tion. It needs to be re­freshed manu­ally us­ing the­ory.in­val­id­ateSec­ond­aryEqua­tion.
• The pub­lic­a­tion for­mula, through get­Pub­lic­a­tion­Mul­ti­pli­er­For­mula.

When we look at the sec­ond­ary equa­tion or the pub­lic­a­tion for­mula, we can see that the func­tions don’t ac­tu­ally have a code block at­tached:

var getSecondaryEquation = () => theory.latexSymbol + "=\\max\\rho";
var getPublicationMultiplierFormula = (symbol) => "\\frac{ {" + symbol + "}^{0.164} }{3}";

In­stead, they ex­ist on only one line. This in­dic­ates that the func­tions im­me­di­ately re­turn the fol­low­ing ex­pres­sion, and this code is the short-hand equi­val­ent of:

var getSecondaryEquation = () =>
{
    return theory.latexSymbol + "=\\max\\rho";
}
var getPublicationMultiplierFormula = (symbol) =>
{
    return "\\frac{ {" + symbol + "}^{0.164} }{3}";
}

Also note that com­pared to reg­u­lar LaTeX, the LaTeX com­mands in-game must be star­ted with two back slashes, in­stead of one.

The pub­lic­a­tion mul­ti­plier is de­term­ined by get­Pub­lic­a­tion­Mul­ti­plier, which takes the tau value (of the last pub­lic­a­tion) and re­turns the mul­ti­plier as a BigNum­ber - the game’s large num­ber (‘ee’ and up) lib­rary.

The tau value is de­term­ined by getTau, based on the cur­rency value. As a high-score met­ric, tau can only in­crease and never de­crease, un­less the the­ory is re­set.

The the­ory, like most, fea­tures a 2D graph dis­play­ing the cur­rency’s value on a log­ar­ithmic scale. The graph’s value is up­dated 10 times per second through get2D­Graph­Value.

The last four func­tions are used to cal­cu­late the terms in the the­ory:

• getC1 cal­cu­lates 's value as a step­wise power sum. An ex­plan­a­tion of step­wise power sums will be given later.
• getC2 cal­cu­lates 's value as powers of two.
• getC1­Ex­po­nent cal­cu­late 's ex­po­nent ac­cord­ing to the c1­Exp mile­stone.
• getC2­Ex­po­nent cal­cu­late 's ex­po­nent ac­cord­ing to the c2­Exp mile­stone.