Introduction à la programmation en Dark Basic


Nombre de débutants se jettent dans la programmation Dark Basic sans avoir des connaissances solides en la matière ;
A qui la faute ? A cause d'une désinformation autour de ce logiciel qui est en faite dûe a la politique publicitaire de Focus. Le soft est accompagné d'un manuel d'utilisation qui s'avère, ma foi, bien insuffisant pour comprendre parfaitement la logique de programmation qui vous sera demandée.
Je vous propose a travers ce petit cours de vous familiariser avec les principes simples de la programmation informatique en langage Basic.
Autant vous prévenir tout de suite, ne vous attendez donc pas à faire un jeu sensationnel, comme la suite de Doom III en utilisant Dark Basic, mais vous pourrez tout de même avec l'expérience arriver à un résultat plus que satisfaisant.
Si vous souhaitez voir des exemples de jeux, rendez vous sur le site officiel .




Partie I - Les variables

Vous en avez peut-être entendu parler en cours de mathématiques ?
Les variables servent à stocker dans la mémoire vive de votre ordinateur les données nécessaires à votre programme.
Prenons un exemple concret : vous avez tous déjà joué avec la mascotte de Nintendo, Mario.
Notre plombier possede un certain nombre de vies, ce nombre est stocké dans la mémoire de la console. Quand vous êtes touchés par un ennemi vous perdez une vie, et donc la valeur contenue dans la variable en question est modifiée ! Car Les données des variables varient !

Nous allons tout au long de cette introduction créer un mini-jeu, un trouve-nombre, afin de mettre en application vos nouveaux acquis.
Nous devons avant apprendre à correspondre avec l'utilisateur. Pour cela, apprenons à afficher à l'écran du texte : la fameuse commande print.

Code :

print "helloworld"

Cela affichera helloworld à l'ecran, mais hélas le programme va se refermer automatiquement après son exécution, car le compilateur lit les commandes de gauche à droite et de haut en bas (de façon littéraire).
La présence des guillemets est obligatoire, ils permettent de faire comprendre à l'ordinateur qu'il s'agit d'une chaîne de caractère (du texte).
Il va donc avoir l'ordre d'afficher "helloworld", et n'a ensuite plus rien à faire. Cela engendre donc une fermeture du programme.
Pour empêcher cela, nous allons donc mettre après cette ligne l'instruction wait key qui comme son nom l'indique (pour les anglophones) va attendre que l'utilisateur presse une touche de son clavier avant de continuer.

Code :

print "helloworld"
wait key

La commande print peut egalement afficher une variable.
Nous allons apprendre à déclarer une variable (bien que ça ne soit pas indispensable sous Dark Basic, mais cela vous sera tres utile plus tard afin de vous y retrouver).
Rien de compliqué, il suffit avant tout de donner un nom à votre variable
Cependant, il y a certaines règles à bien respecter :

Le nom d'une variable ne doit pas :
- commencer par un chiffre (exemple : 1ange).
- comporter d'accent (exemple : âge ).
- comporter d'espaces (exemple : age de mon fils).
Le Dark Basic ne fait pas la différence entre minuscules et majuscules, donc la variable age sera égale à la variable Age ou bien encore à la variable agE.

Code :

Age = 20

Nous avons donné à la variable age la valeur 20 avec le signe "égal".
Nous n'avons plus qu'à afficher la commande à l'écran :

Code :

Print age 

Le programme affichera 20. Notez l'absence des guillemets, qui cette fois-ci sert à faire comprendre à l'ordinateur qu'il a pour ordre d'afficher une variable.

Code :

Age = 20
print "j'ai ",age," ans"
wait key

Exécutez le programme, ce dernier affichera à l'écran "j'ai 20 ans". Comme vous l'aurez compris, l'instruction print peut être suivie d'un grand nombre de paramètres.
Chaque paramètre doit être suivi d'une virgule .

Code :

age = 20
poids = 50
print "j'ai ",age," ans et je pese ",poids," Kilogramme(s)"
wait key

Bref, nous savons maintenant communiquer avec l'utilisateur.
Pour notre trouve-nombre, il faut tout d'abord que l'ordinateur choisisse un nombre aléatoire entre deux extremités.
Pour cela, la commande Rnd(Max) est à notre service. Il s'agit là d'une commande pseudo aléatoire qui détermine un nombre entre zéro et le maximun donné entre parenthèses.
Ici, nous allons avoir besoin de sélectionner un nombre entre 1 et 100.

Code :

Nombre_Recherche = Rnd(99)+1

Si par hasard, le générateur tombe sur 0, Nombre_Recherche sera égal à 1 ( 0+1 ).
D'autre part, si le générateur tombe sur 99, Nombre_Recherche sera égal à 100 (99+1).




La commande INPUT :

Maintenant que l'ordinateur a choisi un nombre, il faut demander à l'utilisateur de faire part à l'ordinateur de son choix.
Nous utiliserons pour cela Input.
La commande Input fonctionne un peu comme la commande print. Vous pouvez avec celle-ci affiche du texte.

Code :

Input "Quel est ton age? ",Age
print " vous avez ",age," An(s)"

Le programme ci-dessus va vous demander votre âge, cet âge sera memorisé dans la variable "age".
Le programme affichera ensuite votre âge à travers la phrase, " Vous avez X an(s) ".
Comme vous le voyez, nous pouvons grâce à input afficher un texte et mémoriser ensuite une donnée dans une variable.
Dans notre cas, l'utilisateur doit composer un nombre compris entre 1 et 100.




Les conditions :

Dans notre vie, nous sommes souvent appeleés à utilisé les "si".
Ce "si" est unique, il permet d'établir une condition.

Un exemple simple :
"Si j'ai une mauvaise vue, alors j'ai besoin de lunettes."

Ces conditions peuvent alors se suivre :
- Si j'ai une mauvaise vu, alors j'ai besoin de lunettes.
- Si je suis myope, j'aurais besoin d'un type x de verre.
- Si je suis presbytes, j'aurais besoin d'un type x' de verre"

Nous utilisons ce petit mot très couramment dans notre vie sans forcément s'en rendre compte.

Les conditions se révèlent être un élément très important d'un programme. Les séries de si vont donner vie à votre programme.

Dans notre trouve-nombre, nous avons besoin de :

1 - Limiter le nombre que l'utilisateur rentrera.
Celui-ci a la possibilité d'entrer un nombre compris entre 1 et 100.
Si le nombre est supérieur à 100 ou inférieur à 0, on lui redemande de composer sa proposition sans pour autant lui retirer une chance.

2 - Vérifier si la proposition du joueur est :
- Supérieure au nombre cherché .
- Inférieure au nombre cherché.
- Egale au nombre cherché.

Maintenant que nous avons les principes en tête, il ne reste plus qu'à mettre cela en application.




Les boucles :

Une boucle permet de répéter une action un certain nombre de fois.
Certaines boucles sont faites pour répéter un nombre infini de fois les instructions données.
Nous allons nous intéresser a la boucle "DO : LOOP". Il existe de nombreuses boucles différentes et plus pratiques dans certaines situations, mais nous étudierons cela plus tard.

Infini dites vous ? En réalité, non, car il faut tout de même établir une condition de "sortie". Lorsque l'utilisateur appuyera sur la touche "Esc" de son clavier, le programme se fermera. De même, nous voulons que le programme se ferme une fois que le joueur a trouvé le bon nombre, ou qu'il n'a plus d'essais possibles.

Taper ce code sur votre compilateur :

Code :

do
    print "ça se répète à l'infini !!"
loop

Executez ! Comme vous le voyez, "ça se repete a l'infini !!" va se repéter à l'écran tant que vous n'appuyez pas sur la touche "Esc".
Vous me direz alors, quelle est l'utilité des boucles ?

Dans notre jeu, il s'agira de répéter la demande jusqu'à ce que le joueur :
- Ait trouvé le bon nombre.
- N'ait plus d'essais possibles.
- Ait appuyé sur la touche "Esc".




Les commentaires & la syntaxe :

Ce n'est pas un principe, mais ceci se révèle indispensable en programmation.
Vous pouvez à tout moment vous permettre de glisser des notes dans votre code afin de le rendre plus lisible et compréhensible pour les autres personnes que vous. Très pratique lors des phases de debuggage (lorsque l'on cherche a corriger des bugs, on peut mettre en commentaire du code suceptible de créer un bug : en faisant cela, le compilateur ignorera ces commandes).

Pour insérer un commentaire il suffit de mettre rem ou ` suivi d'un espace puis de votre texte.
Si vos commentaires prennent plusieurs lignes, il est peut-être bon d'utiliser la commande remstart/remend. Entre ces deux instructions, vous pouvez écrire autant de lignes de code que vous le souhaitez, tout sera ignoré par le compilateur.

Code :

rem Commentaire sur une ligne
 `Commentaire sur une ligne

 RemStart
  commentaire
  sur plusieurs
  Lignes
 Remend

Une autre chose importante, la possibilité de mettre plusieurs instructions sur une ligne. Chaque commande que vous souhaitez faire suivre d'une autre commande devra d'abord être suivie par ; ou :.

Code :

print " salut " ; wait key

Le trouve-nombre :

Nous allons enfin passer à la programmation de votre premier jeu. Toutes les notions apprises précédemment sont fraîches ? Alors allons-y.

Je vais vous donner un code commenté, étape par étape.

Code :

`*******************
`** Trouve Nombre **
`** Auteur : Vous **
`*******************

`Cette commande permet a l'ordinateur de ne pas toujours affichés les mêmes 
`nombres aleatoires.

 Randomize timer()

`1er chose a faire on declare les differentes variables

 Nombre_Cherche = Rnd(99)+1 ; ` C'est le chiffre choisis par l'ordinateur.
 Nombre_Joueur  as Integer  ; `la variable qui stockeras la proposition du joueur.
                            ; `C'est un entier, donc si le joueur tape un Nombre
                            ; `decimal, il n'en tiendras pas compte.
 Chance_Joueur = 10         ; `On donne au Joueur 10 chances afin de trouver le 
                            ; `Nombre.        
                            
`Boucle DO - LOOP que l'on va appeler " Principale "
`Boucle Principale

Do
	Cls ; `permet d'effacer l'ecran, ainsi , une fois l'operation de saisie 
	    ; `terminé ; l'affichage du egale ; plus petit ; plus grand ; on efface
	    ; `ce qui a été ecrit sur l'ecran pour ne pas gener le joueur. cela apporte
	    ; `une difficluté supplementaire car le joueur doit se rappeler de ses
	    ; `propositions.
	    
	Print " Il vous reste ",Chance_Joueur," chances."     
	Input " Tapez un Nombre compris entre 1 et 100 ", Nombre_Joueur
	
	`Si la proposition est egale au Nombre recherché alors...
	
	if Nombre_Joueur = Nombre_Cherche
		print " Bravo "
		wait key ; end
	else ; `autrement
	`Si ce Chiffre n'est pas egale, alors il est soit plus grand, soit plus petit
	`Si il est plus grand, alors on marque " Moins " autrement, c'est qu'il 
	`est plus petit ( car il ne peut pas être egale, car on stoppe le programme avant )
	`et l'on marque moins.	 
	  if Nombre_Joueur > Nombre_Cherche
	   	Print " Moins "
	  else
	  	   Print " Plus "
	  endif
	endif  
	
	if Nombre_Joueur >= 1 and Nombre_Joueur =< 100 
	 Dec Chance_Joueur,1 ; `On enleve une chance au joueur 
	                     ; `seulement si la proposition est comprise entre 1 et 100.
	endif 
	
	`si le joueur n'a plus de chance, alors c'est le game over et l'on ferme le jeu.
	
	if Chance_Joueur = 0 
		 print " Game over " 
		 wait key ; end 
	endif	 
	
	Print " Appuyez sur une touche pour continuer "
	
	wait key
	
Loop ; `on Boucle la boucle.

Partie II - Consolidification des bases


Les différents types de variables

Si êtes d'une nature curieuse, vous avez sans doute essayé ceci :

Code :

Nom = "Tersa"
print Nom

Hélas, lors de la compilation du programme, un joli message d'erreur viendra vous déranger.
La première chose à savoir est que la variable nom ne peut contenir que des entiers, par exemple : 10, 20, 30, 30000, -200, etc ...
Pour vous permettre de stocker des données telles que votre nom, il vous faut déclarer la variable de la façon suivante :

Code :

Nom as String

J'en vois certains sourire à la vue du mot string, qui signifie en français, ficelle, ou chaîne ... Chaîne de caractère. En effet, votre nom est une suite de caractères qui devront être placés entre guillemets.

Code :

Nom as string
Nom = "Tersaken"
Print Nom
wait key

Notez que la déclaration de la variable nom peut être évitée ainsi :

Code :

Nom$ = "Tersaken"
Print Nom$
wait key

Qui vous fera ainsi économiser une ligne de code. Le $ placé derrière le nom de la variable sert à indiquer au compilateur que l'on manipule une variable de type string. Il vous faudra par la suite ajouter le $ à chaque utilisation de la variable, nom$ étant différent de nom.

Comme des valeurs mathématiques, les strings peuvent être additionnées.

Code :

String1$ = "I come from "
String2$ = "England"
Print String1$+String2$
wait key

Vous obtiendrez "I come from england", mais contrairement aux mathématiques, l'ordre lors d'une addition est important, essayez donc cela :

Code :

String1$ = "I come from "
String2$ = "England"
Print String2$+String1$
wait key

Cette particularité peut être très intéréssante, nous en reparlerons plus tard.

Continuons, que faites-vous si vous voulez stocker des nombres ayant des valeurs décimales ?
Vous déclarez une variable comme suit :

Code :

decimale as float
decimale = 10.03
print decimale
wait key

Remarquez que nous n'utilisons pas de virgules pour séparer la partie entière, et la partie décimale, nous utilisons un simple point. Comme précédemment, vous pouvez économiser une ligne de code en procédant comme ceci :

Code :

decimale# = 10.03
print decimale#
wait key

Apprenez aussi que ce type de variable est limité a 7 chiffres après la virgule.

Il existe encore quelques types de variables :

Les Booleans :
Les booleans (booléens) doivent, eux, être obligatoirement déclarés. Ils, sont utilisés pour stocker une valeur simple, vrai ou faux, representés en informatique respectivement par un 1 et un 0.
L'intérêt par rapport a un entier ? Tout simplement qu'ils prennent beaucoup moins de place en mémoire,
donc dès que vous avez besoin de ce genre de variable, pensez au boolean, dans un soucis d'otpimisation.

Code :

Ex_Boolean as boolean

Les Bytes :
Un byte (octet) est une série constituée de huit 0 ou 1. Je ne souhaite pas rentrer dans les détails, mais sachez simplement que ce type de variable peut contenir des valeurs comprises entre 0 et 255 ou de -127 a 128. Les valeurs stockées ne sont que des valeurs entières. Comme les booleans, il prennent moins de place en memoire.

Code :

Ex_Byte as byte

Les Words :
Les words (mot en anglais) sont ce que l'on pourrait appeler des "doubles bytes", soit une suite de seize 0 ou 1 , ce qui nous donne la possibilité de stocker des valeurs de 0 a 65535.

Code :

Ex_Word as word

Les Dwords :
Les dwords sont littéralement parlant des "double word", donc, que l'on pourrait également appeler des quatruple bytes. Le stockage s'effectue sur 32 bits, ce qui nous donne la possibilité de stocker des valeurs de 0 à 4,294,967,295.

Code :

Ex_Dword as dword

Ils existent encore d'autre types de variables, je les ai mis un peu à part, car je ne m'en sers tout simplement jamais :

Les DOUBLE INTEGER peuvent stocker des valeurs comprises entre –9,223,372,036,854,775,808 et 9,223,372,036,854,775,807, ce qui vous laisse une grande marge. Sachez aussi que ce type de variable est assez friand en mémoire.

Les DOUBLE FLOAT peuvent quant à eux stocker des variables jusqu'à 1.7E +/- 308.


Si vous êtes interessés par le stockage des données, voici un petit paragraphe vous étant pleinement destiné.
Il est possible que vous ne compreniez pas cela, mais cela n'a pas réellement d'importance .


Les variables ont plusieurs types. Ces type se définissent par le nombre d'octets destinés à coder une valeur.
Un octet, c'est une série de 0 et de 1 (8 en l'occurence), soit une solution totale de 256 solutions : de 0 à 255 en base 10.
Avec un Bit (0/1), on peut avoir deux solutions, donc quand on rajoute un bit supplémentaire, chacune des solution peut être suivie de 2 solution (un 0 ou un 1).
Les deux solutions se divisent en deux branches :

0 - 0
.\ 1

1 - 0
.\ 1

Ce qui forme 4 solutions. A chaque fois que l'on rajoute un bit, donc, le nombre total de solution est mutiplié par 2. Ainsi, pour trouver le nombre total de solutions on fera 2 ^ nombre de bits.

On peut regrouper 2 octets dans un word (mot), ce qui donne une valeur pouvant aller de 0 à 65535 soit 2 ^ 16.

Il existe les dword (double word), qui, comme son nom l'indique, permet de stocker 2 ^ (16 * 2) = de 0 à 4 294 967 295 (énorme ^^).

Cependant comme vous l'aurez remarqué, on ne peut pas aller dans les valeurs négatives. C'est pour ça qu'un des bit de la série est destiné à coder le signe.

Ainsi avec l'exemple precident, 2 ^ (16 * 2 - 1), soit de - 2,147,483,648 à 2,147,483,647, ce qui correspond à l'entier (integer).





Les boucles

Vous avez pu lire précédemment qu'il existait plusieurs sortes de boucles. Dans ce paragraphe, nous allons les étudier une par une, laisssant de coté la boucle DO - LOOP que vous devriez maintenant savoir utiliser.


La boucle For/Next

La boucle for/next permet de répéter une action un nombre n de fois. Nous voulons par exemple afficher 5 fois "helloworld" à l'écran. Il nous suffirait de faire ceci :

Code :

for x = 0 to 4
    print " helloworld "
next x
wait key

Voyons plus en détail ce code. La boucle est declarée avec l'instruction "for", suivie d'une variable. Cette variable va changer de valeur 5 fois, elle va prendre les valeurs suivantes :
x = 0 ; x = 1 ; x = 2 ; x = 3 ; x = 4. Une fois que x sera égal à 4, le programme exécutera une dernière fois ce qui est contenu dans la boucle. "helloworld" sera donc affiché 5 fois. Pour fermer la boucle, nous utiliserons NEXT accompagné du nom de la variable utilisée.

Code :

for x = 0 to 4
    print x
next x
wait key

Vous pouvez facilement observer le phénomène en copiant le code ci-dessus.

STEP vous permet de "sauter" d'un pas donné, voici un code très simple qui vous permettra de comprendre l'instruction :

Code :

for x = 0 to 4 step 2
    print x
next x
wait key

X prendra succesivement les valeurs suivantes : x = 0 ; x = 2 ; x = 4. L'action raéalisée par la boucle sera alors répétée 3 fois.

Nous verrons par la suite l'utilité d'une telle fonction.

[ a suivre ... ]