slp-enforcer/dist/slippi/stats/combos.js

Finds violations of the Melee Controller Ruleset by inspecting SLP files

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const last_1 = __importDefault(require("lodash/last"));
const common_1 = require("./common");
var ComboEvent;
(function (ComboEvent) {
    ComboEvent["COMBO_START"] = "COMBO_START";
    ComboEvent["COMBO_EXTEND"] = "COMBO_EXTEND";
    ComboEvent["COMBO_END"] = "COMBO_END";
})(ComboEvent = exports.ComboEvent || (exports.ComboEvent = {}));
class ComboComputer extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.playerPermutations = new Array();
        this.state = new Map();
        this.combos = new Array();
        this.settings = null;
    }
    setup(settings) {
        // Reset the state
        this.settings = settings;
        this.state = new Map();
        this.combos = [];
        this.playerPermutations = common_1.getSinglesPlayerPermutationsFromSettings(settings);
        this.playerPermutations.forEach((indices) => {
            const playerState = {
                combo: null,
                move: null,
                resetCounter: 0,
                lastHitAnimation: null,
                event: null,
            };
            this.state.set(indices, playerState);
        });
    }
    processFrame(frame, allFrames) {
        this.playerPermutations.forEach((indices) => {
            const state = this.state.get(indices);
            if (state) {
                handleComboCompute(allFrames, state, indices, frame, this.combos);
                // Emit an event for the new combo
                if (state.event !== null) {
                    this.emit(state.event, {
                        combo: last_1.default(this.combos),
                        settings: this.settings,
                    });
                    state.event = null;
                }
            }
        });
    }
    fetch() {
        return this.combos;
    }
}
exports.ComboComputer = ComboComputer;
function handleComboCompute(frames, state, indices, frame, combos) {
    var _a, _b, _c, _d;
    const currentFrameNumber = frame.frame;
    const playerFrame = frame.players[indices.playerIndex].post;
    const opponentFrame = frame.players[indices.opponentIndex].post;
    const prevFrameNumber = currentFrameNumber - 1;
    let prevPlayerFrame = null;
    let prevOpponentFrame = null;
    if (frames[prevFrameNumber]) {
        prevPlayerFrame = frames[prevFrameNumber].players[indices.playerIndex].post;
        prevOpponentFrame = frames[prevFrameNumber].players[indices.opponentIndex].post;
    }
    const oppActionStateId = opponentFrame.actionStateId;
    const opntIsDamaged = common_1.isDamaged(oppActionStateId);
    const opntIsGrabbed = common_1.isGrabbed(oppActionStateId);
    const opntIsCommandGrabbed = common_1.isCommandGrabbed(oppActionStateId);
    const opntDamageTaken = prevOpponentFrame ? common_1.calcDamageTaken(opponentFrame, prevOpponentFrame) : 0;
    // Keep track of whether actionState changes after a hit. Used to compute move count
    // When purely using action state there was a bug where if you did two of the same
    // move really fast (such as ganon's jab), it would count as one move. Added
    // the actionStateCounter at this point which counts the number of frames since
    // an animation started. Should be more robust, for old files it should always be
    // null and null < null = false
    const actionChangedSinceHit = playerFrame.actionStateId !== state.lastHitAnimation;
    const actionCounter = playerFrame.actionStateCounter;
    const prevActionCounter = prevPlayerFrame ? prevPlayerFrame.actionStateCounter : 0;
    const actionFrameCounterReset = actionCounter < prevActionCounter;
    if (actionChangedSinceHit || actionFrameCounterReset) {
        state.lastHitAnimation = null;
    }
    // If opponent took damage and was put in some kind of stun this frame, either
    // start a combo or count the moves for the existing combo
    if (opntIsDamaged || opntIsGrabbed || opntIsCommandGrabbed) {
        let comboStarted = false;
        if (!state.combo) {
            state.combo = {
                playerIndex: indices.opponentIndex,
                startFrame: currentFrameNumber,
                endFrame: null,
                startPercent: prevOpponentFrame ? (_a = prevOpponentFrame.percent) !== null && _a !== void 0 ? _a : 0 : 0,
                currentPercent: (_b = opponentFrame.percent) !== null && _b !== void 0 ? _b : 0,
                endPercent: null,
                moves: [],
                didKill: false,
                lastHitBy: indices.playerIndex,
            };
            combos.push(state.combo);
            // Track whether this is a new combo or not
            comboStarted = true;
        }
        if (opntDamageTaken) {
            // If animation of last hit has been cleared that means this is a new move. This
            // prevents counting multiple hits from the same move such as fox's drill
            if (state.lastHitAnimation === null) {
                state.move = {
                    playerIndex: indices.playerIndex,
                    frame: currentFrameNumber,
                    moveId: playerFrame.lastAttackLanded,
                    hitCount: 0,
                    damage: 0,
                };
                state.combo.moves.push(state.move);
                // Make sure we don't overwrite the START event
                if (!comboStarted) {
                    state.event = ComboEvent.COMBO_EXTEND;
                }
            }
            if (state.move) {
                state.move.hitCount += 1;
                state.move.damage += opntDamageTaken;
            }
            // Store previous frame animation to consider the case of a trade, the previous
            // frame should always be the move that actually connected... I hope
            state.lastHitAnimation = prevPlayerFrame ? prevPlayerFrame.actionStateId : null;
        }
        if (comboStarted) {
            state.event = ComboEvent.COMBO_START;
        }
    }
    if (!state.combo) {
        // The rest of the function handles combo termination logic, so if we don't
        // have a combo started, there is no need to continue
        return;
    }
    const opntIsTeching = common_1.isTeching(oppActionStateId);
    const opntIsDowned = common_1.isDown(oppActionStateId);
    const opntDidLoseStock = prevOpponentFrame && common_1.didLoseStock(opponentFrame, prevOpponentFrame);
    const opntIsDying = common_1.isDead(oppActionStateId);
    // Update percent if opponent didn't lose stock
    if (!opntDidLoseStock) {
        state.combo.currentPercent = (_c = opponentFrame.percent) !== null && _c !== void 0 ? _c : 0;
    }
    if (opntIsDamaged || opntIsGrabbed || opntIsCommandGrabbed || opntIsTeching || opntIsDowned || opntIsDying) {
        // If opponent got grabbed or damaged, reset the reset counter
        state.resetCounter = 0;
    }
    else {
        state.resetCounter += 1;
    }
    let shouldTerminate = false;
    // Termination condition 1 - player kills opponent
    if (opntDidLoseStock) {
        state.combo.didKill = true;
        shouldTerminate = true;
    }
    // Termination condition 2 - combo resets on time
    if (state.resetCounter > common_1.Timers.COMBO_STRING_RESET_FRAMES) {
        shouldTerminate = true;
    }
    // If combo should terminate, mark the end states and add it to list
    if (shouldTerminate) {
        state.combo.endFrame = playerFrame.frame;
        state.combo.endPercent = prevOpponentFrame ? (_d = prevOpponentFrame.percent) !== null && _d !== void 0 ? _d : 0 : 0;
        state.event = ComboEvent.COMBO_END;
        state.combo = null;
        state.move = null;
    }
}