This is an update to the original post about automated shattering.

Testing showed that the alicorn sacrifice was inconsistent. Sometimes it would trigger, other times it would not. It was not even as simple as whether you were on the religion tab or not.

In the end I had to actually create my own button to use for shattering, creating it similarly to how the game does to allow for consistent shattering.

// ** Alicorns
// Load religion buttons into memory
game.religionTab.render()
var model = Object.assign({}, game.religionTab.sacrificeAlicornsBtn.model)

var alicornButton = new classes.ui.religion.SacrificeBtn(
    {
        controller: new classes.ui.religion.SacrificeAlicornsBtnController(
            game
        ),
        prices: model.prices},
    game
)

function sacrificeAlicorns () {
    alicornButton.render()
    alicornButton.controller.sacrificeAll(
        alicornButton.model,
        false,
        () => {}
    )
}

Forcing the rendering each time is probably overkill, however this will require further testing to ensure it doesn’t actually need to be done.

As an added benefit, this allowed for streamlining the shatter widget code by removing the manual option mappings to model with a simple shatterWidget.render() call. This is updated in the linked script as well.

As mentioned in my previous post, calculating shattering profitability is a separate process from implementing the shatter engine itself. They can be paired together to ensure the engine is running when profitable and stops if you would run out of TC due to the Cycle or Dark Future.

Profits also need to account for idle production since there is time spent between shatters. It does not account for Alicorn rift chances since as shatter speed increases, chances for rifts to even occur will decrease.

Unobtainium per Shatter

Unobtainium per shatter is simply how much unobtainium is returned every year due to Resource Retrieval. That ratio will be passed in from the parent function so it will always be up to date.

function getUnobtPerShatter(ratio, delay) {
    var n = 'unobtainium',
        unobt = game.resPool.get(n),
        unProd = game.getResourcePerTick(n) * 5 *
            (game.time.isAccelerated ? 1.5 : 1),
        unYr = unProd * 800,
        unIdle = unProd * (shatterPerTick ? delay/5 : delay)
        unShatter = unYr * ratio + unIdle

    // return per shatter or max
    return Math.min(unShatter, unobt.maxValue)
}

Alicorns per Shatter

Unfortunately shattering essentially eliminates alicorn income because are skipping years rather than triggering per tick/day effects. This does mean calculations can omit the chance even though at low values of chronofurnaces you will still be gaining extra alicorns.

function getAlicornPerShatter(ratio, delay) {
    var n = 'alicorn',
        aliProd = game.getResourcePerTick(n) * 5 *
            (game.time.isAccelerated ? 1.5 : 1),
        aliYr = aliProd * 800,
        aliIdle = aliProd * (shatterPerTick ? delay/5 : delay)

    return aliYr * ratio + aliIdle
}

Time Crystals per Shatter

Time Crystals per shatter converts from resources per year to Time Crystals per year by assuming partial income. This does require a certain amount of padding on initial crystals to ensure that the engine does not stall, but once started it should not need to stop since the purchase will cover any future expenditures.

function getTCPerTrade() {
    var leviRace = game.diplomacy.races.find(
        race => race.name === 'leviathans')

    var ratio = game.diplomacy.getTradeRatio(),
        tc = leviRace.sells.find(
            res => res.name === 'timeCrystal'),
        amt = tc.value - (tc.value * (tc.delta / 2))

    return amt * (1 + ratio) * (1 + (0.02 * leviRace.energy))
}

function getTCPerShatter() {
    var rr = game.getEffect('shatterTCGain') *
        (1 + game.getEffect('rrRatio'))

    var unobt = getUnobtPerShatter(rr),
        tcPerUnobt = getTCPerTrade() / 5000,
        ali = getAlicornPerShatter(rr),
        tcPerAli = (1 + game.getEffect('tcRefineRatio')) / 25,
        heatChallenge = game.challenges.getChallenge("1000Years").researched,
        furnaceBoost = (heatChallenge ? 5 : 10) / 100

    return (unobt * tcPerUnobt + ali * tcPerAli) * (1 + furnaceBoost)
}

Time Crystal Profitability

Because of Dark Future and possible overheat situations (if manually shattering), price per shatter will not always be 1. Leverage the internal price calculation to get the actual cost and determine profit relative to it.

// Use shatterButton from intellishatter if present rather than
// risk possible UI changes
var shatterPerTick = false
var shatterPadding = 0 // Additional seconds to delay shatter

function getTimePer10Heat() {
    var heat = game.challenges.getChallenge('1000Years').researched,
        heat = heat ? 5 : 10
    return Math.ceil(Math.abs(heat / ((shatterPerTick ? 1 : 5) *
                                    game.getEffect('heatPerTick')))) +
        (shatterPadding * (shatterPerTick ? 5 : 1))
}

function createShatterWidget () {
    var shatterWidget = new classes.ui.ChronoforgeWgt(game),
        shatterButton = shatterWidget.children.find(
            button => button.opts.name === 'Combust TC'
        );

    shatterButton.model = Object.assign({},shatterButton.opts);
    shatterButton.model.options = Object.assign({},shatterButton.opts)
    shatterButton.model.enabled = true;
    return shatterButton
}

var shatterButton = createShatterWidget()


function getTCProfitability() {
    var inTC = getTCPerShatter(),
        outTC = shatterButton.controller
            .getPrices(shatterButton.model)
            .find(x => x.name === 'timeCrystal').val
    return inTC - outTC
}

Positive values given by getTCProfitability() mean profit, negative values are the cost in TC every time you shatter.

Most of the published code assumes that Kittens Game has finished loading and is running properly before the functions are pasted into the console (or loaded in other ways). In many cases it won’t matter because the code is fairly self-contained, but in others trying to initialize the scripts before the page is ready will result in errors because it is looking for data that doesn’t exist.

Kittens Game uses two variables to store state information, game and gamePage, from what I’ve seen they are equivalent and I typically use the former for actual calculations. The latter however is not available until the page has finished loading so it will guarantee assets are in place.

Waiting for the variable to be defined ensures that everything is ready and won’t error out.

function run () {
    // Scripts go here
    ...
}

function start () {
    if (typeof gamePage != 'undefined') {
        run()
    } else {
        // Try every second to initialize
        setTimeout(start, 1000)
    }
}

start()

A semi frequent topic on Discord is shatter engines and ensuring you don’t overheat while still producing as much as you can through TimeCrystal mechanics. The actual calculations to determine profitability of shattering through Resource Retrieval and Blazars will be saved for a later post, this one will look at implementing a shatter engine that runs at an optimal pace without having to monitor it constantly.

There are four elements needed to keep the shatter engine going, the third of which will need to be addressed at a later date.

1. Shattering Time Crystals as quickly as heat dissipation allows
2. Sacrificing Alicorns when they reach 25 to ensure crystal creation
3. Trading with Leviathans to keep up a supply of Time Crystals and to avoid capping unobtanium
4. A timer to check or perform these actions

Timing for shattering

Shattering at an optimal rate means just as quickly as you can remove 10 heat from your furnace. Since the goal is to never go into overheat there is no reason to shatter more than 1 crystal at a time. You’ll remain at minimal heat and can always manually shatter to get a boost if there is a reason.

// Use per-tick calculations.  Could be useful at high chrono furnace
// levels to optimize even further
var shatterPerTick = false;

var shatterPadding = 0; // Addition seconds to delay shatter

function getTimePer10Heat() {
    var heat = game.challenges.getChallenge('1000Years').researched,
        heat = heat ? 5 : 10
    return Math.ceil(Math.abs(heat / ((shatterPerTick ? 1 : 5) *
                                    game.getEffect('heatPerTick')))) +
        (shatterPadding * (shatterPerTick ? 5 : 1))
}

The shatter button itself is hidden on the timeTab and isn’t available initially because it needs to be rendered. Previous solutions suggested using a ... children[0].children[0] ... click() construct but bloodrizer pointed at using the built in classes and controller to identify the actual doShatterAmt() function. A bit of prodding and working out difference between manually generating a small segment vs how the page itself loads and the function was available.

Building a new widget was simpler than using the rendered one because of component nesting. Combust TC is nested inside of a chronoforgePanel (cfPanel) which is why there were the nested children. Option name had to be used because unlike every other object on the panel, Combust TC does not have an id property, but there is no guarantee that will not be changed.

function createShatterWidget () {
    var shatterWidget = new classes.ui.ChronoforgeWgt(game),
        shatterButton = shatterWidget.children.find(
            button => button.opts.name === 'Combust TC'
        );

    shatterButton.model = Object.assign({},shatterButton.opts);
    shatterButton.model.options = Object.assign({},shatterButton.opts)
    shatterButton.model.enabled = true;
    return shatterButton
}

var shatterButton = createShatterWidget()

The actual shatter function keeps track of the counter state so that it can shatter as required. The dojo controller functions need access to the model (sibling to the controller) as well as an event and callback. doShatterAmt also needs an amount to shatter, which defaults to 5 if not specified. Since we aren’t monitoring the engine, the callback and event aren’t needed, only the model and quantity.

var counter = 1;
function shatterTCTime () {
    if (counter % getTimePer10Heat() == 0) {
        shatterButton.controller.doShatterAmt(
            shatterButton.model, false, () => { }, 1
        )
        counter = 1
    } else {
        counter++
    }
}

Shattering will only occur if there are enough resources to do so successfully.

Alicorn sacrificing

Alicorn sacrificing is a very similar button to the one used for Time Crystals however it is not in a nested container. Calling the existing controller is simpler than ensuring all options are generated in the models.

// Force rendering of the religionTab in case it isn't done yet
game.religionTab.render()
var alicornButton = game.religionTab.sacrificeAlicornsBtn

function sacrificeAlicorns () {
    alicornButton.controller.sacrificeAll(
        alicornButton.model, false, () => { }
    )
}

Leviathan Trading

Shatter Engines are only efficient as long as Leviathans are providing Time Crystals. Trading with them allows the engine to continue running consistently.

Luckily there is a tradeAll(<race>) function that intelligently trades for what is available and does not need monitoring to ensure there are resources available.

function tradeLeviathans () {
    var leviRace = game.diplomacy.races.find(
        race => race.name === 'leviathans'
    )
    game.diplomacy.tradeAll(leviRace)
}

Shatter Timer

Since there are multiple functions needing to be run, a wrapper to call them in order is needed. Also there is no reason to try and run the shatter engine when there are no time crystals, so only allow it to be triggered if the resource is unlocked.

function automateShatter () {
    sacrificeAlicorns()
    tradeLeviathans()
    shatterTCTime()
}

if (gamePage.resPool.get('timeCrystal').unlocked) {
    var shatterInterval = setInterval(automateShatter,
                                      shatterPerTick ? 200 : 1000)
} else {
    console.log("Time Crystals not available")
}
// clearInterval(shatterInterval)

When playing KittensGame I frequently find myself having to switch game tabs constantly while trying to build. In particular during the titanium build-out phase I end up needing to switch from Trading with Zebras back to the Bonfire to build more Reactors, Accelerators or Factories.

This came up on Discord last week and I decided to look into what it would take to implement this. I’m learning Javascript as I go so I knew there would likely be suboptimal designs but it was not nearly as hard as I expected.

First I figured out what structure I’d want for identifying event and action. From working with Lisp and Powershell I’d wanted to go with an associative list of Key -> Action or Action -> Key but couldn’t figure out how to make this work in Javascript. Probably for the best since an array of objects worked out quite well and is easily extensible.

{
    name: 'Tab to switch to',
    key: 'Key',    // Must capitalize letters to match event.key if
                   // Shift is pressed
    shift: true,   // Shift modifier prevents accidental switching
    alt: false,    // Alt and Control false to not interact with
    control: false // browser bindings.
}

With that in place it was easy to create the mappings for the commonly used tabs. Use the initial of the tab as the keybinding, with any duplicates moving to the next letter (in this case SPace and TIme).

Then a function to identify which of the keybindings to act on based on events and recreate the existing tab switching functionality to jump to the new tab and render it.

// tablist is the variable containing the keybindings
function switchTab(event) {
    var newTab = keybinds.find(x =>
        x.key === event.key &&
        x.shift == event.shiftKey &&
        x.alt == event.altKey &&
        x.control == event.ctrlKey)
    if (newTab && newTab.name!= activeTabId) {
        console.log('Switching to: ' + newTab.name)
        game.ui.activeTabId = newTab.name
        game.ui.render()
    }
}

Adding this as a keyup event listener let it trigger on keystrokes, which provided the last piece needed.

While testing it I remembered the other issue I constantly have had, closing the Options and Export dialogs by hitting Escape from habit and seeing nothing happen. By defining a new action: property in the mapping and setting it to trigger the click action on the Options page I fixed the first half of that.

// tablist is the variable containing the keybindings
function switchTab(event) {
    var newTab = keybinds.find(x =>
        x.key === event.key &&
        x.shift == event.shiftKey &&
        x.alt == event.altKey &&
        x.control == event.ctrlKey)
    if (newTab && newTab.name!= activeTabId) {
        if (newTab.action) {
            newTab.action()
        } else {
            console.log('Switching to: ' + newTab.name)
            game.ui.activeTabId = newTab.name
            game.ui.render()
        }
    }
}

Now add in a few other new features with lowercase bindings to distinguish from tab switching and the naming needs to be slightly updated:

• hunt
• praise
• observe

Finally I realized that rather than target the close button on options, just use jQuery to target the last visible .dialog div and hide it.