mnml/client/src/events.jsx

const toast = require('izitoast');
const eachSeries = require('async/eachSeries');

const actions = require('./actions');
const { TIMES } = require('./constants');
const { getCombatSequence } = require('./utils');

function registerEvents(store) {

    // timeout handlers
    store.subscribe(() => {
        const { game, instance, ws } = store.getState();

        if (!ws) return true;
        if (!game) ws.clearGameStateTimeout();
        if (!instance) ws.clearInstanceStateTimeout();
    });

    function setPing(ping) {
        store.dispatch(actions.setPing(ping));
    }

    function setTeam(team) {
        localStorage.setItem('team', JSON.stringify(team));
        store.dispatch(actions.setTeam(team));
    }

    function setNav(v) {
        store.dispatch(actions.setNav(v));
    }

    function setConstructList(constructs) {
        // check team is in list
        const { team } = store.getState();
        const ids = constructs.map(c => c.id);

        // team is fucked up, or just registered
        // reset to the first 3 constructs
        if (!team.every(t => t && ids.includes(t))) {
            store.dispatch(actions.setTeam([ids[0], ids[1], ids[2]]));
        }

        store.dispatch(actions.setConstructs(constructs));
    }

    function setInstanceList(list) {
        store.dispatch(actions.setInstanceList(list));
    }

    function setWs(ws) {
        store.dispatch(actions.setWs(ws));
    }

    function setGame(game) {
        const { game: currentGame, ws } = store.getState();

        if (game) ws.startGameStateTimeout(game.id);
        if (game && currentGame) {
            if (game.resolved.length !== currentGame.resolved.length) {
                // stop fetching the game state til animations are done
                ws.clearGameStateTimeout();
                const newRes = game.resolved.slice(currentGame.resolved.length);
                let id = game.resolved.length - currentGame.resolved.length;
                return eachSeries(newRes, (r, cb) => {
                    if (['Disable', 'TargetKo'].includes(r.event[0])) return cb();
                    // Create sub events for combat animations
                    const sequence = getCombatSequence(r);
                    id += 1;
                    return eachSeries(sequence, (stages, sCb) => {
                        const stagedR = Object.create(r);
                        stagedR.sequence = sequence;
                        stagedR.stages = stages;
                        stagedR.id = id;
                        let timeout = 0;
                        if (stages.includes('START_SKILL') && stages.includes('END_SKILL')) {
                            timeout = TIMES.SOURCE_AND_TARGET_TOTAL_DURATION;
                        } else if (stages.includes('START_SKILL')) timeout = TIMES.SOURCE_DURATION_MS;
                        else if (stages.includes('END_SKILL')) timeout = TIMES.TARGET_DURATION_MS;
                        else if (stages.includes('POST_SKILL')) timeout = TIMES.POST_SKILL_DURATION_MS;
                        store.dispatch(actions.setResolution(stagedR));

                        return setTimeout(sCb, timeout);
                    }, err => {
                        if (err) console.error(err);
                        // Clear the anim classes
                        store.dispatch(actions.setResolution('clear'));
                        // Finished this resolution small delay for reset
                        return setTimeout(cb, 5);
                    });
                }, err => {
                    if (err) return console.error(err);
                    store.dispatch(actions.setAvatarAnimation({ id: -1 }));
                    store.dispatch(actions.setResolution(null));
                    // stop skipping resolutions
                    store.dispatch(actions.setSkip(false));
                    // update the game
                    store.dispatch(actions.setGame(game));
                    // get the latest state and restart polling
                    ws.sendGameState(currentGame.id);
                    return true;
                });
            }
        }

        return store.dispatch(actions.setGame(game));
        return console.log('EVENT ->', 'game', game);
    }

    function setAccount(account) {
        store.dispatch(actions.setAccount(account));
    }

    function clearCombiner() {
        store.dispatch(actions.setInfo([]));
        store.dispatch(actions.setCombiner([null, null, null]));
    }

    function setActiveSkill(skill) {
        store.dispatch(actions.setActiveSkill(skill));
    }

    function setActiveItem(v) {
        store.dispatch(actions.setActiveItem(v));
    }

    function clearInfo() {
        store.dispatch(actions.setInfo(null));
        store.dispatch(actions.setActiveConstruct(null));
        console.log('event clear item');
    }

    function clearInstance() {
        store.dispatch(actions.setCombiner([null, null, null]));
        store.dispatch(actions.setReclaiming(false));
        store.dispatch(actions.setActiveSkill(null));
        store.dispatch(actions.setActiveConstruct(null));
        store.dispatch(actions.setInfo(null));
        store.dispatch(actions.setItemEquip(null));
        store.dispatch(actions.setItemUnequip(null));
        store.dispatch(actions.setVboxHighlight([]));
        store.dispatch(actions.setConstructDeleteId(null));
    }

    function setAccountInstances(v) {
        return store.dispatch(actions.setInstances(v));
    }

    function setInstance(v) {
        const { account, ws, instance } = store.getState();
        if (v) {
            ws.startInstanceStateTimeout(v.id);

            const player = v.players.find(p => p.id === account.id);
            store.dispatch(actions.setPlayer(player));

            if (!instance || v.id !== instance.id) {
                store.dispatch(actions.setNav('vbox'));
                const first = player.constructs[0];
                store.dispatch(actions.setActiveConstruct(first));
            }
        }
        return store.dispatch(actions.setInstance(v));
    }

    function setItemInfo(v) {
        return store.dispatch(actions.setItemInfo(v));
    }

    // events.on('SET_PLAYER', setInstance);

    // events.on('SEND_SKILL', function skillActive(gameId, constructId, targetConstructId, skill) {
    //     ws.sendGameSkill(gameId, constructId, targetConstructId, skill);
    //     setConstructStatusUpdate(constructId, skill, targetConstructId);
    // });

    // events.on('CONSTRUCT_ACTIVE', function constructActiveCb(construct) {
    //     for (let i = 0; i < constructs.length; i += 1) {
    //         if (constructs[i].id === construct.id) constructs[i].active = !constructs[i].active;
    //     }
    //     return setConstructs(constructs);
    // });

    const errMessages = {
        select_constructs: 'Select your constructs before battle using the numbered buttons next to the construct avatar',
        complete_nodes: 'You need to complete the previously connected nodes first',
        max_skills: 'Your construct can only learn a maximum of 4 skills',

    };

    function errorPrompt(type) {
        const message = errMessages[type];
        const OK_BUTTON = '<button type="submit">OK</button>';
        toast.info({
            theme: 'dark',
            color: 'black',
            timeout: false,
            drag: false,
            position: 'center',
            maxWidth: window.innerWidth / 2,
            close: false,
            buttons: [
                [OK_BUTTON, (instance, thisToast) => instance.hide({ transitionOut: 'fadeOut' }, thisToast)],
            ],
            message,
        });
    }

    // setup / localstorage
    const team = JSON.parse(localStorage.getItem('team'));
    if (team && team.every(t => t)) {
        setTeam(team);
        setNav('list');
    }

    return {
        errorPrompt,
        clearCombiner,
        clearInstance,
        setAccount,
        setActiveSkill,
        setActiveItem,
        setConstructList,
        setGame,
        clearInfo,
        setInstance,
        setInstanceList,
        setAccountInstances,
        setWs,
        setPing,
        setItemInfo,
    };
}

module.exports = registerEvents;