Initiation au BASIC – Programmer un jeu PONG sur Amstrad CPC

Programmer un jeu PONG sur Amstrad CPC

Crée ton premier jeu rétro !

Locomotive BASIC • CPC 464/664/6128 • Cours complet • Étape par étape • Résultats immédiats

Sommaire

Introduction : Bienvenue dans le monde de l’Amstrad CPC
Premier contact avec le Locomotive BASIC
Les variables : la mémoire de ton programme
Afficher et dessiner à l’écran
Les boucles : répéter des actions
Les conditions : prendre des décisions
Lire le clavier : interagir avec le joueur
Le son : faire chanter ton CPC
PROJET FINAL : Créer ton jeu PONG complet !
Pour aller plus loin

1. Introduction : Bienvenue dans le monde du CPC

Qu’est-ce que l’Amstrad CPC ?

L’Amstrad CPC (Colour Personal Computer) est un ordinateur personnel sorti en 1984, créé par la société britannique Amstrad. Il a connu un immense succès en Europe, particulièrement en France, au Royaume-Uni et en Espagne.

Le CPC se déclinait en trois modèles principaux : le CPC 464 (avec lecteur de cassettes intégré), le CPC 664 et le CPC 6128 (avec lecteur de disquettes). Tous utilisent le même BASIC : le Locomotive BASIC.

🖥️ Le Locomotive BASIC est considéré comme l’un des meilleurs BASIC de l’époque, avec des commandes graphiques et sonores intégrées très puissantes !

Pourquoi apprendre le Locomotive BASIC ?

BASIC enrichi : commandes graphiques, son, couleurs intégrées (pas besoin de POKE !)
Syntaxe claire : LOCATE, CLS, SOUND… des commandes explicites
Résultats immédiats : tape une commande, vois le résultat instantanément
Fondamentaux : variables, boucles, conditions… tout y est !

Comment pratiquer ?

Tu n’as pas besoin d’un vrai Amstrad CPC ! Utilise un émulateur gratuit :

WinAPE (Windows) : winape.net – Le plus populaire et complet
Caprice32 (Multi-plateforme) : github.com/ColinPitrat/caprice32
CPCBox (En ligne) : cpcbox.com – Directement dans ton navigateur !
RetroVirtualMachine (Mac/Windows/Linux) : retrovirtualmachine.org

💡 Conseil
Lance l’émulateur dès maintenant et garde-le ouvert. Tu vas taper du code tout au long de ce cours !

2. Premier contact avec le Locomotive BASIC

L’écran de démarrage

Quand tu allumes le CPC (ou l’émulateur), tu vois :

Amstrad 64K Microcomputer (v1)
© 1984 Amstrad Consumer Electronics plc
and Locomotive Software Ltd.

BASIC 1.0

Ready
_

Le mot « Ready » signifie que l’ordinateur attend tes instructions. Le curseur clignotant indique où tu vas taper.

Ta première commande : PRINT

La commande PRINT affiche du texte à l’écran. Tape exactement ceci et appuie sur ENTRÉE :

PRINT "BONJOUR LE MONDE!"

Résultat :

BONJOUR LE MONDE!

Ready

Bravo ! Tu viens d’exécuter ta première instruction. Le texte entre guillemets s’affiche exactement comme tu l’as écrit.

PRINT peut faire des calculs

PRINT ne fait pas qu’afficher du texte. Il peut aussi calculer :

PRINT 5+3
PRINT 10*4
PRINT 100/5
PRINT 2^8

Essaie chaque ligne. Tu verras les résultats : 8, 40, 20, 256. Les opérateurs sont : + (addition), - (soustraction), * (multiplication), / (division), ^ (puissance).

Mode direct vs Mode programme

Ce que tu viens de faire, c’est le mode direct : tu tapes une commande, elle s’exécute immédiatement. Mais pour créer un vrai programme, on utilise des numéros de ligne.

Tape ceci (sans oublier les numéros) :

10 PRINT "LIGNE 1"
20 PRINT "LIGNE 2"
30 PRINT "LIGNE 3"

Cette fois, rien ne s’affiche ! L’ordinateur a mémorisé ces lignes. Pour les voir, tape :

LIST

Pour exécuter le programme, tape :

RUN

💡 Les numéros de ligne
On utilise 10, 20, 30… (pas 1, 2, 3) pour pouvoir insérer des lignes entre. Par exemple, si tu veux ajouter quelque chose entre 10 et 20, tu peux créer la ligne 15.

Commandes essentielles

Commande	Description
`NEW`	Efface le programme en mémoire
`RUN`	Lance le programme
`LIST`	Affiche le programme
`CLS`	Efface l’écran (Clear Screen)
`ESC ESC`	Appuyer 2× sur ESC pour arrêter un programme
`RENUM`	Renumérote les lignes (pratique !)

3. Les variables : la mémoire de ton programme

C’est quoi une variable ?

Une variable, c’est comme une boîte avec une étiquette. Tu peux y ranger une valeur (un nombre, du texte) et la retrouver plus tard grâce à son nom.

En BASIC, on crée une variable simplement en lui donnant une valeur :

score = 0
vies = 3
nom$ = "JOUEUR1"

Les types de variables

Il existe plusieurs types :

Type	Suffixe	Exemple
Réel	(aucun)	`score = 3.14`
Entier	`%`	`vies% = 3`
Chaîne	`$`	`nom$ = "PAUL"`

💡 Astuce performance
Les entiers (%) sont plus rapides que les réels. Pour un jeu, utilise vies%, score%, x%, y% !

Avantage du Locomotive BASIC

Contrairement à d’autres BASIC de l’époque, le Locomotive BASIC accepte des noms de variables longs et significatifs :

score.joueur1 = 0
position.balle.x = 20
vitesse = 5

🖥️ Les noms peuvent contenir des lettres, chiffres et points. C’est bien plus lisible que les noms à 2 caractères d’autres BASIC !

Exercice pratique

Tape ce petit programme (n’oublie pas NEW pour effacer le précédent) :

NEW

10 score% = 0
20 vies% = 3
30 PRINT "SCORE:";score%
40 PRINT "VIES:";vies%
50 score% = score% + 100
60 vies% = vies% - 1
70 PRINT "NOUVEAU SCORE:";score%
80 PRINT "VIES RESTANTES:";vies%

RUN

Observe comment score% = score% + 100 fonctionne : on prend la valeur actuelle (0), on ajoute 100, et on range le résultat (100) dans score%.

4. Afficher et dessiner à l’écran

Les modes d’écran

L’Amstrad CPC propose 3 modes d’affichage :

Mode	Résolution	Texte	Couleurs
MODE 0	160×200	20×25	16
MODE 1	320×200	40×25	4
MODE 2	640×200	80×25	2

Pour notre jeu Pong, nous utiliserons le MODE 1 (40×25, 4 couleurs) – un bon compromis.

Pour changer de mode, tape la commande suivante :

MODE 1  'Change le mode et efface l'écran

Effacer l’écran : CLS

Pour effacer l’écran sans changer de mode :

CLS

Simple et efficace ! Pas besoin de codes compliqués comme sur d’autres machines.

Positionner le curseur : LOCATE

C’est LA commande magique du CPC ! LOCATE place le curseur où tu veux :

LOCATE colonne, ligne

' Exemple: afficher au centre (MODE 1)
LOCATE 18, 12
PRINT "HELLO!"

Les coordonnées vont de 1 à 40 (colonnes) et 1 à 25 (lignes) en MODE 1.

💡 Rappel
Contrairement à beaucoup d’autres BASIC, sur CPC les coordonnées commencent à 1, pas à 0 !

Les couleurs

Le CPC offre des commandes simples pour gérer les couleurs :

INK numero, couleur  'Définit une encre
PAPER numero         'Couleur du fond
PEN numero           'Couleur du texte
BORDER couleur       'Couleur de la bordure

Exemple coloré :

NEW

10 MODE 1
20 INK 0, 1   'Fond bleu
30 INK 1, 24  'Texte jaune
40 BORDER 1   'Bordure bleue
50 PAPER 0: PEN 1
60 CLS
70 LOCATE 15, 12: PRINT "AMSTRAD CPC!"

RUN

Tableau des couleurs principales

Code	Couleur	Code	Couleur
0	Noir	13	Blanc
1	Bleu	24	Jaune
6	Rouge	9	Vert

5. Les boucles : répéter des actions

Pourquoi des boucles ?

Dans un jeu, beaucoup d’actions se répètent : afficher l’écran, vérifier les touches, déplacer les objets… Les boucles permettent de répéter du code sans le réécrire.

La boucle FOR…NEXT

La boucle FOR répète un bloc de code un nombre précis de fois :

NEW

10 FOR i% = 1 TO 10
20 PRINT "Compte:";i%
30 NEXT i%

RUN

Explication ligne par ligne :

Ligne 10 : i% commence à 1, et ira jusqu’à 10
Ligne 20 : Affiche la valeur actuelle de i%
Ligne 30 : Augmente i% de 1 et retourne à la ligne 10 (sauf si i% > 10)

Le pas (STEP)

Tu peux changer l’incrément avec STEP :

10 FOR i% = 0 TO 20 STEP 2
20 PRINT i%;
30 NEXT i%

Affiche : 0 2 4 6 8 10 12 14 16 18 20

On peut même compter à l’envers :

10 FOR i% = 10 TO 1 STEP -1
20 PRINT "Decompte:";i%
30 NEXT i%
40 PRINT "DECOLLAGE!"

La boucle WHILE…WEND

Le Locomotive BASIC offre aussi WHILE…WEND, une boucle qui continue tant qu’une condition est vraie :

NEW

10 x% = 1
20 WHILE x% < 100
30 PRINT x%;
40 x% = x% * 2
50 WEND

Affiche : 1 2 4 8 16 32 64 (puis s’arrête car 128 >= 100)

🖥️ WHILE…WEND est une fonctionnalité avancée que beaucoup de BASIC de l’époque n’avaient pas !

La boucle GOTO (boucle infinie)

Pour un jeu, on a besoin d’une boucle qui ne s’arrête jamais (ou presque). On utilise GOTO :

NEW

10 CLS
20 x% = 0
30 x% = x% + 1
40 PRINT "x =";x%
50 GOTO 30

Ce programme compte indéfiniment. Pour l’arrêter, appuie 2 fois sur ESC.

Exercice : animation simple

Crée une balle qui se déplace :

NEW

10 MODE 1
20 x% = 1
30 CLS
40 LOCATE x%, 12: PRINT "O"
50 FOR d% = 1 TO 50: NEXT d%
60 x% = x% + 1
70 IF x% > 40 THEN x% = 1
80 GOTO 30

La ligne 50 est une boucle de délai – elle ne fait rien mais prend du temps, ce qui ralentit l’animation.

6. Les conditions : prendre des décisions

IF…THEN : la base

Les conditions permettent au programme de réagir différemment selon les situations. La structure de base est :

IF condition THEN action

Exemples :

10 score% = 150
20 IF score% > 100 THEN PRINT "BRAVO!"
30 IF score% = 0 THEN PRINT "GAME OVER"
40 IF score% < 50 THEN PRINT "CONTINUE..."

IF…THEN…ELSE

Le Locomotive BASIC supporte ELSE, ce qui permet de gérer les deux cas :

10 vies% = 0
20 IF vies% > 0 THEN PRINT "CONTINUE" ELSE PRINT "GAME OVER"

🖥️ ELSE sur la même ligne : c’est une fonctionnalité que beaucoup d’autres BASIC n’avaient pas !

Les opérateurs de comparaison

Opérateur	Signification	Exemple
`=`	Égal à	`IF x = 10`
`<>`	Différent de	`IF x <> 0`
`<`	Inférieur à	`IF x < 40`
`>`	Supérieur à	`IF score > 100`
`<=`	Inférieur ou égal	`IF y <= 25`
`>=`	Supérieur ou égal	`IF vies >= 1`

Combiner avec AND et OR

On peut vérifier plusieurs conditions :

10 x% = 20
20 y% = 12
30 IF x% > 0 AND x% < 40 THEN PRINT "x OK"
40 IF x% = 1 OR x% = 40 THEN PRINT "BORD!"

Application : collision avec les bords

Dans Pong, la balle rebondit sur les bords. Voici la logique :

'Si balle touche bord gauche ou droit
IF bx% <= 1 OR bx% >= 40 THEN dx% = -dx%

'Si balle touche bord haut ou bas
IF by% <= 1 OR by% >= 25 THEN dy% = -dy%

dx% et dy% sont la direction de la balle. Les inverser (-dx%) fait rebondir la balle !

💡 Commentaires
L’apostrophe ' permet d’ajouter des commentaires. L’ordinateur ignore tout ce qui suit ' sur la ligne. REM fonctionne aussi.

7. Lire le clavier : interagir avec le joueur

INKEY$ : la touche magique

Pour lire une touche sans attendre que le joueur appuie sur ENTRÉE, on utilise INKEY$ :

NEW

10 k$ = INKEY$
20 IF k$ = "" THEN 10
30 PRINT "Tu as appuye sur: ";k$
40 GOTO 10

Explication :

INKEY$ lit la touche pressée et la met dans k$
Si aucune touche n’est pressée, k$ est vide (« »)
La ligne 20 attend qu’une touche soit pressée

INKEY(n) : tester une touche précise

Le Locomotive BASIC offre aussi INKEY(n) qui teste si une touche spécifique est pressée :

'Touches flèches du curseur:
INKEY(0)  'Flèche HAUT
INKEY(2)  'Flèche BAS
INKEY(8)  'Flèche GAUCHE
INKEY(1)  'Flèche DROITE

INKEY(n) renvoie -1 si la touche est pressée, 0 sinon.

💡 Avantage
INKEY(n) peut détecter plusieurs touches en même temps, contrairement à INKEY$ !

Contrôler un personnage

Utilisons les touches fléchées pour déplacer un caractère :

NEW

10 MODE 1
20 x% = 20: y% = 12
30 CLS
40 LOCATE x%, y%: PRINT "@"
50 IF INKEY(0)<>0 AND y%>1 THEN y%=y%-1
60 IF INKEY(2)<>0 AND y%<25 THEN y%=y%+1
70 IF INKEY(8)<>0 AND x%>1 THEN x%=x%-1
80 IF INKEY(1)<>0 AND x%<40 THEN x%=x%+1
90 GOTO 30

Essaie ! Tu peux déplacer le @ avec les touches fléchées.

Codes des touches utiles

Touche	Code	Touche	Code
↑ (Haut)	0	ESPACE	47
↓ (Bas)	2	ENTER	18
← (Gauche)	8	A	69
→ (Droite)	1	Z	71

8. Le son : faire chanter ton CPC

La commande SOUND

Le CPC possède un chip sonore AY-3-8912 à 3 voix. La commande SOUND permet de jouer des sons facilement :

SOUND canal, periode, duree, volume

Où :

canal : 1, 2 ou 4 (ou combinaisons pour plusieurs voix)
période : hauteur du son (plus petit = plus aigu)
durée : en centièmes de seconde
volume : 0 (silence) à 15 (max)

Exemples de sons

Un bip simple :

SOUND 1, 200, 20, 12

Une gamme montante :

NEW

10 FOR n% = 400 TO 100 STEP -30
20 SOUND 1, n%, 10, 12
30 NEXT n%

Sons pour notre Pong

Voici les sous-programmes de son qu’on utilisera :

'--- SON DE REBOND (BALLE) ---
900 SOUND 1, 200, 3, 12
910 RETURN

'--- SON DE POINT MARQUÉ ---
950 SOUND 1, 100, 15, 15
960 RETURN

On appellera ces sons avec GOSUB 900 (rebond) ou GOSUB 950 (point).

GOSUB et RETURN

GOSUB est comme GOTO, mais il se souvient d’où il vient. RETURN revient à cet endroit :

NEW

10 PRINT "DEBUT"
20 GOSUB 100
30 PRINT "FIN"
40 END

100 PRINT "SOUS-PROGRAMME"
110 RETURN

RUN

Résultat : DEBUT, SOUS-PROGRAMME, FIN. C’est parfait pour du code qu’on réutilise !

💡 END
La commande END arrête proprement le programme. Sans elle, le programme continuerait et exécuterait le sous-programme une deuxième fois !

Tableau des périodes (notes)

DO	RÉ	MI	FA	SOL	LA
478	426	379	358	319	284

9. PROJET FINAL : Créer ton jeu PONG ! 🎮

Tu as maintenant toutes les connaissances nécessaires ! Nous allons construire le jeu étape par étape.

Architecture du jeu

Notre Pong aura :

Une balle qui rebondit
Une raquette joueur (contrôlée au clavier)
Une raquette ordinateur (IA simple)
Un score pour chaque joueur
Des sons de rebond et de point

Étape 1 : Variables et initialisation

Tape ce début de programme (NEW d’abord pour effacer) :

NEW

1  '*** PONG AMSTRAD CPC ***
10 MODE 1
20 INK 0,1:INK 1,24:INK 2,6:INK 3,13
30 BORDER 1:PAPER 0:PEN 1
40 '--- Variables ---
50 bx%=20:by%=12   'Balle position
60 dx%=1:dy%=1     'Balle direction
70 p1%=10          'Raquette joueur Y
80 p2%=10          'Raquette CPU Y
90 s1%=0:s2%=0     'Scores
95 sp%=30          'Vitesse (delai)

Les variables :

bx%, by% : position de la balle
dx%, dy% : direction de la balle (+1 ou -1)
p1%, p2% : position Y des raquettes
s1%, s2% : scores des joueurs
sp% : délai (plus petit = plus rapide)

Étape 2 : Boucle principale et affichage

Ajoute la boucle de jeu :

100 '=== BOUCLE PRINCIPALE ===
110 CLS
120 '--- Affiche score ---
130 LOCATE 15,1:PRINT "J1:";s1%;" CPU:";s2%
140 '--- Affiche raquette joueur ---
150 FOR i%=0 TO 4
160 LOCATE 2,p1%+i%:PRINT "|"
170 NEXT i%
180 '--- Affiche raquette CPU ---
190 FOR i%=0 TO 4
200 LOCATE 39,p2%+i%:PRINT "|"
210 NEXT i%
220 '--- Affiche balle ---
230 LOCATE bx%,by%:PRINT "O"

Étape 3 : Contrôles et IA

Ajoute la gestion du clavier et l’IA de l’ordinateur :

300 '=== CONTROLES ===
310 IF INKEY(0)<>0 AND p1%>2 THEN p1%=p1%-1
320 IF INKEY(2)<>0 AND p1%<20 THEN p1%=p1%+1

400 '=== IA CPU ===
410 IF by%<p2%+2 AND p2%>2 THEN p2%=p2%-1
420 IF by%>p2%+2 AND p2%<20 THEN p2%=p2%+1

L’IA est simple : elle suit la balle ! Elle compare la position Y de la balle avec le milieu de sa raquette (p2% + 2).

Étape 4 : Mouvement de la balle

La balle bouge et rebondit :

500 '=== MOUVEMENT BALLE ===
510 bx%=bx%+dx%
520 by%=by%+dy%
530 '--- Rebond haut/bas ---
540 IF by%<2 OR by%>24 THEN dy%=-dy%:GOSUB 900
550 '--- Rebond raquette joueur ---
560 IF bx%=3 AND by%>=p1% AND by%<=p1%+4 THEN dx%=1:GOSUB 900
570 '--- Rebond raquette CPU ---
580 IF bx%=38 AND by%>=p2% AND by%<=p2%+4 THEN dx%=-1:GOSUB 900

Étape 5 : Points et remise en jeu

600 '=== VERIFICATION POINTS ===
610 IF bx%<2 THEN s2%=s2%+1:GOSUB 950:GOSUB 800
620 IF bx%>39 THEN s1%=s1%+1:GOSUB 950:GOSUB 800

700 '=== DELAI ET BOUCLE ===
710 FOR d%=1 TO sp%:NEXT d%
720 GOTO 100

Étape 6 : Sous-programmes

Ajoute les sous-programmes de remise en jeu et de son :

800 '--- Remise en jeu ---
810 bx%=20:by%=12
820 dx%=-dx%
830 FOR d%=1 TO 200:NEXT d%
840 RETURN

900 '--- Son rebond ---
910 SOUND 1,200,3,12
920 RETURN

950 '--- Son point ---
960 SOUND 1,100,15,15
970 RETURN

📝 Code complet du jeu

Voici le programme complet à taper (ou copier dans ton émulateur) :

1  '*** PONG AMSTRAD CPC ***
10 MODE 1:INK 0,1:INK 1,24:BORDER 1:PAPER 0:PEN 1
20 bx%=20:by%=12:dx%=1:dy%=1
30 p1%=10:p2%=10:s1%=0:s2%=0:sp%=30

100 CLS
110 LOCATE 15,1:PRINT"J1:";s1%;" CPU:";s2%
120 FOR i%=0 TO 4:LOCATE 2,p1%+i%:PRINT"|";:NEXT i%
130 FOR i%=0 TO 4:LOCATE 39,p2%+i%:PRINT"|";:NEXT i%
140 LOCATE bx%,by%:PRINT"O"

200 IF INKEY(0)<>0 AND p1%>2 THEN p1%=p1%-1
210 IF INKEY(2)<>0 AND p1%<20 THEN p1%=p1%+1

300 IF by%<p2%+2 AND p2%>2 THEN p2%=p2%-1
310 IF by%>p2%+2 AND p2%<20 THEN p2%=p2%+1

400 bx%=bx%+dx%:by%=by%+dy%
410 IF by%<2 OR by%>24 THEN dy%=-dy%:GOSUB 900
420 IF bx%=3 AND by%>=p1% AND by%<=p1%+4 THEN dx%=1:GOSUB 900
430 IF bx%=38 AND by%>=p2% AND by%<=p2%+4 THEN dx%=-1:GOSUB 900

500 IF bx%<2 THEN s2%=s2%+1:GOSUB 950:GOSUB 800
510 IF bx%>39 THEN s1%=s1%+1:GOSUB 950:GOSUB 800

600 FOR d%=1 TO sp%:NEXT d%
610 GOTO 100

800 bx%=20:by%=12:dx%=-dx%
810 FOR d%=1 TO 200:NEXT d%:RETURN

900 SOUND 1,200,3,12:RETURN
950 SOUND 1,100,15,15:RETURN

Lance le jeu avec RUN et utilise les touches fléchées HAUT/BAS pour jouer !

💡 Ajuster la difficulté
Modifie la variable sp% à la ligne 30. Plus petit = plus rapide. Essaie sp%=15 pour un défi !

10. Pour aller plus loin

Améliore ton Pong !

Maintenant que tu as un jeu fonctionnel, voici des idées pour l’améliorer :

Mode 2 joueurs : remplace l’IA par des contrôles clavier (touches A/Z)
Accélération : diminue sp% à chaque rebond pour rendre le jeu plus difficile
Angle de rebond : change dy% selon l’endroit où la balle touche la raquette
Écran de titre : ajoute un menu avant le jeu avec MODE 0 et couleurs
Game Over : arrête le jeu quand un joueur atteint 10 points

Fonctionnalités avancées du CPC

Le Locomotive BASIC offre beaucoup de possibilités :

Graphismes : PLOT, DRAW, MOVE pour dessiner des lignes et formes
Sprites logiciels : TAG et PRINT CHR$ pour des personnages animés
Fenêtres : WINDOW pour créer des zones d’affichage séparées
Enveloppes sonores : ENV et ENT pour des sons élaborés

Autres projets pour débuter

Snake : un serpent qui grandit en mangeant
Breakout : casser des briques avec une balle
Guess the Number : deviner un nombre aléatoire (utilise RND)
Text Adventure : un jeu d’aventure textuel

Ressources

Manuel du CPC : cpcwiki.eu – La référence absolue
CPCRulez : cpcrulez.fr – Jeux, démos, tutoriels en français
Amstrad.eu : programmes et documentation
CPC-Power : cpc-power.com – Base de données de jeux

🎉 Félicitations !
Tu as créé ton premier jeu rétro en Locomotive BASIC !

Tu maîtrises maintenant les fondamentaux de la programmation : variables, boucles, conditions, entrées/sorties. Ces concepts sont universels et te serviront dans tous les langages modernes.

Bonne continuation dans ton aventure de programmeur ! 🖥️