Benchmarking AI Agents for Game Development

# Illustrative sketch (not from the paper)
import torch

class GameAgent:
    def __init__(self, model):
        self.model = model  # language model for code generation

    def generate_game(self, prompt):
        """GameGen: generate a full game from a NL request"""
        return self.model.generate(prompt)  # returns code string

    def fix_game(self, buggy_code, defect_desc):
        """GameFix: apply a reversible mutation to repair a defect"""
        patch = self.model.generate(f"Fix: {defect_desc}")
        return buggy_code.replace("/*BUG*/", patch)

    def optimize_game(self, code, opt_prompt):
        """GameOpt: multi‑turn optimization based on feedback"""
        for _ in range(3):  # simulate three optimization turns
            improvement = self.model.generate(opt_prompt)
            code += f"\n# opt: {improvement}"
        return code

    def evaluate(self, executable):
        """Hybrid evaluation: static + dynamic runtime check"""
        static_ok = "def main" in executable
        runtime_ok = torch.tensor([1]).item() == 1  # placeholder runtime test
        return static_ok and runtime_ok

class MockModel:
    def generate(self, text):
        return f"# generated code for [{text}]"

agent = GameAgent(MockModel())
code = agent.generate_game("Create a platformer where a character jumps.")
buggy = code + "\n/*BUG*/"
fixed = agent.fix_game(buggy, "missing jump logic")
optimized = agent.optimize_game(fixed, "Improve frame rate")
print("Evaluation passed:", agent.evaluate(optimized))

// Illustrative sketch (not from the paper)
const torch = require('torch-js'); // placeholder for runtime check

class GameAgent {
  constructor(model) {
    this.model = model; // language model for code generation
  }

  // GameGen: generate a full game from a NL request
  generateGame(prompt) {
    return this.model.generate(prompt); // returns code string
  }

  // GameFix: apply a reversible mutation to repair a defect
  fixGame(buggyCode, defectDesc) {
    const patch = this.model.generate(`Fix: ${defectDesc}`);
    return buggyCode.replace('/*BUG*/', patch);
  }

  // GameOpt: multi‑turn optimization based on feedback
  async optimizeGame(code, optPrompt) {
    for (let i = 0; i < 3; i++) { // simulate three optimization turns
      const improvement = this.model.generate(optPrompt);
      code += `\n// opt: ${improvement}`;
    }
    return code;
  }

  // Hybrid evaluation: static + dynamic runtime check
  evaluate(executable) {
    const staticOk = executable.includes('function main');
    const runtimeOk = torch.tensor([1]).item() === 1; // placeholder runtime test
    return staticOk && runtimeOk;
  }
}

class MockModel {
  generate(text) {
    return `// generated code for [${text}]`;
  }
}

(async () => {
  const agent = new GameAgent(new MockModel());
  let code = agent.generateGame('Create a platformer where a character jumps.');
  let buggy = code + '\n/*BUG*/';
  let fixed = agent.fixGame(buggy, 'missing jump logic');
  let optimized = await agent.optimizeGame(fixed, 'Improve frame rate');
  console.log('Evaluation passed:', agent.evaluate(optimized));
})();