Anatomie d’une animation graphique écrite en Gambas
Une démo grâce au composant SDL de Gambas.
Si, comme moi, vous êtes amateur de démos façon oldskool (Atari ou Amiga), peut-être vous est-il venu l’idée d’écrire vos propres programmes d’animation
graphique. Cela est une excellente idée. Comme toute création, la programmation apporte beaucoup de plaisir mais aussi, ne nous le cachons pas, beaucoup de difficultés parfois.
Mais quelle fierté de voir se matérialiser sous ses yeux le résultat de ses propres lignes de code.
Cette documentation est faite pour vous si vous n’êtes pas familier avec ce type de programme informatique ayant pour but d’animer votre écran et les yeux de ceux qui vont le regarder.
Écrire du code, quel qu’il soit, demande du savoir et des efforts. Les lignes qui suivent ont donc la modeste ambition de partager mes connaissances avec vous afin de vous aider à progresser rapidement.
Nous allons prendre les sources de la démo Worm que nous allons analyser ligne par ligne (ou presque).
Mais auparavant, on va étudier un autre code plus simple pour voir comment utiliser la bibliothèque SDL. :
SDL, c’est quoi : Simple DirectMedia Layer est une bibliothèque logicielle libre utilisée pour créer des démos graphiques en deux dimensions. Je pars du principe que vous connaissez un peu Gambas. Au moins, la façon de l’installer puis de le lancer.
- Au commencement du programme, il y a la création d’un nouveau projet Fichier ⇒ Nouveau projet.
Sélectionnez Application SDL Cela va créer un programme qui va afficher un compteur de frame
Ci-dessous le code qui est automatiquement généré.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| PRIVATE $hWindow AS Window
PUBLIC SUB Main()
$hWindow = NEW Window AS"Window"
WITH $hWindow
.Resize(640, 480
.Resizable = FALSE
.Show
.FrameRate = 60
END WITH
END
|
1
2
3
4
5
6
7
8
9
10
11
| PUBLIC SUB Window_Draw()
DIM H AS INTEGER
H = Font.DefaultHeight * 4
Draw.Clear
Draw.Font.Size = H
Draw.Text("Gambas",0, 0)
Draw.Text(CStr($hWindow.FrameCount),0, H)
END
|
1
2
3
4
5
6
7
8
9
10
| PUBLIC SUB Window_KeyPress()
SELECT CASE Key.Code
CASE Key.F1
$hWindow.FullScreen = NOT $hWindow.FullScreen
CASE Key.Esc
$hWindow.Close
END SELECT
END
|
Nous allons en premier étudier ces quelques lignes de code parce que nous verrons ultérieurement que sa structure s’appliquera à Worm et à toutes autres animations SDL.
1
| PRIVATE $hWindow AS Window 'Cette partie est l’entête du programme.
|
C’est là que sont déclarées toutes les variables utilisées ailleurs par le programme.
Ici sont déclarées les variables publiques et privées de l’application.
Selon le programme la liste de ces variables peut être conséquente $hwindow comme étant une classe propre au composant SDL.
C’est dans cette fenêtre que s’effectueront l’ensemble des affichages.
1
2
| PUBLIC SUB Main() ': On instancie la classe évite les répétitions d’appel pour chacune des lignes suivantes.
$hWindow = NEW Window AS "Window"
|
'Les lignes qui commenceront par un point se référeront à cet objet.
1
2
3
| WITH $hwindow
.Resize(640, 480) ': Taille de l’écran
.Resizable = FALSE ': Fixe la taille de l’écran aux valeurs décrites juste avant.
|
'Cela veut dire qu’il faudra mettre cette valeur booléenne à true pour avoir un affichage en plein écran.
.Show ': Affiche l’écran
.FrameRate = 60 ': Défini le nombre d’images par seconde.
End With ': fin du with
End ' Fin de la procédure Main()
[/code]
Notez que l’appel $hwindow.show va appeler automatiquement la procédure nommée Window_Draw().
Voyons cela.
1
2
3
4
5
6
7
| PUBLIC SUB Window_Draw() ': C’est la procédure d’affichage
DIM H AS INTEGER ': Variable locale utilisée pour la taille du caractère d’affichage. Taille des caractères
Draw.Clear ': On efface l’écran à chaque affichage (60 par seconde)
Draw.Font.Size = H ': Affichage des caractères avec la taille définie juste avant
Draw.Text("Gambas",0, 0) ': On affiche le mot Gambas en haut à gauche de l’écran
Draw.Text(CStr($hWindow.FrameCount),0, H) ': On affiche juste en dessous le compteur de frame. 0 = position horizontale, H = position verticale
END
|
Voilà notre programme d’affichage est fini.
Il nous reste à conclure en gérant la fermeture de la fenêtre.
Ce qui est fait par le code ci-dessous.
1
2
3
4
5
6
7
8
9
10
| PUBLIC SUB Window_KeyPress() 'si on appuie sur une touche on déclenche l’événement
SELECT CASE Key.Code ': Quelle touche a été activée
CASE Key.F1 ': Touche F1
$hWindow.FullScreen = NOT $hWindow.FullScreen ': On change pour le plein écran ou inversement
CASE Key.Esc ': Touche Escape
$hWindow.Close ': On ferme la fenêtre
END SELECT
END
|
Voilà comment fonctionne grosso-modo un projet SDL.
Quand on a compris ces bases qui sont à mon avis indispensables à connaître, on peut passer à des constructions plus complexes.
Worm
Chargez le programme puis lancez-le par la touche F5 pour voir ce qu’il fait. Faire Escape pour sortir.
Si vous avez activé la numérotation des lignes dans les paramètres de l’éditeur, vous pouvez voir que le programme fait 385 lignes.
Ce qui est relativement court en regard des propriétés de ses animations.
Commençons par les deux premières déclarations des variables privées.
1
2
3
4
| PRIVATE $hWindow AS Window ': Nous venons juste de voir un peu plus haut à quoi servait cette variable.
PRIVATE timers AS Timer ': Ici, nous déclarons un chronomètre nommé timers.
'Ce chronomètre nous servira à changer les animations du ver toutes les 22 secondes.
'Il y a 44 variables. Nous les aborderons au fur et à mesure de leur utilisation.
|
Voyons sans plus tarder notre procédure principale
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
| PUBLIC SUB Main()
DIM ii, i AS INTEGER
$hWindow = NEW Window AS "Window"
hImage = NEW Image($hWindow.Width, $hWindow.Height)
x2 = NEW INTEGER[13] ': Position x des étoiles
y2 = NEW INTEGER[13] ' : Position y des étoiles
xp = NEW INTEGER[13] ' : Position x des étoiles
yp = NEW INTEGER[13] ': Position x des étoiles
gambas = Image.Load("logo.png") ': Le logo de Gambas
Tete = Image.Load("Tete.png") ': La tête du ver
img3 = NEW Image[gambas.Height] ': Variable servant à stocker chaque ligne de l’image logo.png
FOR i = 0 TO gambas.Height
img3[i] = gambas.Copy(0, i, gambas.Width, 1)
NEXT
Timers = NEW Timer AS "MyTimer" ': On instancie la classe MyTimer
timers.enabled = TRUE ': On exécute le chronomètre
timers.Delay = 22000 ': On lui met une valeur à 22000 millisecondes
WITH $hWindow ': On initialise notre écran d’affichage
.Resize(1920, 1080) ': En 1920*1080 pixels
.Framerate = 60 ': 60 images par seconde. L’être humain ne perçoit que 60 images par seconde, donc il ne sert à rien de définir un framerate supérieur.
'Pour info, une libellule peut en percevoir 250.
.Title = "A worm with some others effects" ': Titre de la fenêtre
Lettres = Image.Load("192.png") ': Image contenant les caractères servant à l’affichage de la mention « GAMBAS »
Lettres2 = Image.Load("307.gif") ': Image contenant les caractères servant au défilement du texte
Star1 = Image.Load("Star1.png") ': On lit l’étoile bleue
Star2= Image.Load("etoile.png") ': On lit l’étoile jaune
etoile2= Image.Load("balle2.png") ': On lit la balle rouge
Charge_Fonte() ': On appelle la procédure de chargement des lettres pour Gambas
Texte() ': Puis procédure d’attribution des lettres
Charge_Fonte2() ': On appelle la procédure de chargement des lettres pour le défilement du texte
Texte2() ': Puis procédure d’attribution des lettres
scroll = $hWindow.width + 200 ': Longueur du scrolle Gambas
scroll2 = $hWindow.width + 400 ': Longueur du défilement de texte
speed = -4 ': Vitesse du défilement
RANDOMIZE ': On active la fonction pour la réinitialiser à chaque affichage
FOR ii = 1 TO 13 ': Boucle pour mémoriser les valeurs
xp[ii] = Int(Rnd * 20)
yp[ii] = Int(Rnd * 20)
x2[ii] = .width / 2 ': 50 positions x différentes
y2[ii] = .height / 2 ': 50 positions Y différentes
NEXT
sound1 = sound.Load("Worm.mp3")
sound2 = sound.Load("rire.mp3")
sound1.Play(-1) ': On lit en boucle. On peut bien sur prendre n’importe quelle musique, mais pour une démos oldskoll, c’est mieux d’utiliser un antique soundchips :-)
.show
END WITH
END
|
Fin des initialisations privées.
Passons à l’exécution du programme qui va se faire par l’option $hwindow.show
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| PUBLIC SUB Window_draw() ': Procédure déclenchée par l’événement .show
IF compteur = 1 THEN ': Variable utilisée pour le fondu pour l’apparition du ver
ifnd -= 2 ': Valeur du fondu diminue de 2 à chaque boucle
IF ifnd <= 1 THEN compteur = 3 ': Valeur de l’opaque. On met le compteur à 3 pour attendre le déclenchement du timer
ELSE
IF compteur = 2 THEN ': Variable utilisée pour le fondu pour la disparition du ver
ifnd += 2 ': Valeur du fondu augmente de 2 à chaque boucle
IF ifnd >= 255 THEN ': Valeur de la transparence.
Pozx = 1 ': On remet la position x à 1
INC nbeffect ': On incrémente la variable des effets
IF nbeffect > 9 THEN nbeffect = 1 ': On a neuf effets différents. Arrivé à neuf, on recommence avec l’effet numéro 1
compteur = 1 ': Idem avec le compteur qui est remis à 1 donc on va incrémenter le fondu pour aller vers l’opaque.
ENDIF
ENDIF
ENDIF
Draw.Clear() ': On efface l’écran
sco = 0 ': Valeurs pour la position du scrolle de texte
cco = 0
cco2 = 0
scroll = scroll + speed ': Vitesse du scroll
scroll2 = scroll2 + speed
m = m
sco = sco
IF copFond THEN ': Si copfond est à true alors on calcule les couleurs du bas de l’écran en mémoire
Cop() ': Procédure de copie
ELSE
Draw.Image(Fond, 0, 20, $hWindow.width, $hWindow.height,,, 180) ': Sinon on affiche l’image inversée. Cela évite de dessiner le bas d’écran à chaque affichage
ENDIF
IF a2 >= 1300 THEN ': Boucle utilisée pour la distorsion de logo de Gambas
increment = FALSE ': Variable utilisée pour augmenter ou diminuer la distorsion
ELSE
IF a2 <= -1300
increment = TRUE
ENDIF
ENDIF
Star() ': On appelle la procédure d’affichage des étoiles
scrolle() ': Puis celle d’affichage du texte Gambas en bas d’écran
scrolle2() ': Puis celle d’affichage du défilement du texte en haut d’écran
Worm(($hwindow.Width / 2.2), ($hwindow.Height / 2.6)) ': Puis l’affichage du ver en passant les valeurs de x et y comme paramètres.
END
|
Passons maintenant à la procédure suivante
1
2
3
4
5
6
7
8
9
10
11
12
13
| PUBLIC SUB Mytimer_timer() ': Cette procédure se déclenche toute les 22000 millisecondes, donc chaque animation du ver dure 22 secondes
IF compteur = 3 THEN
compteur = 2 ': Si le compteur est à 3 (en attente) On l’initialise à 2 c’est à dire qu’on va commencer le fondu vers la transparence. La variable compteur à donc trois positions.
'Compteur = 1 on débute le fondu de la transparence vers l’opaque
'Compteur = 2 on débute le fondu de l’opaque vers la transparence
'Compteur = 3 on ne fait rien dans l’attente du déclenchement du timer.
' Pour résumé, après 22 seconde, l’animation disparaît progressivement puis l’animation suivante apparaît progressivement etc... etc, pour tous les enchaînements.
'NB : En gambas la valeur de la transparence complète est égale à 255, celle de l’opaque est égale à 1
ENDIF
END
|
La procédure suivante cop() va dessiner les lignes de couleur en bas de l’écran
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| PUBLIC SUB cop()
DIM c AS INTEGER ': Variable pour la boucle
FOR c = 0 TO 220 ': Toutes les nuances de couleur sur 220 lignes
Draw.Background = Color.HSV(c, 255, 20) ': Chaque ligne prend la couleur du background
Draw.Line(0, c, $hWindow.width, c) ': Chaque ligne est dessinée d’un bord à l’autre de l’écran
NEXT ': Et ainsi de suite jusqu’à la fin de la boucle (220 lignes)
Fond = $hWindow.Screenshot() ': On copie tout l’écran dans la variable Fond
copFond = FALSE ': Une fois que cela est fait, on met la variable copfond à false de façon à ne plus faire cette action.
'NB : La variable Fond à été définie comme une image dans la déclaration des variables.
PRIVATE Fond AS Image
END
|
Il est temps maintenant de passer à l’affichage des étoiles
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| PROCEDURE Star()
DIM ii AS INTEGER ': Variable de boucle
RANDOMIZE
FOR ii = 1 TO 12 ': On va afficher 12 étoiles jaunes
Draw.Image(Star1, x2[ii], y2[ii], 8 + ii, 8 + ii) ': Les étoiles sont affichées l’une près l’autre Star1 = étoile jaune
x2[ii] = position x 'de l’étoile
y2[ii] = position y
8 + ii ' 8 + ii = taille de l’image. La variable ii permet de varier la taille.
'Si vous voulez avoir des étoiles plus grosses alors il faudra modifier la valeur de ii en la multipliant par 2 ou 3 ou plus.
'Exemple : 8 + ii * 2, 8+ii * 2
x2[ii] = x2[ii] + xp[ii] ': On augmente la position de x à chaque itération.
'Rappel : la variable xp à été initialisée dans la procédure main()
y2[ii] = y2[ii] + yp[ii] ': Même chose pour y
IF x2[ii] < 0 OR x2[ii] > $hWindow.width OR y2[ii] < -20 OR y2[ii] > $hWindow.height THEN ': Si la position de x est supérieure à la largeur de l’écran ou si y est supérieur à la hauteur de l’écran alors
x2[ii] = $hWindow.width / 2 ': On ramène la valeur à la moitié de l’écran (au milieu)
y2[ii] = $hWindow.height / 2 ': idem ci-dessus
ENDIF
NEXT
FOR ii = 1 TO 6 ': On fait la mème chose pour les étoiles bleues
Draw.Image(Star2, x2[ii], y2[ii], 8 + ii, 8 + ii)
x2[ii] = x2[ii] + xp[ii]
y2[ii] = y2[ii] + yp[ii]
IF x2[ii] < 0 OR x2[ii] > $hWindow.width OR y2[ii] < -20 OR y2[ii] > $hWindow.height THEN
x2[ii] = $hWindow.width / 2
y2[ii] = $hWindow.height / 2.2
ENDIF
NEXT
END
|
On regarde comment se passe l’affichage du mot GAMBAS en bas d’écran.
En premier, il faut charger chaque lettre dans une variable.
Comment procéder ?
D’abord, il faut comprendre comment est organisée l’image qui contient les caractères. Ici 192.png.
On mesure la taille des caractères. 32*32
On regarde comment chaque caractère est positionné dans l’image.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| PROCEDURE Charge_Fonte() ': La procédure qui charge les caractères
DIM x, y4, z AS INTEGER ': On a besoin de trois variables. X pour la position horizontale, Y pour la position de chaque ligne, Z pour la numérotation de chaque caractère dans le tableau lettre[]
$car = " ! ' ,-. 0123456789: ABCDEFGHIJKLMNOPQRSTUVWXYZ" ': Dans la variable $car, on recopie chaque caractère dans l’ordre d’apparition de l’image 192.png
Lettre = NEW Image[61] ': on instancie le tableau qui va contenir les caractères :
FOR y4 = 0 TO 5 ': on a 6 lignes
FOR x = 0 TO 9 ': chaque ligne contient 10 caractères
INC Z ': On incrémente de 1
Lettre[Z] = Lettres.Copy(X * 32, Y4 * 32, 32, 32) ': on copie chaque lettre de l’image dans le tableau..
'Par exemple si Z = 41 alors Lettre[Z] contiendra l’image de la lettre M qui est bien à la 41eme position dans la variable $car.
NEXT
NEXT
END
|
La deuxième phase consiste à l’attribution des images à chacune des lettres que l’on souhaite afficher
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| PROCEDURE Texte() ': on charge les caractères de gambas
DIM Lig1, $key AS STRING ': On défini deux variables texte
DIM x AS INTEGER ': plus une variable de type integer
Lig1 = "GAMBAS" ': la première variable contient le mot GAMBAS
Lig1 = Upper$(lig1) ': On met le contenu de Lig1 en majuscule.
Lig2 = lig1 ': On sauvegarde Lig1 dans Lig2
ScrollText = NEW Image[Len(lig1)] ': On instancie scrolltext de la longueur du texte
FOR x = 0 TO Len(Lig1)
$Key = Left$(Lig1, 1) ': On met le premier caractère de Lig1 dans la variable $key
$Key = InStr($car, $key) ': puis on regarde dans la variable $car où se trouve ce caractère.
'On utilise l’instruction InStr qui nous renvoie la position du caractère à l’intérieur de la variable.
'Dans notre exemple le premier caractère de Lig1 c’est le G de Gambas qui est situé en 40eme position dans la variable $car. Donc $key = 40
ScrollText[x] = Lettre[$key] ': ensuite on prend l’image qui est contenu dans le tableau Lettre[] à la position définie par $key et on la pose dans le tableau ScrollText[x].
'C’est ce tableau qui nous servira à faire notre scrolling
Lig1 = Mid$(Lig1, 2, Len(lig1)) ': On va passer au caractère suivant. Pour effectuer cela, on supprime le premier caractère de notre variable.
'On utilise l’instruction Mid$(Lig1, 2, Len(lig1)) c’est à dire que l’on sélectionne le contenu de la variable Lig1 à partir de la deuxième position.
'Donc Lig1 devient AMBAS
NEXT ': on recommence le travail avec le caractère suivant
END
|
Ce travail étant bien accompli, on s’attaque à l’affichage de nos caractères
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| PROCEDURE scrolle() ': Gambas et son reflet
DIM ic AS INTEGER = 1 ': on a besoin d’une seule variable
FOR ic = 0 TO Len(lig2)
Draw.Image(ScrollText[ic], $hwindow.Width / 2.5 + ic * 32, $hWindow.Height / 1.4 + 30 * Sin((cco + sco - m) / 80)) ': Le caractère ScrollText[ic] est affiché à l’écran.
'La position x est égale à la longueur de l’écran divisé par 2.5 + ic * 32 puisque l’image du caractère est de 32*32.
'La position y est égale à la hauteur de l’écran divisé par 1.4 + 30 * Sin((cco + sco - m) / 80)).
'On utilise la valeur de Sin((cco + sco - m) / 80)) pour faire sauter les lettres
Draw.Image(ScrollText[ic], $hwindow.Width / 2.5 + ic * 32, $hWindow.Height / 1.2 - 30 * Sin((cco + sco - m) / 80),,,, 180, 180) ' : On fait la même chose pour le reflet. ,,,, 180, 180 fixe pour la première valeur le niveau de transparence, et pour la seconde, la rotation de l’image (180°)
cco = cco + 90 ': On augmente la valeur de cco à chaque passage de la boucle.
NEXT
END
|
Voilà pour l’affichage du mot GAMBAS qui sautille en bas de l’écran.
Passons au défilement du texte en haut de l’écran
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| PROCEDURE Charge_Fonte2() ': la procédure est identique à celle expliquée plus haut (charge_fonte)
DIM x, y4, z AS INTEGER
$car2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.,-\" !?()':;1234567890"
'Notez que leur positionnement peut être très différent d’une image à l’autre.
Lettre2 = NEW Image[51]
FOR y4 = 0 TO 4
FOR x = 0 TO 9
INC Z
Lettre2[Z] = Lettres2.Copy(X * 32, Y4 * 38, 32, 38)
NEXT
NEXT
END
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| PROCEDURE Texte2() ': on charge les caractères du texte du scrolling.
'Mêmes explications que celles données plus haut (charge_texte).
'Il n’y a que la longueur du texte qui change.
DIM Lig1, $key AS STRING
DIM x AS INTEGER
Lig1 = " Hi ! this is my new oldskool demo like with five effects. Stars, worm, scrolltext, a text with dancing letters over a rainbow and the Gambas's logo with distorsion... "
Lig1 = Upper$(lig1)
Lig22 = lig1
ScrollText2 = NEW Image[Len(lig1) + 10]
FOR x = 0 TO Len(Lig1) -1
$Key = Left$(Lig1, 1)
$Key = InStr($car2, $key)
ScrollText2[x] = Lettre2[$key]
Lig1 = Mid$(Lig1, 2, Len(lig1))
NEXT
END
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| PROCEDURE scrolle2() 'scrolling ': défilement du texte en haut de l’écran
DIM ic AS INTEGER = 1
IF scroll2 < -(Len(lig22) * 32) THEN ': Si la valeur de scroll2 dépasse celle de la longueur du texte * 32 (la largeur de chaque caractère)
scroll2 = $hWindow.width ' : alors on remet scroll2 à la largeur de l’écran
ENDIF
FOR ic = 1 TO Len(lig22) ' : on affiche le défilement du texte
Draw.Image(ScrollText2[ic], scroll2 + ic * 32, $hWindow.Height / 8, 76, 76) ': Chaque caractère s’affiche à la position X = scroll2 + ic *32 et Y = $hwindow/8, les caractères sont affichés en 76*76 pixels
NEXT
END
|
Et voilà, on sait faire sauter et défiler des lettres.
Notre démo est presque finie.
Il nous reste à voir l’animation du ver et la distorsion du logo de Gambas en bas d’écran.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
| PUBLIC SUB Worm(xc AS INTEGER, yc AS INTEGER)
DIM a, b, x4, xx, y4, y3, z2, r AS FLOAT = 0
pozx = pozx + 1 ': On augmente de 1 la position X
pozy = pozy + 2 ': On augmente de 2 la position Y
a = pozx / 200
FOR b = 1 TO 15 ' : on commence la boucle d’affichage. Il y a quatorze boule pour le corps et une boule pour la tête.
y4 = b
x4 = Cos(a) - y4 * Sin(a) ': x4 pour calculer la position horizontale
y3 = Sin(a) + y4 * Cos(a) ': y3 pour le calcul de la position verticale
y4 = y3
y3 = Cos(y4) * Sin(1) ': Une autre variable pour la position horizontale
z2 = Sin(y4) * Cos(1) ': Idem pour la position verticale
SELECT CASE Nbeffect ': On sélectionne le numéro de l’effet à afficher.
'Rappel : le numéro de l’effet change avec la variable compteur = 2
CASE 1
sx = Int(z2 * (x4 + hball) * 8 ) ' 'position x : Position x pour chaque effet
sy = Int(x4 * (z2 + hball) * 10) ''position y : Position y pour chaque effet
CASE 2
sx = Int(Cos(x4) * (y3 + hball) * 30)
sy = Int(Cos(z2) * (y3 + hball) * 70)
CASE 3
sx = Int(z2 * (x4 + hball) * 20)
sy = Int(Cos(x4) * (z2 + hball) * 20)
CASE 4
sx = Int(a * (x4) * 6)
sy = Int(z2 + Cos(x4) * 18)
CASE 5
sx = Int(y3 * (x4 + hball) * 12)
sy = Int(y3 * (z2 + hball) * 40)
CASE 6
sx = Int(x4 * (y3 + hball) * 10 * Cos(1))
sy = Int(z2 * (y3 + hball) * 60 * Cos(1))
CASE 7
sx = Int(x4 * (y3 + hball) * 18)
sy = Int(z2 * (y3 + hball) * 60)
CASE 8
sx = Int(Cos(z2) * (x4 + hball) * 20)
sy = Int(Cos(x4) * (y3 + hball) * 10)
sound1.Volume = 20
sound2.volume = 128
sound2.Play(1)
CASE 9
sound1.Volume = 100
x4 = Cos(a * 8 ) + y4 * Sin(a)
z2 = Sin(y4) * y4 / 8
sx = Int(z2 * (hball * 4) * 8 ) ''position x
sy = Int(x4 * (hball * 2) * 10) ''position y
END SELECT
IF b = 15 THEN
Draw.Image(tete, xc + sx, yc + sy, 62, 62,, ifnd) ' : On affiche la tête si b = 15
FOR xx = 0 TO gambas.Height - 1 STEP 2 ': distorsion du logo de gambas.
'On ne prend qu’une ligne sur 2, c’est suffisant
Draw.Image(img3[xx], ($hwindow.Width / 6 - gambas.Width / 2) + Cos(ag) * 30, ($hwindow.Height / 1.2 - gambas.Height / 3.5) + xx) ': Le logo de gauche
Draw.Image(img3[xx], ($hwindow.Width / 1.2 - gambas.Width / 2) + Cos(ag) * 30, ($hwindow.Height / 1.2 - gambas.Height / 3.5) + xx,,,,, 180) ': Le logo de droite. La valeur 180 permet d’inverser l’image
IF increment THEN
ag = ag + 0.1
ELSE
ag = ag - 0.1
ENDIF
NEXT
ELSE
Draw.Image(balle2, xc + sx, yc + sy, 62, 62,, ifnd) ': Si b <> 15 on affiche le corp.
ENDIF
NEXT
END
|
====================
Navigation :
<-- Liens du Wiki : <--<-- Accueil du WIKI : <-- <--Création de Projets <--====================
La Documentation :
====================