Créez les jeux vidéo que vous imaginez.

function createGame() {
  return {
    title: "Votre prochaine pépite",
    bugs: 0 // Pour le moment.
  };
}

function motivationDavid() {
  // David entre dans le chat.
  return "Sort toi les doigts";
}
function fixBug(game) {
  // Un corrigé. Deux offerts.
  game.bugs += 2;
  return game;
}

function spawnBoss() {
  // Le vrai boss de fin :
  return "Le point-virgule oublié";
}

function saveGame(game) {
  // Avant de tout améliorer.
  return { ...game, saved: true };
}

function countHardProblems() {
  // Les deux grands problèmes :
  return [
    "Nommer les variables",
    "Vider le cache",
    "Savoir compter"
  ];
}

function nameFinalVersion() {
  // Cette fois, promis.
  return "jeu_final_v8_vraiment_final";
}

function testGame() {
  const worksOnMyMachine = true;
  // On livre mon PC avec le jeu ?
  return worksOnMyMachine;
}
const game = createGame();
motivationDavid();
fixBug(game);
spawnBoss();
saveGame(game);
testGame();
// Ça marche ? On ne touche plus.

function makeCoffee(cups) {
  // Le compilateur accepte aussi les expressos.
  const focus = Math.min(cups, 4);
  return { focus, tremblement: cups > 4 };
}

function startGameJam(hours) {
  // 48 heures. Dont 12 pour choisir la police.
  const usefulHours = Math.max(0, hours - 12);
  return usefulHours;
}

function estimateProject(days) {
  // Une petite feature, disait-il.
  const optimism = 3;
  return days * optimism;
}

function reduceScope(features) {
  // Le MMO attendra la prochaine game jam.
  const keep = features.slice(0, 3);
  return keep;
}

function chooseEngine(engines) {
  // Le meilleur moteur reste celui qu'on ouvre.
  const installed = engines[0];
  return installed;
}

function nameVariable(attempt) {
  // x était pris. truc aussi.
  const prefix = "trucImportant";
  return prefix + attempt;
}

function renameProject(version) {
  // Le dossier final a encore grandi.
  const name = "final_final_promis_";
  return name + version;
}

function writeDocumentation(lines) {
  // Ce commentaire me remerciera dans six mois.
  const effort = Math.ceil(lines / 10);
  return effort;
}

function readOldCode(months) {
  // Qui a écrit ça ? Ah. Moi.
  const author = "moi, mais avant le café";
  return { months, author };
}

function explainMagicNumber(value) {
  // 42. La documentation tient en deux chiffres.
  const explanation = "ça marchait avec ce nombre";
  return { value, explanation };
}

function addOneFeature(features) {
  // Le bouton Options ouvre un deuxième projet.
  const next = [...features, "juste une option"];
  return next;
}

function fixOnePixel(x) {
  // Toute la soirée pour un pixel. Il le méritait.
  const perfect = Math.round(x);
  return perfect;
}

function centerTheMenu(width) {
  // Le boss caché du développement web.
  const middle = width / 2;
  return { x: middle, confiance: "fragile" };
}

function chooseFont(fonts) {
  // Le gameplay attend. Cette police est jolie.
  const shortlist = fonts.slice(0, 12);
  return shortlist;
}

function pickColor(hex) {
  // C'est le même bleu. Mais en mieux.
  const approved = hex.toUpperCase();
  return approved;
}

function addScreenShake(power) {
  // Si tout tremble, personne ne voit le bug.
  const shake = Math.min(power, 8);
  return shake;
}

function spawnParticles(count) {
  // Le game feel, vendu par paquets de 100.
  const sparkles = Math.min(count, 100);
  return sparkles;
}

function makeExplosion(size) {
  // On avait dit une petite explosion.
  const dramaticSize = size * 3;
  return dramaticSize;
}

function balanceWeapon(damage) {
  // Équilibré, sauf quand mon frère joue.
  const balanced = Math.max(1, damage - 1);
  return balanced;
}

function nerfBoss(health) {
  // Le testeur voulait voir le niveau deux.
  const mercy = Math.ceil(health * 0.8);
  return mercy;
}

function buffSlime(level) {
  // Il était mignon dans le tutoriel.
  const damage = level * level;
  return damage;
}

function teachTutorial(steps) {
  // Le joueur a déjà cliqué sur Passer.
  const remembered = steps.slice(0, 1);
  return remembered;
}

function showHint(deaths) {
  // Conseil : essayer de rester vivant.
  const message = deaths > 5 ? "Respire." : "Tu gères.";
  return message;
}

function respawnPlayer(lives) {
  // Encore une. C'est la dernière. Enfin presque.
  const remaining = Math.max(0, lives - 1);
  return remaining;
}

function addCheckpoint(progress) {
  // La vraie preuve d'amour du développeur.
  const savedProgress = progress;
  return savedProgress;
}

function saveBeforeBoss(slot) {
  // La confiance, oui. Une sauvegarde, aussi.
  const backup = { slot, saved: true };
  return backup;
}

function loadSave(save) {
  // Le héros revient. Son inventaire aussi, normalement.
  const inventory = save.inventory ?? [];
  return inventory;
}

function autosave(seconds) {
  // Jamais au milieu du saut. Promis.
  const interval = Math.max(10, seconds);
  return interval;
}

function nameSaveSlot(index) {
  // Le slot 1 est sacré depuis 1998.
  const label = "Ne pas écraser " + index;
  return label;
}

function addInventory(items) {
  // 37 potions. Aucune utilisée par principe.
  const potions = items.filter(item => item === "potion");
  return potions.length;
}

function usePotion(health) {
  // Je la garde pour un combat plus difficile.
  const savedForLater = true;
  return savedForLater ? health : 100;
}

function collectLoot(rarity) {
  // Le coffre légendaire contenait une chaussette.
  const item = rarity > 9 ? "chaussette dorée" : "chaussette";
  return item;
}

function rollCritical(chance) {
  // Le hasard est surtout contre moi.
  const honestChance = Math.max(0, Math.min(1, chance));
  return honestChance;
}

function openChest(keys) {
  // La clé était dans l'autre pantalon.
  const canOpen = keys > 0;
  return canOpen;
}

function findSecret(walls) {
  // Le joueur a frappé absolument tous les murs.
  const suspicious = walls.filter(wall => wall.cracked);
  return suspicious;
}

function unlockAchievement(tries) {
  // Succès débloqué : persévérance discutable.
  const unlocked = tries >= 20;
  return unlocked;
}

function skipCutscene(seen) {
  // Le scénariste vient de verser une larme.
  const allowed = seen;
  return allowed;
}

function writeDialogue(words) {
  // Le PNJ avait juste une petite question.
  const duration = Math.ceil(words / 3);
  return duration;
}

function createNpc(name) {
  // Sa mission : bloquer exactement la porte.
  const job = "gardien du passage étroit";
  return { name, job };
}

function moveNpc(position) {
  // Il marche. Vers le mur. Avec conviction.
  const direction = { x: 1, y: 0 };
  return { position, direction };
}

function findPath(obstacles) {
  // Le chemin le plus court passe par la table.
  const detours = obstacles.length;
  return detours + 1;
}

function jumpOverGap(distance) {
  // La physique a demandé un second avis.
  const courage = distance + 0.01;
  return courage;
}

function applyGravity(velocity) {
  // Le seul système qui ne prend jamais de congés.
  const gravity = 9.81;
  return velocity + gravity;
}

function fixCollision(overlap) {
  // Les murs ne sont pas une suggestion.
  const correction = Math.max(0, overlap);
  return correction;
}

function testPhysics(mass) {
  // Le tonneau vient de quitter la carte.
  const suspiciousMass = Math.max(0.1, mass);
  return suspiciousMass;
}

function capFrameRate(fps) {
  // Mon menu tourne plus vite que mon jeu.
  const limit = Math.min(60, fps);
  return limit;
}

function optimizeLoop(iterations) {
  // On a gagné 1 ms. On fête ça 3 heures.
  const saved = Math.floor(iterations / 1000);
  return saved;
}

function profileGame(samples) {
  // Le coupable était la petite boucle innocente.
  const slowest = Math.max(0, ...samples);
  return slowest;
}

function removeDebugLogs(logs) {
  // La console avait commencé son autobiographie.
  const essential = logs.filter(log => log.level === "error");
  return essential;
}

function hideDebugMenu(release) {
  // Le bouton Triche n'est pas une fonctionnalité.
  const visible = !release;
  return visible;
}

function shipBuild(testsPassed) {
  // Ça marche chez moi. On livre mon bureau ?
  const ready = testsPassed;
  return { ready, portable: "à vérifier" };
}

function versionBuild(number) {
  // Cette version corrige la version corrective.
  const patch = number + 1;
  return "1.0." + patch;
}

function writePatchNotes(bugs) {
  // Correction de divers trucs très précis.
  const fixed = Math.max(0, bugs);
  return fixed + " raisons de mettre à jour";
}

function readBugReport(report) {
  // Étapes : jouer. Résultat : ça marche pas.
  const details = report.steps ?? "Mystère";
  return details;
}

function reproduceBug(attempts) {
  // Il disparaît dès qu'on partage son écran.
  const reproducible = attempts % 7 === 0;
  return reproducible;
}

function closeTicket(fixed) {
  // Le ticket est fermé. Le débat reste ouvert.
  const status = fixed ? "résolu" : "à reproduire";
  return status;
}

function handleFeedback(comments) {
  // Tout le monde veut un jeu différent.
  const useful = comments.filter(comment => comment.actionable);
  return useful;
}

function testOnMobile(width) {
  // Le bouton est parti vivre hors de l'écran.
  const compact = width < 600;
  return compact;
}

function supportController(connected) {
  // La manette fonctionne. Sauf le bouton jouer.
  const input = connected ? "manette" : "clavier";
  return input;
}

function remapKeys(key) {
  // ZQSD rencontre WASD. Débat international.
  const binding = key.toUpperCase();
  return binding;
}

function adjustVolume(volume) {
  // Le premier son a réveillé le quartier.
  const safe = Math.min(0.5, Math.max(0, volume));
  return safe;
}

function loopMusic(minutes) {
  // Le compositeur l'aimait. Au début.
  const repeats = Math.floor(minutes / 2);
  return repeats;
}

function addFootsteps(speed) {
  // Le ninja porte apparemment des sabots.
  const loudness = speed * 0.1;
  return loudness;
}

function muteMenu(muted) {
  // Le meilleur correctif de la réunion.
  const silence = muted ? 0 : 1;
  return silence;
}

function chooseResolution(width) {
  // Les pixels ont demandé plus d'espace.
  const height = Math.round(width * 9 / 16);
  return { width, height };
}

function resizeSprite(scale) {
  // Le héros a mangé le mauvais champignon.
  const safeScale = Math.max(0.1, scale);
  return safeScale;
}

function animateWalk(frames) {
  // Deux images. Beaucoup d'imagination.
  const frameCount = Math.max(2, frames);
  return frameCount;
}

function flipSprite(left) {
  // Il court à gauche avec une grande certitude.
  const scaleX = left ? -1 : 1;
  return scaleX;
}

function drawShadow(height) {
  // Sans ombre, tout le monde fait du lévitage.
  const opacity = Math.max(0.1, 1 - height / 100);
  return opacity;
}

function addBloom(intensity) {
  // On distingue encore le jeu. Augmente un peu.
  const glow = Math.min(2, intensity);
  return glow;
}

function fixCamera(target) {
  // Le héros est hors champ. Choix artistique ?
  const focus = target;
  return focus;
}

function zoomCamera(zoom) {
  // Un gros plan sur le bug, c'est courageux.
  const framed = Math.max(0.5, Math.min(2, zoom));
  return framed;
}

function shakeController(force) {
  // La manette essaie de fuir le boss.
  const vibration = Math.min(1, force);
  return vibration;
}

function scheduleBreak(hours) {
  // Le bug attendra. Tes poignets préfèrent.
  const due = hours >= 1;
  return due;
}

function stretchFingers(minutes) {
  // David valide le mouvement. Pas l'excuse.
  const ready = minutes > 0;
  return ready;
}

function watchOneTutorial(videos) {
  // Un seul tuto. Puis soudain, dimanche.
  const remaining = Math.max(0, videos - 1);
  return remaining;
}

function leaveTutorialHell(projects) {
  // Fermer la vidéo compte comme première étape.
  const next = projects[0] ?? "un petit Pong";
  return next;
}

function askCommunity(question) {
  // Le canard en plastique était indisponible.
  const message = question.trim();
  return message;
}

function explainToDuck(problem) {
  // Le canard ne juge pas les noms de variables.
  const understood = problem.length > 0;
  return understood;
}

function finishPrototype(playable) {
  // Pas parfait. Mais cette fois, on peut jouer.
  const victory = playable;
  return { victory, next: "faire tester" };
}