accessing unit states from returned object

[ratacat]

Here's my current config, it seems like this.states.is('winter') isn't working from the returned object.

"use strict"
const TimeCrunch = require("~bundles/timecrunch/lib/TimeCrunch")
const { Logger } = require("ranvier")

module.exports = {
    listeners: {
        startup: state => function () {
            const config = {
                // One and only one unit is the smallest measured subdivision of time, defined as a 'tick'
                minute: {
                    tick: true,
                    makes: { hour: 60 },
                },

                // Optionally one can define a function to be called when
                // a unit increments (having a bell toll, etc.)
                hour: {
                    makes: { day: 24 },
                    onIncrement() {
                        state.GameServer.emit("gamehour",this.time)
                    },
                    // Units can be divided into multiple state changes. For example, a day has two or more states defined
                    // by how many hours have passed.
                    // 'states' can be an object or a function.
                    // In this case, dawn and dusk are different depending
                    // on the season
                    states() {
                        if (this.states.is("winter")) {
                            return {
                                day: 9, // 0900 -- by default this number represents hours. however, each property returned can also be a function that has access to any time unit.
                                night: 20, // 2000
                            }
                        }
                        return {
                            day: 6, // 0900
                            night: 23, // 2200
                        }
                    }
                },
                day: {
                    makes() {
                        const days = this.time.month % 2 ? 31 : 30
                        return { month: days }
                    },
                    onIncrement() {
                        state.GameServer.emit("gameday",this.time)
                    },
                },
                month: {
                    // The 'of' property can also be a function called
                    // In this case, even months have 30 days and odd have 31.
                    makes: { year: 12 },

                    // For simpler state changes, an object marking the
                    // transitional thresholds is fine.
                    states: {
                        winter: 11,
                        spring: 3,
                        summer: 5,
                        fall: 9
                    },
                    onIncrement(){
                        state.GameServer.emit("gamemonth",this.time)
                    }
                },
                year: {
                    makes: {season: 50},
                    onIncrement(){
                        state.GameServer.emit("gameyear",this.time)
                    }
                }
            }

            state.TimeCrunch = new TimeCrunch(config)

            let sync = getSynchronize(Date.now())
            for (let [k,v] of Object.entries(sync)) {
                loadUnit.call(state.TimeCrunch,k,v)
            }

            setInterval(function () {
                state.GameServer.emit("gameminute")
            }, 1250)

        },
        gameminute: state => () => {
            let obj = state.TimeCrunch.tick("minute",1)
            for (let [name,area] of state.AreaManager.areas){
                area.emit("gameminute",obj)
            }
        },
        gamehour: state => function(time){
            for (let [name,area] of state.AreaManager.areas){
                area.emit("gamehour",time)
            }
        },
        gameday: state => function(time){
            for (let [name,area] of state.AreaManager.areas){
                area.emit("gameday",time)
            }
        },
        gamemonth: state => function(time){
            for (let [name,area] of state.AreaManager.areas){
                area.emit("gamemonth",time)
            }
        },
        gameyear: state => function(time){
            for (let [name,area] of state.AreaManager.areas){
                area.emit("gameyear",time)
            }
        }
    }
}

function loadUnit(id, amount){
    this.time[id] = amount
}

function getSynchronize(datetime){
    let yfloat = (datetime * 48) / 31536000000
    let ywhole = Math.floor(yfloat)
    let yremainder = yfloat - ywhole

    let mfloat = yremainder * 12
    let mwhole = Math.floor(mfloat)
    let mremainder = mfloat - mwhole

    let dfloat = mremainder * 30
    let dwhole = Math.floor(dfloat)
    let dremainder = dfloat - dwhole

    let hfloat = dremainder * 24
    let hwhole = Math.floor(hfloat)
    let hremainder = hfloat - hwhole

    let ifloat = hremainder * 60
    let iwhole = Math.floor(ifloat)
    let iremainder = ifloat - iwhole

    return {minute: iwhole, hour: hwhole, day: dwhole, month: mwhole, year: ywhole - 2000}
}