werewolf-core/dist/lib/game.js

Are you a WEREWOLF?

"use strict";
var extend = require('extend');
var event_1 = require('./event');
var player_1 = require('./player');
var effect_1 = require('./effect');
var Game = (function () {
    function Game(initField) {
        this.players = new player_1.Players();
        this.effects = new effect_1.Effects();
        this.field = initField;
        this.ruleProducers = [];
        this.playerProducers = {};
        this.effectProducers = {};
        this.actions = {};
    }
    Game.prototype.loadRuleProducers = function (ps) {
        (_a = this.ruleProducers).push.apply(_a, ps);
        var _a;
    };
    Game.prototype.loadPlayerProducers = function (ps) {
        extend(false, this.playerProducers, ps);
    };
    Game.prototype.loadEffectProducers = function (ps) {
        extend(false, this.effectProducers, ps);
    };
    Game.prototype.loadActions = function (acts) {
        extend(false, this.actions, acts);
    };
    Game.prototype.loadPackage = function (p) {
        if (p.ruleProducers) {
            this.loadRuleProducers(p.ruleProducers);
        }
        if (p.playerProducers) {
            this.loadPlayerProducers(p.playerProducers);
        }
        if (p.effectProducers) {
            this.loadEffectProducers(p.effectProducers);
        }
        if (p.actions) {
            this.loadActions(p.actions);
        }
    };
    Game.prototype.addPlayer = function (p) {
        this.players.add(p);
    };
    Game.prototype.addEffect = function (e) {
        this.effects.add(e);
    };
    Game.prototype.removeEffect = function (id) {
        this.effects.removeById(id);
    };
    Game.prototype.runEvent = function (e) {
        var resultObject = {};
        var runner = new EventRunner(this.players, this.effects, this.field, {
            ruleProducers: this.ruleProducers,
            playerProducers: this.playerProducers,
            effectProducers: this.effectProducers,
            actions: this.actions,
        }, null, resultObject);
        runner.runEvent(e);
        this.players = resultObject.players;
        this.effects = resultObject.effects;
        this.field = resultObject.field;
        return e;
    };
    Game.prototype.getPlayers = function () {
        return process.env.NODE_ENV === 'production' ? this.players : this.players.deepClone();
    };
    Game.prototype.getEffects = function () {
        return process.env.NODE_ENV === 'production' ? this.effects : this.effects.deepClone();
    };
    Game.prototype.getField = function () {
        return process.env.NODE_ENV === 'production' ? this.field : extend(true, {}, this.field);
    };
    return Game;
}());
exports.Game = Game;
var EventRunner = (function () {
    function EventRunner(players, effects, field, handlers, base, resultObject) {
        this.handlers = handlers;
        this.base = base;
        this.resultObject = resultObject;
        this.players = safetyClone.players(players);
        this.effects = safetyClone.effects(effects);
        this.field = safetyClone.field(field);
    }
    EventRunner.prototype.runOneEvent = function (e, subrunner) {
        var handlers = [];
        for (var _i = 0, _a = this.handlers.ruleProducers; _i < _a.length; _i++) {
            var pr = _a[_i];
            var es = pr[e.type];
            if (Array.isArray(es)) {
                handlers.push.apply(handlers, es);
            }
        }
        var _loop_1 = function(pl) {
            var pr = this_1.handlers.playerProducers[pl.type];
            if (pr) {
                var es = pr[e.type];
                if (Array.isArray(es)) {
                    handlers.push.apply(handlers, (es.map(function (e) { return extend({ player: safetyClone.player(pl) }, e); })));
                }
            }
        };
        var this_1 = this;
        for (var _b = 0, _c = this.players.asArray(); _b < _c.length; _b++) {
            var pl = _c[_b];
            _loop_1(pl);
        }
        var _loop_2 = function(ef) {
            var pr = this_2.handlers.effectProducers[ef.type];
            if (pr) {
                var es = pr[e.type];
                if (Array.isArray(es)) {
                    handlers.push.apply(handlers, (es.map(function () { return extend({ effect: safetyClone.effect(ef) }, ef); })));
                }
            }
        };
        var this_2 = this;
        for (var _d = 0, _e = this.effects.asArray(); _d < _e.length; _d++) {
            var ef = _e[_d];
            _loop_2(ef);
        }
        sortHandlers(handlers);
        var before;
        var after;
        var i;
        var l = handlers.length;
        for (i = 0; i < l; i++) {
            var h = handlers[i];
            if (h.priority >= 0) {
                break;
            }
        }
        before = handlers.slice(0, i);
        after = handlers.slice(i);
        for (var _f = 0, before_1 = before; _f < before_1.length; _f++) {
            var _g = before_1[_f], player = _g.player, effect = _g.effect, handler = _g.handler;
            var param = {
                runner: subrunner,
                players: safetyClone.players(this.players),
                effects: safetyClone.effects(this.effects),
                field: safetyClone.field(this.field),
                event: e,
            };
            if (player) {
                param.player = player;
            }
            if (effect) {
                param.effect = effect;
            }
            handler(param);
        }
        if (e.prevented !== true) {
            var action = this.handlers.actions[e.type];
            if (action) {
                var param = {
                    runner: subrunner,
                    players: this.players,
                    effects: this.effects,
                    field: this.field,
                    event: e,
                };
                action(param);
            }
        }
        for (var _h = 0, after_1 = after; _h < after_1.length; _h++) {
            var _j = after_1[_h], player = _j.player, effect = _j.effect, handler = _j.handler;
            var param = {
                runner: subrunner,
                players: safetyClone.players(this.players),
                effects: safetyClone.effects(this.effects),
                field: safetyClone.field(this.field),
                event: e,
            };
            if (player) {
                param.player = player;
            }
            if (effect) {
                param.effect = effect;
            }
            handler(param);
        }
        return e;
    };
    EventRunner.prototype.runEvent = function (e) {
        var base = new event_1.EventBase();
        base.addEvent(e);
        var subrunner = this.branchRunner(base);
        var ev;
        while (ev = base.iterateEvent()) {
            this.runOneEvent(ev, subrunner);
        }
        if (this.resultObject != null) {
            this.resultObject.players = this.players;
            this.resultObject.effects = this.effects;
            this.resultObject.field = this.field;
        }
        return e;
    };
    EventRunner.prototype.addEvent = function (e) {
        var base = this.base;
        if (base == null) {
            throw new Error('Cannot add an event to a null-based EventRunner');
        }
        base.addEvent(e);
    };
    EventRunner.prototype.branchRunner = function (base) {
        return new EventRunner(this.players, this.effects, this.field, this.handlers, base, void 0);
    };
    return EventRunner;
}());
exports.EventRunner = EventRunner;
function sortHandlers(handlers) {
    handlers.sort(function (a, b) { return a.priority - b.priority; });
}
var safetyClone;
(function (safetyClone) {
    function player(pl) {
        return process.env.NODE_ENV === 'production' ? pl : extend(true, {}, pl);
    }
    safetyClone.player = player;
    function players(pl) {
        return process.env.NODE_ENV === 'production' ? pl : pl.deepClone();
    }
    safetyClone.players = players;
    function effect(ef) {
        return process.env.NODE_ENV === 'production' ? ef : extend(true, {}, ef);
    }
    safetyClone.effect = effect;
    function effects(efs) {
        return process.env.NODE_ENV === 'production' ? efs : efs.deepClone();
    }
    safetyClone.effects = effects;
    function field(f) {
        return process.env.NODE_ENV === 'production' ? f : extend(true, {}, f);
    }
    safetyClone.field = field;
})(safetyClone || (safetyClone = {}));