@woosh/meep-engine/src/core/model/reactive/js/compileReactiveToJS.js

Pure JavaScript game engine. Fully featured and production ready.

/**
 *
 * @param {ReactiveReference} r
 * @returns {string}
 */
function compileReference(r) {
    return `this.${r.name}`;
}

/**
 *
 * @param {ReactiveLiteralNumber} l
 * @return {string}
 */
function compileLiteralNumber(l) {
    return `${l.getValue()}`;
}

/**
 *
 * @param {ReactiveLiteralBoolean} l
 * @return {string}
 */
function compileLiteralBoolean(l) {
    return `${l.getValue()}`;
}

/**
 *
 * @param {ReactiveLiteralString} l
 * @return {string}
 */
function compileLiteralString(l) {
    return `'${l.getValue()}'`;
}


/**
 *
 * @param {ReactiveGreaterThan} gt
 * @returns {string}
 */
function compileComparisonGT(gt) {
    return `( ${compileExpression(gt.left)} > ${compileExpression(gt.right)} )`;
}

/**
 *
 * @param {ReactiveGreaterThanOrEqual} gte
 * @returns {string}
 */
function compileComparisonGTE(gte) {
    return `( ${compileExpression(gte.left)} >= ${compileExpression(gte.right)} )`;
}

/**
 *
 * @param {ReactiveLessThan} gt
 * @returns {string}
 */
function compileComparisonLT(gt) {
    return `( ${compileExpression(gt.left)} < ${compileExpression(gt.right)} )`;
}

/**
 *
 * @param {ReactiveLessThanOrEqual} gt
 * @returns {string}
 */
function compileComparisonLTE(gt) {
    return `( ${compileExpression(gt.left)} <= ${compileExpression(gt.right)} )`;
}

/**
 *
 * @param {ReactiveEquals} exp
 * @returns {string}
 */
function compileComparisonEQ(exp) {
    return `( ${compileExpression(exp.left)} === ${compileExpression(exp.right)} )`;
}

/**
 *
 * @param {ReactiveNotEquals} exp
 * @returns {string}
 */
function compileComparisonNEQ(exp) {
    return `( ${compileExpression(exp.left)} !== ${compileExpression(exp.right)} )`;
}

/**
 *
 * @param {ReactiveNegate} exp
 * @returns {string}
 */
function compileNegate(exp) {
    return `-${compileExpression(exp.source)}`;
}

/**
 *
 * @param {ReactiveOr} exp
 * @returns {string}
 */
function compileOr(exp) {
    return `( ${compileExpression(exp.left)} || ${compileExpression(exp.right)} )`;
}

/**
 *
 * @param {ReactiveAnd} exp
 * @returns {string}
 */
function compileAnd(exp) {
    return `( ${compileExpression(exp.left)} && ${compileExpression(exp.right)} )`;
}

/**
 *
 * @param {ReactiveAdd} exp
 * @returns {string}
 */
function compileAdd(exp) {
    return `( ${compileExpression(exp.left)} + ${compileExpression(exp.right)} )`;
}

/**
 *
 * @param {ReactiveMultiply} exp
 * @returns {string}
 */
function compileMultiply(exp) {
    return `( ${compileExpression(exp.left)} * ${compileExpression(exp.right)} )`;
}

/**
 *
 * @param {ReactiveExpression} exp
 * @returns {string}
 */
function compileExpression(exp) {
    if (exp.isReactiveLiteralNumber) {
        return compileLiteralNumber(exp);
    } else if (exp.isReactiveLiteralBoolean) {
        return compileLiteralBoolean(exp);
    } else if (exp.isReactiveLiteralString) {
        return compileLiteralString(exp);
    } else if (exp.isReference) {
        return compileReference(exp);
    } else if (exp.isReactiveGreaterThan) {
        return compileComparisonGT(exp);
    } else if (exp.isReactiveGreaterThanOrEqual) {
        return compileComparisonGTE(exp);
    } else if (exp.isReactiveLessThan) {
        return compileComparisonLT(exp);
    } else if (exp.isReactiveLessThanOrEqual) {
        return compileComparisonLTE(exp);
    } else if (exp.isReactiveEquals) {
        return compileComparisonEQ(exp);
    } else if (exp.isReactiveNotEquals) {
        return compileComparisonNEQ(exp);
    } else if (exp.isReactiveOr) {
        return compileOr(exp);
    } else if (exp.isReactiveAnd) {
        return compileAnd(exp);
    } else if (exp.isReactiveAdd) {
        return compileAdd(exp);
    } else if (exp.isReactiveMultiply) {
        return compileMultiply(exp);
    } else if (exp.isReactiveNegate) {
        return compileNegate(exp);
    } else {
        throw new Error(`Unknown node '${exp.constructor.name}'`);
    }
}

/**
 *
 * @param {ReactiveExpression} exp
 * @return {string}
 */
export function compileReactiveToJS(exp) {
    return compileExpression(exp);
}