Tuto tir sous hollywood

• 

  Anonyme

  18 mars 2013 à 23h23 #180983

  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