How to Merge Two Games with AI: Game Mashups, Mods and Code

Mario in Elden Ring and other game mashup examples

These are author/vendor descriptions reviewed on 10 October 2026, not our own playtests. Melty describes a create/publish workflow that gives instructions to a coding agent. That is context for how creators use AI, not proof that every mashup uses AI or that any pair of games works. The commercial titles remain reference examples; their files are not bundled. Our worked example below is entirely original.

Vibe coding games, AI-assisted modding and world remixes

Use the name that fits the workflow you want to build.

Vibe coding games

Using natural-language requests to iterate on code with an AI assistant. In this guide, preserve a working baseline and verify each small change.

AI-assisted game modding

An assistant helps create or debug a plugin, script or asset workflow. Name the tools the creator actually credits; do not infer AI use from a dramatic result.

Game mechanics mashup

Original rules interact inside one game loop: collecting a token replenishes an arena ability. This is the approach used by the downloadable lab.

Runtime bridge

Two simulations exchange state through an adapter or protocol. SkyCraft describes a shared-memory bridge; ER Mario feeds host collision to libsm64.

AI world model / world remix

A model generates an explorable environment from prompts. Project Genie is a separate workflow from adapting game source code.

How to combine game mechanics without conflicting systems

Copying both projects into one folder does not resolve who owns time, physics, controls or saves. Keep one host authoritative and adapt each donor to a written contract.

How to merge two games with AI, step by step

1. STEP 1

   Choose the kind of mashup

   Distinguish a runtime mod, a bridge between games, an original mechanic blend and an AI-generated world.

   

   If you own two source projects, first run each unchanged and record its controls, rules and target. For a retail crossover, the creator architecture and required local inputs are a different path. This guide does not install retail mods or supply game files.

2. STEP 2

   Choose one host and write the contract

   Preserve the existing game loop and define coordinates, time, input, state, events and outcomes.

   

   In our lab the shared world is 640 × 360, speed 180 world pixels/second, time advances in at most 0.01 second substeps and long frames cap 0.1 second. The host controls movement and results; adapters return events.

3. STEP 3

   Adapt one donor at a time

   Keep independent modes working; route donor events through the shared host rather than duplicating controllers or loops.

   

   Run collector and arena separately before enabling hybrid. Collector wins at four tokens; arena wins after twenty seconds and refills pulse charges over time. Do not give either adapter an animation loop or a competing win screen.

4. STEP 4

   Make the mechanics interact

   Connect a collection event to one arena pulse-charge refill; define a coherent combined win rule.

   

   Hybrid replaces timed refill with collection refill. Collecting a token produces one unique event, grants one charge up to three, and never wins early. Survive AND collect; loss takes priority. This interaction makes a mechanic blend rather than two unrelated minigames.

5. STEP 5

   Use AI in small, testable changes

   Review proposed files, execute baseline/adapter/hybrid checks, compare evidence and test the target controls before shipping.

   

   Ask your coding assistant to change one boundary, show complete changed files and add a check that can fail. Inspect the diff and execute the check. A polished generated video or decompiler screenshot does not establish a working code integration. Test the browser/device controls after the native core.

Original worked code: Collector + Arena = Token Pulse

collector.mjs · arena.mjs · host.mjs · check.mjs · input.mjs · serve.mjs · index.html · style.css · main.mjs · README.md · LICENSE.txt · files.mjs

Extract the whole merge-lab folder. Requires Node24; no packages or game assets to install. Keep its MIT notices.

node check.mjs
node serve.mjs

The first command should report 22 passing native core checks. The second prints a localhost URL for manual practice; stop with Ctrl+C. Keep all files together and use the local helper rather than double-clicking HTML. Do not expose this helper as a public server.

Compare the Collector, Arena and Hybrid selector modes. Move with WASD/arrows or direction buttons, use Pulse, then try pause/resume, leave/return and restart. These are manual acceptance instructions; browser/render/keyboard/touch/device checks remain OPEN. The canvas uses original procedural circles. This V1 teaching probe is not a complete BINX.fun V2 game.

The shared host and interaction

/* Original Forge merge host; shared timing/motion pattern from Pocket Engine1.0. MIT. */
import {createTokens,collect} from './collector.mjs';
import {arenaStep,pulse} from './arena.mjs';
export const modes=['collector','arena','hybrid'];
const clamp=(n,a,b)=>Math.max(a,Math.min(b,n));
export function createState(mode='hybrid'){
 if(!modes.includes(mode))throw Error('Choose collector, arena or hybrid');
 return {mode,status:'ready',age:0,remaining:20,player:{x:320,y:180},tokens:mode==='arena'?[]:createTokens(),hazards:[],collected:0,defeated:0,hp:3,charges:1,spawnClock:3,chargeClock:3,invulnerable:0,nextHazard:0,pulseHeld:false,events:[]};
}
export function start(mode='hybrid'){const s=createState(mode);s.status='running';return s;}
export function togglePause(s){if(s.status==='running')s.status='paused';else if(s.status==='paused')s.status='running';s.pulseHeld=false;}
export function step(s,input={},dt=0.01){
 if(s.status!=='running'||!Number.isFinite(dt)||dt<=0||dt>0.01+1e-9)return;
 s.events=[];s.age+=dt;
 const dx=Number(!!input.right)-Number(!!input.left),dy=Number(!!input.down)-Number(!!input.up),length=Math.hypot(dx,dy)||1;
 s.player.x=clamp(s.player.x+dx/length*180*dt,14,626);s.player.y=clamp(s.player.y+dy/length*180*dt,14,346);
 if(s.mode!=='arena')for(const event of collect(s)){s.events.push(event);s.collected++;if(s.mode==='hybrid')s.charges=Math.min(3,s.charges+1);}
 if(s.mode!=='collector'){
  s.remaining=Math.max(0,s.remaining-dt);s.chargeClock-=dt;
  if(s.mode==='arena'&&s.chargeClock<=0){s.chargeClock+=3;s.charges=Math.min(3,s.charges+1);}
  if(input.pulse&&!s.pulseHeld)for(const event of pulse(s)){s.events.push(event);s.defeated+=event.removed;}
  s.pulseHeld=!!input.pulse;
  for(const event of arenaStep(s,dt)){s.events.push(event);if(event.type==='damage')s.hp-=event.amount;}
 }
 // Exactly one host owns outcomes. Donors report events and never start loops.
 if(s.hp<=0)s.status='lost';
 else if(s.mode==='collector'&&s.collected===4)s.status='won';
 else if(s.mode==='arena'&&s.remaining===0)s.status='won';
 else if(s.mode==='hybrid'&&s.collected===4&&s.remaining===0)s.status='won';
}
export function advance(s,input,elapsed){
 if(!Number.isFinite(elapsed)||elapsed<=0)return;
 const dt=Math.min(0.1,elapsed),count=Math.ceil(dt/0.01);
 for(let i=0;i<count&&s.status==='running';i++)step(s,input,dt/count);
}

Inspect all 22 native checks · Read scope and reuse notes · Keep the original permission notice

Reuse first: the input and local helper are existing owned Pocket Engine code; shared movement/timing and bounded wave/contact patterns adapt existing Forge labs. The new host/event/refill glue fills the integration gap. Existing donor projects and private BINX games stay intact.

AI game mashup and crossover mod questions