Arcade-Forge : Plongée dans l'Histoire de Missile Command et Construction de Notre Propre Défense Atomique en LÖVE !
Salut les archivistes de l'arcade et les futurs développeurs de jeux !
Aujourd'hui, chez Arcade-Forge, nous allons rendre hommage à l'un des jeux les plus emblématiques et anxiogènes de l'histoire du jeu vidéo : Missile Command. Préparez-vous à un voyage dans le temps jusqu'à l'apogée de la Guerre Froide, puis à une plongée dans le code pour recréer ce classique avec le framework LÖVE2D.
L'Histoire Dramatique de Missile Command : Un Classique Né de la Peur
Missile Command, sorti en juillet 1980, n'est pas juste un jeu d'arcade, c'est un véritable témoignage de son époque.
- Qui l'a créé ? Le jeu a été développé par Atari, avec une conception principale attribuée à Dave Theurer. L'idée lui est venue après une nuit d'anxiété et de cauchemars récurrents sur l'holocauste nucléaire, une peur palpable durant la Guerre Froide. Il voulait créer un jeu qui transmette cette tension et cette impuissance face à une menace écrasante.
- Quand est-il sorti ? En plein été 1980. Le contexte géopolitique de l'époque (tensions entre les États-Unis et l'Union Soviétique, course aux armements nucléaires) a indéniablement contribué à la résonance du jeu auprès du public.
- A-t-il eu du succès tout de suite ? Oui, un succès retentissant ! Missile Command a été un hit immédiat dans les salles d'arcade. Son gameplay unique, son thème intense et son ambiance sonore et visuelle (avec le célèbre "cloc" des missiles qui montent et le "bip" des alertes) ont captivé les joueurs. Il était non seulement divertissant mais aussi profondément marquant, les laissant souvent avec un sentiment d'urgence et d'inéluctabilité. Il est devenu l'un des jeux d'arcade les plus rentables d'Atari.
Missile Command est resté gravé dans les mémoires comme un chef-d'œuvre de design qui transcende le simple divertissement pour toucher à des thèmes plus profonds.
Qu'est-ce que Missile Command ? Le But, le Gameplay, la Tension
Le But du Jeu : Votre mission est simple, mais vitale : défendre six villes (ou bases) situées en bas de l'écran contre des vagues incessantes de missiles balistiques ennemis tombant du ciel.
Comment y Jouer : Le joueur dispose de trois bases de lancement de missiles (dans le jeu original, trois sites de lancement, un central et deux latéraux).
- Ciblage : À l'aide d'un trackball (ou de la souris dans notre version), vous déplacez un viseur sur l'écran.
- Tir : En cliquant, vous tirez un missile intercepteur depuis l'une de vos bases (la plus proche du point ciblé). Ce missile s'élève et explose à l'endroit que vous avez ciblé.
- L'Explosion Salvatrice : Le but est de faire exploser votre missile juste avant qu'un missile ennemi n'atteigne le sol. L'explosion de votre missile crée une boule de feu qui détruit tous les missiles ennemis qui la traversent.
- Gestion des Munitions : Dans l'original, chaque base avait un stock limité de missiles. Une fois vides, elles ne pouvaient plus tirer. Les bases pouvaient aussi être détruites par les missiles ennemis.
- Perte du Jeu : Le jeu se termine lorsque toutes vos villes (et vos bases dans certaines versions ou si vous manquez de munitions) sont détruites. La musique emblématique et l'écran final montrant l'annihilation de vos villes contribuent à la gravité du propos.
Missile Command est un jeu d'anticipation et de gestion de ressources sous pression, où chaque décision compte et le sentiment d'être submergé est quasi constant.
Notre Projet : Recréer Missile Command avec LÖVE2D
Inspirés par ce monument, nous avons entrepris de recréer une version simplifiée de Missile Command en utilisant LÖVE2D. LÖVE est un framework de développement de jeux léger et puissant, parfait pour les débutants grâce à sa simplicité et au langage Lua.
L'objectif de ce projet était double : rendre hommage à un classique et surtout, montrer comment les mécaniques de base d'un jeu peuvent être construites pas à pas. Nous avons rencontré des défis typiques, comme la gestion des collisions et la logique de suppression d'objets, mais chaque obstacle fut une occasion d'apprendre !
Le Code Commenté : Décortiquer la Défense Atomique pour les Débutants
Maintenant, il est temps de plonger dans le cœur de notre clone de Missile Command. Nous avons commenté le code de manière très détaillée pour que même un programmeur débutant puisse comprendre chaque ligne.
-- Arcade-forge
-- main.lua
-- C'est le fichier principal de ton jeu LÖVE. Tout le code que LÖVE va exécuter est ici.
---
-- [[
-- ==========================
-- 1. Définition des Constantes
-- ==========================
-- Les constantes sont des valeurs qui ne changent pas pendant l'exécution du jeu.
-- C'est une bonne pratique de les mettre en haut pour les modifier facilement si besoin.
-- ]]
---
local SCREEN_WIDTH = 800 -- Largeur de l'écran de jeu en pixels (points sur l'écran)
local SCREEN_HEIGHT = 600 -- Hauteur de l'écran de jeu en pixels
local BASE_COUNT = 3 -- Nombre de bases (lanceurs de missiles) du joueur
local CITY_COUNT = 6 -- Nombre de villes à protéger
local MISSILE_SPEED = 200 -- Vitesse des missiles ennemis (en pixels par seconde)
local PLAYER_MISSILE_SPEED = 400 -- Vitesse des missiles que le joueur tire
local EXPLOSION_LIFETIME = 0.5 -- Durée de vie d'une explosion en secondes
local EXPLOSION_RADIUS = 50 -- Rayon initial d'une explosion (quand elle apparaît)
-- Dimensions des éléments du jeu pour les collisions.
-- On les définit ici pour être cohérent avec le dessin et la détection.
local CITY_WIDTH = 30 -- Largeur d'une ville
local CITY_HEIGHT = 15 -- Hauteur d'une ville
local BASE_WIDTH = 40 -- Largeur d'une base
local BASE_HEIGHT = 20 -- Hauteur d'une base
---
-- [[
-- ==========================
-- 2. Déclaration des Tables (Listes d'Objets)
-- ==========================
-- Les "tables" en Lua sont comme des listes ou des ensembles d'éléments.
-- Ici, chaque table va contenir tous les objets d'un certain type dans le jeu.
-- Par exemple, 'enemyMissiles' contiendra tous les missiles ennemis qui sont actuellement en l'air.
-- ]]
---
local bases = {} -- Une table pour stocker toutes les bases du joueur
local cities = {} -- Une table pour stocker toutes les villes à protéger
local enemyMissiles = {} -- Une table pour stocker tous les missiles ennemis
local playerMissiles = {} -- Une table pour stocker tous les missiles tirés par le joueur
local explosions = {} -- Une table pour stocker toutes les explosions actives
---
-- [[
-- ==========================
-- 3. Variables de Jeu Générales
-- ==========================
-- Ces variables gardent une trace de l'état global du jeu.
-- ]]
---
local score = 0 -- Le score du joueur, commence à zéro
local gameOver = false -- Un "drapeau" (flag) qui devient vrai (true) quand le jeu est terminé
---
-- [[
-- ==========================
-- 4. love.load()
-- ==========================
-- Cette fonction est la première à être exécutée quand le jeu démarre.
-- C'est ici qu'on prépare tout : on initialise les éléments, on charge les ressources.
-- ]]
---
function love.load()
-- Définit le titre de la fenêtre du jeu
love.window.setTitle("LÖVE Missile Command")
-- Configure la fenêtre : largeur, hauteur, non redimensionnable, et synchronisation verticale (pour éviter le "tearing")
love.window.setMode(SCREEN_WIDTH, SCREEN_HEIGHT, {resizable = false, vsync = true})
-- Initialisation des bases du joueur
-- On calcule un espacement pour qu'elles soient bien réparties sur la largeur de l'écran
local baseSpacing = SCREEN_WIDTH / (BASE_COUNT + 1)
for i = 1, BASE_COUNT do -- Boucle pour créer chaque base
-- Chaque base est une petite table avec sa position (x, y) et son état (vivante ou non)
-- Les bases sont placées vers le bas de l'écran (SCREEN_HEIGHT - 50)
bases[i] = {x = i * baseSpacing, y = SCREEN_HEIGHT - 50, alive = true}
end
-- Initialisation des villes
-- Même principe que pour les bases, mais plus près du bas de l'écran
local citySpacing = SCREEN_WIDTH / (CITY_COUNT + 1)
for i = 1, CITY_COUNT do -- Boucle pour créer chaque ville
-- Les villes sont placées encore plus près du bas de l'écran (SCREEN_HEIGHT - 20)
cities[i] = {x = i * citySpacing, y = SCREEN_HEIGHT - 20, alive = true}
end
-- Charge une police de caractères par défaut pour afficher le texte (score, Game Over)
love.graphics.setFont(love.graphics.newFont(20)) -- Taille de la police 20
end
---
-- [[
-- ==========================
-- 5. love.update(dt)
-- ==========================
-- Cette fonction est appelée à *chaque image* du jeu.
-- C'est ici que toute la logique du jeu est mise à jour : les mouvements, les collisions, l'apparition des ennemis, etc.
-- 'dt' (delta time) est un paramètre très important : c'est le temps écoulé depuis la dernière fois que love.update a été appelée.
-- Utiliser 'dt' permet de rendre la vitesse des objets indépendante de la vitesse de ton ordinateur (du nombre d'images par seconde).
-- ]]
---
function love.update(dt)
if gameOver then return end -- Si le jeu est terminé, on ne fait rien dans la fonction update
-- Mise à jour des missiles ennemis
-- On parcourt la table 'enemyMissiles' à l'envers (de la fin vers le début).
-- C'est important de faire ça quand on supprime des éléments d'une table pendant qu'on la parcourt,
-- pour éviter des erreurs d'index.
for i = #enemyMissiles, 1, -1 do
local missile = enemyMissiles[i] -- On prend le missile actuel
missile.y = missile.y + MISSILE_SPEED * dt -- Le missile descend (sa position y augmente)
local targetHit = false -- Un drapeau pour savoir si ce missile a touché une cible au sol (base ou ville)
-- 1. Vérifier les collisions avec les BASES
-- On vérifie seulement si le missile est arrivé assez bas pour potentiellement toucher une base.
-- 'bases[1].y - BASE_HEIGHT / 2 - 15' est une estimation du haut de la zone des bases.
if missile.y >= (bases[1].y - BASE_HEIGHT / 2 - 15) then
-- Cette boucle parcourt toutes les 'bases'.
-- 'ipairs(bases)' : C'est une fonction qui parcourt les éléments d'une table numérotée (comme une liste).
-- Elle renvoie à chaque fois deux choses : l'index (1, 2, 3...) et la valeur de l'élément.
-- '_' (underscore) : Ici, on n'a pas besoin de l'index numérique de la base (est-ce la 1ère, la 2ème ? Peu importe).
-- L'underscore est une convention en Lua pour dire "j'ignore cette valeur".
-- 'base' : Cette variable va contenir l'objet 'base' lui-même (la table {x=..., y=..., alive=...}) à chaque tour de boucle.
-- C'est cette variable 'base' qu'on utilisera ensuite pour vérifier ses propriétés.
for _, base in ipairs(bases) do
local base = base -- On prend la base actuelle (oui, le nom de la variable est le même que le paramètre de la boucle, c'est OK ici)
-- Si la base est vivante ET que le missile est dans la zone de collision de la base
if base.alive and
missile.x > base.x - BASE_WIDTH / 2 and missile.x < base.x + BASE_WIDTH / 2 and
missile.y > base.y - BASE_HEIGHT / 2 and missile.y < base.y + BASE_HEIGHT / 2 then
base.alive = false -- La base est détruite (elle n'est plus vivante)
targetHit = true -- On indique que ce missile a touché quelque chose
break -- Cesser de vérifier les autres bases pour ce missile (il n'en détruit qu'une)
end
end
end
-- 2. Vérifier les collisions avec les VILLES
-- On ne vérifie les villes QUE SI le missile n'a PAS déjà touché une base.
-- Et si le missile est arrivé assez bas pour potentiellement toucher une ville.
if not targetHit and missile.y >= (cities[1].y - CITY_HEIGHT / 2 - 15) then
for _, city in ipairs(cities) do -- Même logique de parcours que pour les bases
local city = city -- On prend la ville actuelle
-- Si la ville est vivante ET que le missile est dans la zone de collision de la ville
if city.alive and
missile.x > city.x - CITY_WIDTH / 2 and missile.x < city.x + CITY_WIDTH / 2 and
missile.y > city.y - CITY_HEIGHT / 2 and missile.y < city.y + CITY_HEIGHT / 2 then
city.alive = false -- La ville est détruite
targetHit = true -- On indique que ce missile a touché quelque chose
break -- Cesser de vérifier les autres villes pour ce missile
end
end
end
-- 3. Retirer le missile
-- Si le missile a touché une cible OU s'il a dépassé le bas de l'écran, on le retire.
if targetHit or missile.y >= SCREEN_HEIGHT then
table.remove(enemyMissiles, i) -- Retire le missile de la table
end
end
-- Mise à jour des missiles du joueur
for i = #playerMissiles, 1, -1 do
local missile = playerMissiles[i] -- Prend le missile du joueur actuel
-- Calcule la direction vers la cible (où le joueur a cliqué/touché)
local dx = missile.targetX - missile.x
local dy = missile.targetY - missile.y
local dist = math.sqrt(dx*dx + dy*dy) -- Calcule la distance restante jusqu'à la cible
if dist > 0 then -- Si le missile n'est pas encore sur sa cible
-- Calcule comment le missile doit se déplacer pour atteindre la cible en fonction de sa vitesse et du temps écoulé (dt)
local speedX = (dx / dist) * PLAYER_MISSILE_SPEED * dt
local speedY = (dy / dist) * PLAYER_MISSILE_SPEED * dt
missile.x = missile.x + speedX -- Déplace le missile horizontalement
missile.y = missile.y + speedY -- Déplace le missile verticalement
-- Vérifie si le missile a atteint ou dépassé sa cible.
-- C'est une façon robuste de le faire, même si le missile "saute" la cible à cause de sa vitesse.
if (dx * (missile.targetX - missile.x) <= 0 and dy * (missile.targetY - missile.y) <= 0) then
-- Si oui, crée une explosion à l'endroit de la cible
table.insert(explosions, {x = missile.targetX, y = missile.targetY, timer = EXPLOSION_LIFETIME, radius = EXPLOSION_RADIUS})
table.remove(playerMissiles, i) -- Retire le missile du joueur (il a explosé)
end
else -- Si le missile est déjà pile sur sa cible (distance est zéro)
table.insert(explosions, {x = missile.targetX, y = missile.targetY, timer = EXPLOSION_LIFETIME, radius = EXPLOSION_RADIUS})
table.remove(playerMissiles, i)
end
end
-- Mise à jour des explosions
for i = #explosions, 1, -1 do
local explosion = explosions[i] -- Prend l'explosion actuelle
explosion.timer = explosion.timer - dt -- Le compte à rebours de l'explosion diminue
explosion.radius = explosion.radius + 100 * dt -- L'explosion grandit visuellement
-- Vérifier les collisions entre explosions et missiles ennemis
for j = #enemyMissiles, 1, -1 do
local enemyMissile = enemyMissiles[j] -- Prend le missile ennemi actuel
-- Calcule la distance entre le centre de l'explosion et le missile ennemi
local dist = math.sqrt((explosion.x - enemyMissile.x)^2 + (explosion.y - enemyMissile.y)^2)
if dist < explosion.radius then -- Si le missile ennemi est dans le rayon de l'explosion
score = score + 10 -- Le joueur gagne des points
table.remove(enemyMissiles, j) -- Le missile ennemi est détruit par l'explosion
end
end
if explosion.timer <= 0 then -- Si le compte à rebours de l'explosion est terminé
table.remove(explosions, i) -- L'explosion disparaît
end
end
-- Faire apparaître de nouveaux missiles ennemis (très basique pour l'instant)
-- math.random() génère un nombre aléatoire entre 0 et 1.
-- Si ce nombre est très petit (0.015), un nouveau missile apparaît.
-- Cela crée une apparition aléatoire.
if math.random() < 0.015 then
-- Ajoute un nouveau missile ennemi, avec une position X aléatoire en haut de l'écran (y=0)
table.insert(enemyMissiles, {x = math.random(SCREEN_WIDTH), y = 0})
end
-- Vérifier la condition de "Game Over"
-- On suppose que toutes les villes sont détruites au début de la vérification
local allCitiesDestroyed = true
for _, city in ipairs(cities) do -- On parcourt toutes les villes
if city.alive then -- Si on trouve au moins une ville vivante
allCitiesDestroyed = false -- Alors toutes les villes ne sont pas détruites
break -- On peut arrêter de vérifier les villes
end
end
-- On fait la même chose pour les bases
local allBasesDestroyed = true
for _, base in ipairs(bases) do
if base.alive then
allBasesDestroyed = false
break
end
end
-- Si toutes les villes ET toutes les bases sont détruites, c'est "Game Over"
if allCitiesDestroyed and allBasesDestroyed then
gameOver = true
end
end
---
-- [[
-- ==========================
-- 6. love.draw()
-- ==========================
-- Cette fonction est appelée à *chaque image* juste après love.update.
-- C'est ici qu'on dessine tout ce qui doit apparaître à l'écran.
-- Il est important que love.draw() ne contienne pas de logique de jeu (mouvement, collisions)
-- car elle peut être appelée plus ou moins souvent que love.update selon la performance.
-- ]]
---
function love.draw()
-- Dessiner les bases
love.graphics.setColor(0.2, 0.8, 0.2) -- Définit la couleur de dessin en vert foncé (RVB : 0 à 1)
for _, base in ipairs(bases) do -- Pour chaque base
if base.alive then -- Si la base est vivante
-- Dessine un rectangle plein. Les coordonnées sont ajustées pour que x,y soit le centre de la base.
love.graphics.rectangle("fill", base.x - BASE_WIDTH / 2, base.y - BASE_HEIGHT / 2, BASE_WIDTH, BASE_HEIGHT)
end
end
-- Dessiner les villes
love.graphics.setColor(0.8, 0.8, 0.2) -- Couleur jaune pour les villes
for _, city in ipairs(cities) do
if city.alive then
love.graphics.rectangle("fill", city.x - CITY_WIDTH / 2, city.y - CITY_HEIGHT / 2, CITY_WIDTH, CITY_HEIGHT)
end
end
-- Dessiner les missiles ennemis
love.graphics.setColor(1, 0, 0) -- Couleur rouge
love.graphics.setLineWidth(3) -- Définit l'épaisseur de ligne à 3 pixels (pour les rendre plus visibles)
for _, missile in ipairs(enemyMissiles) do
-- Dessine une ligne pour représenter le missile. 'missile.y - 15' rend la ligne un peu plus longue.
love.graphics.line(missile.x, missile.y, missile.x, missile.y - 15)
end
love.graphics.setLineWidth(1) -- Très important : Réinitialise l'épaisseur de ligne à la valeur par défaut (1)
-- pour que les prochains dessins (comme les missiles du joueur) n'aient pas cette épaisseur.
-- Dessiner les missiles du joueur
love.graphics.setColor(0, 0, 1) -- Couleur bleue
for _, missile in ipairs(playerMissiles) do
love.graphics.line(missile.x, missile.y, missile.x, missile.y - 10)
end
-- Dessiner les explosions
love.graphics.setColor(1, 0.5, 0, 0.5) -- Couleur orange avec une transparence (0.5)
for _, explosion in ipairs(explosions) do
-- Dessine un cercle plein au centre de l'explosion, avec son rayon actuel
love.graphics.circle("fill", explosion.x, explosion.y, explosion.radius)
end
-- Afficher le score
love.graphics.setColor(1, 1, 1) -- Couleur blanche pour le texte
-- Affiche le texte "Score: " suivi de la valeur de la variable 'score'
love.graphics.print("Score: " .. score, 10, 10) -- Affiche en haut à gauche (position 10, 10)
-- Afficher "Game Over" si le jeu est terminé
if gameOver then
love.graphics.setColor(1, 0, 0) -- Couleur rouge pour le texte Game Over
-- Affiche "GAME OVER" centré sur l'écran
love.graphics.printf("GAME OVER", 0, SCREEN_HEIGHT / 2 - 20, SCREEN_WIDTH, "center")
end
end
---
-- [[
-- ==========================
-- 7. love.mousepressed(x, y, button, istouch)
-- ==========================
-- Cette fonction est appelée chaque fois qu'un bouton de la souris est pressé.
-- Elle est aussi appelée lors d'un toucher sur un écran tactile !
-- x, y: position du clic ou du toucher.
-- button: quel bouton a été cliqué (1 pour le gauche/principal).
-- istouch: indique si l'événement vient d'un écran tactile (vrai/true) ou d'une souris (faux/false).
-- ]]
---
function love.mousepressed(x, y, button, istouch)
if gameOver then return end -- Si le jeu est terminé, les clics/touchers n'ont plus d'effet
-- On vérifie si c'est un clic gauche de souris (button == 1) OU un toucher d'écran (istouch == true).
-- Cela rend le jeu jouable avec les deux types d'entrée.
if button == 1 or istouch then
-- On doit trouver la base du joueur la plus proche pour qu'elle tire le missile.
local closestBase = nil -- Variable pour stocker la base la plus proche trouvée
local minDist = math.huge -- Initialise la distance minimale à un très grand nombre (l'infini)
-- Cette boucle parcourt toutes les 'bases'.
-- 'ipairs(bases)' : C'est une fonction qui parcourt les éléments d'une table numérotée (comme une liste).
-- Elle renvoie à chaque fois deux choses : l'index (1, 2, 3...) et la valeur de l'élément.
-- '_' (underscore) : Ici, on n'a pas besoin de l'index numérique de la base (est-ce la 1ère, la 2ème ? Peu importe).
-- L'underscore est une convention en Lua pour dire "j'ignore cette valeur".
-- 'base' : Cette variable va contenir l'objet 'base' lui-même (la table {x=..., y=..., alive=...}) à chaque tour de boucle.
-- C'est cette variable 'base' qu'on utilisera ensuite pour vérifier ses propriétés.
for _, base in ipairs(bases) do
if base.alive then -- Seulement si la base est encore vivante
-- Calcule la distance entre la position du clic/toucher (x,y) et le centre de la base
local dist = math.sqrt((x - base.x)^2 + (y - base.y)^2)
if dist < minDist then -- Si cette distance est plus petite que la distance minimale trouvée jusqu'à présent
minDist = dist -- Met à jour la distance minimale
closestBase = base -- C'est cette base qui est la plus proche
end
end
end
if closestBase then -- Si une base vivante la plus proche a été trouvée
-- Crée un nouveau missile du joueur. Il part de la position de la base
-- et a pour cible la position où le joueur a cliqué/touché (x, y).
table.insert(playerMissiles, {x = closestBase.x, y = closestBase.y, targetX = x, targetY = y})
end
end
end
Les Piliers de Notre Code : Concepts Fondamentaux pour la Création de Jeux
En parcourant le code, vous avez découvert ou redécouvert des notions essentielles :
- Variables (ex:
score,gameOver) : Ce sont des conteneurs pour stocker des informations (nombres, états vrai/faux). - Tables (ex:
enemyMissiles,bases) : Des collections d'objets. Elles sont vitales pour gérer tous les éléments dynamiques de votre jeu. - Fonctions LÖVE clés :
love.load(): La phase de préparation du jeu. C'est ici que vous initialisez vos variables, créez vos bases et villes, et chargez ce dont vous avez besoin.love.update(dt): Le moteur du jeu. Cette fonction est appelée continuellement et gère la logique : mouvement des missiles, détection des collisions, destruction des éléments, apparition de nouveaux ennemis. Ledt(delta time) est crucial pour que le jeu tourne à la même vitesse sur tous les ordinateurs.love.draw(): Le pinceau du jeu. Appelé aprèsupdate, il se charge uniquement de dessiner tous les éléments à l'écran à leurs positions mises à jour.
- Boucles (
for ... do ... end) : Permettent de répéter des actions pour chaque élément d'une liste (par exemple, déplacer tous les missiles ennemis). La technique de boucler à l'envers (for i = #table, 1, -1 do) est fondamentale quand vous retirez des éléments d'une liste pendant que vous la parcourez. - Conditions (
if ... then ... end) : Le cœur de la logique décisionnelle du jeu. "Si ceci se produit, alors fais cela." (Ex: si un missile touche, alors détruis-le). - Système de Coordonnées (X, Y) : En LÖVE, le point (0,0) est en haut à gauche de votre fenêtre. L'axe X va vers la droite, et l'axe Y va vers le bas.
- Détection de Collision (Point dans Rectangle) : Une méthode simple pour savoir si un missile (représenté par un point) touche une base ou une ville (représentées par des rectangles).
Ce projet n'est pas seulement une recréation d'un classique, c'est aussi un excellent tremplin pour comprendre les principes fondamentaux de la création de jeux. Chaque ligne de code, chaque ajustement pour corriger un bug, est une leçon.
N'attendez plus ! Téléchargez LÖVE2D, copiez ce code, et amusez-vous à le modifier, à y ajouter des fonctionnalités (sons, graphismes améliorés, vagues d'ennemis plus complexes...). Le monde du développement de jeux vous attend !
Rendez-vous sur Arcade-Forge pour de nouvelles aventures pixelisées !
Et voici le jeu :
Aucun commentaire:
Enregistrer un commentaire