Tuto tir sous hollywood
Affichage de 1 message (sur 1 au total)
-
Hello,
Je sais qu’une paire en a rien a faire et que l’on va encore pointer le voca et l’otho, mais pour ceux que sa intéresse, voici le code hollywood (facilement retranscriptible sous Amos et Basic SDL) :
/*
************************************************************
**
** Created by: CodeBench 0.23 (17.09.2011)
**
** Project: Routine de Tir Sous Hollywood
**
** File: Tir.hws
**
** Date: 12-02-2012 12:29:40
**
************************************************************
*/
; C’est important de bien préparer un script
; Voici donc l’une des façon de bien identifié son programme
@VERSION 5,0 ; Version d’hollywood minimum à avoir
@APPTITLE « Shoot Test » ; Titre du programme
@APPAUTHOR « ArtBlink » ; Auteur du programme… Moi 😉
@APPVERSION « $VER : 0.1 » ; Numéro de version, pour craner j’en ai mis une 😛
@APPDESCRIPTION « Routine qui peut être utilisé dans vos propres jeux » ; tout est dit
; Attention, le code à proprement parler commence
; On créer un écran, sur la fenêtre sera écrit se que l’on indique dans Title = « Bla Bla »
; Width = Largeur de la fenêtre et Height = La hauteur de la fenêtre
; On peut ouvrir un écran UNIQUE en full screen ou plusieurs fenêtre, tout dépend
; de se que l’on recherche
@DISPLAY {Title = « Shoot Test – ArtBlink – Utilisé cette routine pour vos futures Jeux 😉 », Width = 640, Height = 480}
; Je créé mes propres sprites, ou plutôt des Brush (Brosses comme sous DPaint)
; Je préfère les Brosses qui permettent plus de liberté, un meilleur moteur
; de rendu et une plus grande vitesse d’affichage surtout depuis l’insertion
; dans Hollywood d’un Moteur DoubleBuffer en Hardware…
; SetFillStyle défini le type de remplissage de mes formes vectorielles
; que je vais tracer dans les Brosses (Brush)
SetFillStyle(#FILLCOLOR) ; #FILLCOLOR = Remplissage par une couleur (Unie, pas d’effet)
; Ici, je créé la Brosse 1 qui est le triangle Bleu = le vaisseau
CreateBrush(1,32,32,$000000,{HardWare=True})
; Createbrush créé une forme rectangulaire ou un carré
; Ici je créé un carré de 32×32 pixel de couleur noir et je le sauvegarde
; directement dans la mémoire GFX (plus rapide)
; Pour sauvegarder ma Brosse, j’utilise l’item {Hardware=True}
; Pour les couleurs, c’est du RVB, un code hexadécimale, le $ est important
SelectBrush(1)
; SelectBrush me permet d’ouvrir ma brosse pour y faire n’importe quelle modification
; N’oublier pas que pour l’instant, j’ai une brosse qui est de la forme :
; Carré Noir de 32×32 pixels, plutôt sommaire le vaisseau 😉
; Donc j’ouvre ma brosse pour y ajouter un triangle Bleu
Polygon(0,0,{0,32,16,0,32,32},3,$0000ff)
; Ah! une commande de traçage, polygon est une commande qui permet de tracer
; autant de droite que l’on veut
; ATTENTION : Polygon reliera toujours la première coordonnée à la dernière par un trait
EndSelect
; Je referme ma Brosse 1 pour ne plus y faire de modification
;
; Ici, la Brosse 2 qui est le triangle vert = Missile
CreateBrush(2,16,16,$000000,{HardWare=True})
SelectBrush(2)
Polygon(0,0,{0,16,8,0,16,16},3,$00FF00)
EndSelect
; C’est la même chose qu’avec la création de la Brosse Vaisseau
; Evidemment, on peut remplacer facilement mes Brosses… euh… pas belles
; Par de belle Images Bmp,Iff,etc… avec la commande LoadBrush tout en gardant en tête
; de rajouter l’item {Hardware=True}, sinon pas d’accélération 2D
;
; Je dois finaliser mes 2 brosses, et pour cela, je dois enlever le fond de la brosse,
; C’est à dire la couleur Noir, seul le triangle Bleu dois être visible, important si vous
; Mettez une image de fond 😉
;
; Une boucle de 2 car j’ai 2 Brosses
For I=1 To 2
; Je configure la couleur Noir comme une couleur Transparente donc invisible 😉
SetBrushTransparency(I,$000000)
Next
;———————
;- variable globale –
;———————
;
; Ces variables sont quasi inutile, mais efficace pour comprendre le script
; on peut facilement transformer ces variables globales en locale et ainsi
; faire gagner ENORMEMENT de temps au script et donc accélérer le rendu
; grâce a cette otpimisation, on pourrait rajouter bien plus d’ennemis ou d’effets
; à l’écran
;
; Largeur d’écran du jeux (Peut être plus petit que la Taille de l’écran ou fenêtre
; Principale, ici, j’ai prix la taille de la résolution
LargeurDEcran=640
HauteurDEcran=480
;
; === Variable pour le vaisseau ===
;
; Position de départ en X du Triangle Bleu = Vaisseau
XTriangleBleu=320
; Position de départ en Y du Triangle Bleu = Vaisseau
YTriangleBleu=420
; Vitesse de déplacement du Triangle Bleu = Vaisseau (4 pixels par 4 pixels)
VitesseDuTriangleBleu=4
;
; === Variable pour les Missiles ===
;
; Nombre maximum de missile visible à l’écran
NombreDeTirMaxiSurLEcran=4
; Hauteur maximum du missile = après c’est effacement de la Brosses missiles
; On créé une frontière car si on ne touche pas d’ennemis, celui ci ne sera jamais
; initialisé et il n’arrêtera pas de monter jusqu’a -l’infinie
; Ici je définie 100 pixels à partir du haut de l’écran
HauteurMaxiDuTir=100
; Vitesse de déplacement des missiles (2 pixels par 2 pixels)
VitesseDuTir=2
; J’initialise le numéro de missile
NumeroDeMissile=0
; Et ici le temps entre chaque tir, sinon, si on reste appuyé sur la barre espace,
; les missiles partiraient quasi tous en même temps
TempDeRechargement=25
;
; === Tables pour les Missiles ===
;
; On initialise 3 tables, pourquoi je n’ai pas fait une table avec 3 types de données?
; Eh! Oh! c’est qui qui code?
; Oui, j’aurai pu, mais j’ai pas voulu, car le code aurait était pas très facile à
; comprendre, rien ne vous empêche de faire une seule table à 3 dimensions, mais attention
; 3 tables, en accès, c’est plus rapide qu’une table à 3 dimensions… et oui, et l’optimisation
; Alors? un?
;
; Table 1 : Pour le numéro des Missiles
NumeroDuMissile={}
; J’initialise car une table initialisée est une table plus rapide 😉
For NombreDeTirSurLEcran=0 To NombreDeTirMaxiSurLEcran-1 Do NumeroDuMissile[NombreDeTirSurLEcran]=0
; Table 2 : Pour la coordonnée en X des missiles
MissileEnX={}
; J’initialise car une table initialisée est une table plus rapide 😉
For NombreDeTirSurLEcran=0 To NombreDeTirMaxiSurLEcran-1 Do MissileEnX[NombreDeTirSurLEcran]=0
; Table 3 : Pour la coordonnée en Y des missiles
MissileEnY={}
; J’initialise car une table initialisée est une table plus rapide 😉
For NombreDeTirSurLEcran=0 To NombreDeTirMaxiSurLEcran-1 Do MissileEnY[NombreDeTirSurLEcran]=YTriangleBleu
; Pourquoi j’utilise NombreDeTirMaxiSurLEcran-1 pour faire la boucle?
; Si je dit que je veux 4 missiles, tous le monde compte comme sa:
; 1,2,3 et 4
; Or, les tables commencent à 0 donc les tables se présentent comme cela :
; 0,1,2 et 3 => donc c’est 4-1=3 pour avoir 4 missiles
; Voici un petit schéma de mes tables
;
; Table 1 Table 2 Table 3
; NumeroDuMissile MissileEnX MissileEnY
; Ligne [0] 0 0 0
; Ligne [1] 0 0 0
; Ligne [2] 0 0 0
; Ligne [3] 0 0 0
;
; J’espère que se schéma vous fais comprendre un peu mieux le système que je met en place
;
; – Fonction principale que je Boucle à l’infinie –
;
Function Tir()
; Impératif et de suite 😉
; Je flip l’écran
Flip(True)
; et je l’efface
Cls
; ————————————————————————
; Hors Tuto
Box (0,YtriangleBleu+32,LargeurDEcran,HauteurDEcran-YTriangleBleu,$226622)
Box (0,0,LargeurDEcran,YtriangleBleu+32,$000044)
TextOut (0,0, »Appuyez sur Flèche gauche pour aller à gauche »)
TextOut (0,10, »Appuyez sur Flèche Droite pour aller à Droite »)
TextOut (0,20, »Appuyez sur Barre espace pour Tirer »)
TextOut (0,30, »Appuyez sur Ctrl+C pour QUITTER »)
; Fin Hors Tuto
; ————————————————————————
; Maitenant sa commence :
;
; Et hop, je met en route mon compteur qui défini l’intervalle entre chaque tir
TempDeRechargement=TempDeRechargement-1
; Evidement, si celui-ci descend en dessous de 0, je le bloque à 0 sinon, ma routine
; ne se validerait jamais du fait que je test si TempDeRechargement=0 alors je valide
; un tir, voir la commande suivante
If TempDeRechargement<0 Then TempDeRechargement=0
; Ici, c’est assez simple à comprendre, je test les touches du clavier :
Local Tir=IsKeyDown(« SPACE »)
Local Droite=IsKeyDown(« RIGHT »)
Local Gauche=IsKeyDown(« LEFT »)
If Droite=True Then XTriangleBleu=XTriangleBleu+VitesseDuTriangleBleu
; Je bloque le Triangle Bleu (Vaisseau) au bord droit de l’écran si je suis au bout de celui-ci
If XTriangleBleu>LargeurDEcran Then XTriangleBleu=LargeurDEcran
If Gauche=True Then XTriangleBleu=XTriangleBleu-VitesseDuTriangleBleu
; Je bloque le Triangle Bleu (Vaisseau) au bord gauche de l’écran si je suis au bout de celui-ci
If XTriangleBleu<0 Then XTriangleBleu=0
;
; – Test du tir –
;
If TempDeRechargement=0
If Tir=True ; Si j’appuie sur espace
; Je fais une boucle pour tester la table MissileEnY
For Local ValiderUnTir=0 To NombreDeTirMaxiSurLEcran-1
; Si dans la ligne de la table numéro ValiderUnTir = YTriangleBleu, sa veux dire
; que le missile ne bouge pas, c’est qu’il est donc activable pour un tir
If MissileEnY[ValiderUnTir]= YTriangleBleu
NumeroDuMissile[ValiderUnTir]=1
; J’utilise la table MissileEnX pour garder la position en X du vaisseau, la
; ou le missile dois partir, SI je n’utilisai pas cette table, les missiles
; suiverai mon vaisseau, se qui serait ridicule.
MissileEnX[ValiderUnTir]=XTriangleBleu
; Dès que je trouve un Missile activable, je casse la boucle
Break
EndIf
Next
EndIf
; Comme j’ai valider le tir, je remet le compteur à 25
TempDeRechargement=25
EndIf
;
; Ah! Enfin, l’affichage des missiles
;
; Je boucle pour visualiser dans ma table NumeroDuMissile, lesquels sont activés
;
For Local Tir=0 To NombreDeTirMaxiSurLEcran-1
; SI dans la table NumeroDuMissile la ligne Tir = 1, cela veut dire que le missile Tir est
; lancé
If NumeroDuMissile[Tir]=1
; Comme ils sont lancés, il faut décompter pour que ceux-ci montent jusqu’en haut de l’écran
MissileEnY[Tir]=MissileEnY[Tir]-VitesseDuTir
; Si les missiles atteignent la limite de la hauteur alors ceux-ci sont initialisés
If MissileEnY[Tir]<HauteurMaxiDuTir
NumeroDuMissile[Tir]=0 ; hop, le missile numéro Tir est désactivé
MissileEnY[Tir]= YTriangleBleu ; Hop, on initialise le point de départ de ce même missile
EndIf
; Remarque : Lors d’une collision avec un ennemies ou un mur ou peux importe, la méthode est la même
; qu’au dessus.
; Pour éviter de petits bugs graphiques, on affiche le missile que si sa coordonnées en Y est strictement
; INFERIEUR à la coordonnée en Y du triangle bleu
If MissileEnY[Tir]< YTriangleBleu Then DisplayBrush (2,MissileEnX[Tir],MissileEnY[Tir],{AnchorX=0.5,AnchorY=1})
EndIf
Next
; On affiche le Vaisseau (Triangle Bleu)
DisplayBrush (1,XTriangleBleu,YTriangleBleu ,{AnchorX=0.5,AnchorY=0}); Hyper important, on contrôle le vaisseau depuit son centre
EndFunction
; On lance le moteur de rendue DoubleBuffer en Hardware
BeginDoubleBuffer(True)
; Un interval de temps entre chaque image bloqué a 50 FPS maxi
SetInterval(1, Tir, 20)
; Et la boucle infinie classique de Hollywood, sinon le programme s’arrête après la première image
Repeat
WaitEvent
Forever
Voilà, maintenant, vous pouvez, grâce a mon ancien tuto sur le Scroll multidirectionnel, créer un ti jeu
Affichage de 1 message (sur 1 au total)
- Vous devez être connecté pour répondre à ce sujet.
› Forums › AmigaOS, MorphOS et AROS › Développement › Tuto tir sous hollywood
