cbt-game-generator/dist/generators/constantsGenerator.js

Configuration generator for CBT animation apps

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConstantsGenerator = void 0;
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
class ConstantsGenerator {
    constructor(gamePath, gameName, gameType, numberOfVariants, targets) {
        this.gamePath = gamePath;
        this.gameName = gameName;
        this.gameType = gameType;
        this.numberOfVariants = numberOfVariants;
        this.targets = targets;
    }
    generate() {
        const constantsDir = path.join(this.gamePath, 'constants');
        fs.mkdirSync(constantsDir, { recursive: true });
        this.generateTargets(constantsDir);
        this.generateVariantsConfig(constantsDir);
        this.generateDefaults(constantsDir);
    }
    generateTargets(constantsDir) {
        const targetsContent = `export enum E${this.gameName}Targets {
${Object.values(this.targets).flat().map(target => `  ${target} = "${target}",`).join('\n')}
}`;
        fs.writeFileSync(path.join(constantsDir, 'targets.ts'), targetsContent);
    }
    generateVariantsConfig(constantsDir) {
        const variantsContent = `export enum E${this.gameName}Variants {
${Array.from({ length: this.numberOfVariants }, (_, i) => `  V${i + 1} = "${this.generateUniqueId()}",`).join('\n')}
}

export enum ECategories {
  SPEECH = "SPEECH",
}

export enum EObjectsNames {
  PLAY_BUTTON = "play-button",
  BACKGROUND = "background",
  INTRO_PROMPT = "intro-prompt",
  INTERACTION_PROMPT = "interaction-prompt",
  REINFORCEMENT_PROMPT = "reinforcement-prompt",
}

export enum E${this.gameName} {
  // Default values
  PLAY_BUTTON,
  BACKGROUND,
  SPEECH_VISUAL_CLUES,
  SUCCESS_REINFORCEMENT,
  FAILURE_REINFORCEMENT,
  PARTIAL_SUCCESS_REINFORCEMENT,
  CLAPPING_AUDIO,
  FONT,
  EXIT_AUDIO,
  WHAT_IS_THIS_AUDIO,
  THIS_IS_A_AUDIO,

  // Target-based properties
${Object.values(this.targets).flat().map(target => {
            const properties = [
                `  ${target}_LOTTIE`,
                `  ${target}_WEBP`,
                `  ${target}_AUDIO`
            ];
            if (this.gameType === 'SPEECH') {
                properties.push(`  ${target}_FACE_PROMPT`, `  ${target}_FACE_PROMPT_HALF`);
            }
            return properties.join(',\n');
        }).join(',\n')}
}

export enum EGame2States {
  INTRO = "intro",
  INTERACTION = "interaction",
  INTERACTION_SECOND_CHANCE_INTRO = "interaction2_intro",
  INTERACTION_SECOND_CHANCE = "interaction2",
  REINFORCEMENT = "reinforcement",
}

export enum EReinforcementTypes {
  SUCCESS = "success",
  PARTIAL_SUCCESS = "partial-success",
  FAILURE = "failure",
}

export interface AssetsMapping {
  backgroundWebp: string;
  lottie: string;
  audio?: string;
  facePrompt?: string;
  halfFacePrompt?: string;
}

${Object.entries(this.targets).map(([subLo, targets], index) => `export const ${this.gameName.toLowerCase()}ConfigV${index + 1}: Record<string, any> = {
${targets.map(target => `  ${target}: "${target}",`).join('\n')}
};`).join('\n\n')}

${Object.entries(this.targets).map(([subLo, targets], index) => `export const assetLottieWebpMappingSubLo${index + 1}: Record<string, AssetsMapping[]> = {
${targets.map(target => `  ${target}: [
    {
      backgroundWebp: "${target.toLowerCase()}.webp",
      lottie: "${target.toLowerCase()}.json",
      ${this.gameType === 'SPEECH' ? `facePrompt: "${target.toLowerCase()}.mp4",
      halfFacePrompt: "${target.toLowerCase()}_half.mp4",` : ''}
    },
  ],`).join('\n')}
};`).join('\n\n')}`;
        fs.writeFileSync(path.join(constantsDir, 'variantsConfig.ts'), variantsContent);
    }
    generateDefaults(constantsDir) {
        fs.writeFileSync(path.join(constantsDir, 'defaults.ts'), 'export const defaults = {};');
    }
    generateUniqueId() {
        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
        let result = '';
        for (let i = 0; i < 8; i++) {
            result += chars.charAt(Math.floor(Math.random() * chars.length));
        }
        return result;
    }
}
exports.ConstantsGenerator = ConstantsGenerator;