projet: wargame en 16 couleurs (étape n°1)

Vous débutez et vous avez besoin d'aide ? N'hésitez pas à poser vos questions
Avatar de l’utilisateur
Huitbit
Messages : 940
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

projet: wargame en 16 couleurs (étape n°1)

Message par Huitbit »

Une saisie d'écran pour commencer(merci Comtois!)
Image

puis les sprites:

Image

Image

Image

Image

Image

Code : Tout sélectionner

;****************déclaration des variables*****************
Enumeration
  #case_bordure
  #case_mer
  #case_terre
  #case_visite
  
  #spr_bordure
  #spr_terre
  #spr_rustine
  #spr_rivage
  #spr_curseur
  
EndEnumeration
x_carte.b=0       ; position x sur la carte
y_carte.b=0       ; position y sur la carte
x_souris.b=0      ; position x de la souris
y_souris.b=0      ; position y de la souris
       
tirage.s=""       ; variable utilsée dans la conversion déc-bin
inc_tirage.b=0    ; curseur pour selectionner un caractère dans tirage
inc_ile.l=0       ; compteur utilisé pour identifier les îles
numero_ile.l=0    ; identifiant d'île, utilisé pour calculer la surface
surface_ile.l=0   ;surface de l'île

Global inc_ile.l ;pour continuer à indexer les case carte() dans les procedures
;*****************tableaux************************
Dim carte.b(63,47,1); tableau 64*48*2         0: carte     1: numéros des îles
Dim x_detection.b(63,47) ;mémorisation des coordonnées 
Dim y_detection.b(63,47) ;initiales de la case testée
;****************declaration de la procedure detection1**************
Declare.b detection1(x,y,choix)
;****************procedure detection0********************************
Procedure.b detection0(x,y,choix)
  x_detection(x,y)=x
  y_detection(x,y)=y 
  carte(x_detection(x,y),y_detection(x,y),0)=#case_visite
  
  If choix=#case_terre
     carte(x_detection(x,y),y_detection(x,y),1)=inc_ile
  EndIf
  If choix=#case_mer Or choix=#case_terre  
  ;****haut****  
  If carte(x_detection(x,y),y_detection(x,y)-1,0)=choix
    detection1(x_detection(x,y),y_detection(x,y)-1,choix)
  EndIf
  ;****droite****
  If carte(x_detection(x,y)+1,y_detection(x,y),0)=choix
    detection1(x_detection(x,y)+1,y_detection(x,y),choix)
  EndIf
  ;****bas****
  If carte(x_detection(x,y),y_detection(x,y)+1,0)=choix
    detection1(x_detection(x,y),y_detection(x,y)+1,choix)
  EndIf
  ;****gauche****
  If carte(x_detection(x,y)-1,y_detection(x,y),0)=choix
    detection1(x_detection(x,y)-1,y_detection(x,y),choix)
  EndIf 
EndIf

If choix=#case_terre  
  ;****haut droite****  
  If carte(x_detection(x,y)+1,y_detection(x,y)-1,0)=choix
    detection1(x_detection(x,y)+1,y_detection(x,y)-1,choix)
  EndIf
  ;**** bas droite****
  If carte(x_detection(x,y)+1,y_detection(x,y)+1,0)=choix
    detection1(x_detection(x,y)+1,y_detection(x,y)+1,choix)
  EndIf
  ;****bas gauche****
  If carte(x_detection(x,y)-1,y_detection(x,y)+1,0)=choix
    detection1(x_detection(x,y)-1,y_detection(x,y)+1,choix)
  EndIf
  ;**** haut gauche****
  If carte(x_detection(x,y)-1,y_detection(x,y)-1,0)=choix
    detection1(x_detection(x,y)-1,y_detection(x,y)-1,choix)
  EndIf 
EndIf

EndProcedure

;****************procedure detection1********************************
Procedure.b detection1(x,y,choix)
  x_detection(x,y)=x
  y_detection(x,y)=y 
  carte(x_detection(x,y),y_detection(x,y),0)=#case_visite
  
  If choix=#case_terre
     carte(x_detection(x,y),y_detection(x,y),1)=inc_ile
  EndIf
  If choix=#case_mer Or choix=#case_terre  
    ;****haut****  
    If carte(x_detection(x,y),y_detection(x,y)-1,0)=choix
      detection0(x_detection(x,y),y_detection(x,y)-1,choix)
    EndIf
    ;****droite****
    If carte(x_detection(x,y)+1,y_detection(x,y),0)=choix
      detection0(x_detection(x,y)+1,y_detection(x,y),choix)
    EndIf
    ;****bas****
    If carte(x_detection(x,y),y_detection(x,y)+1,0)=choix
      detection0(x_detection(x,y),y_detection(x,y)+1,choix)
    EndIf
    ;****gauche****
    If carte(x_detection(x,y)-1,y_detection(x,y),0)=choix
      detection0(x_detection(x,y)-1,y_detection(x,y),choix)
    EndIf
   EndIf
  
  If choix=#case_terre  
    ;****haut droite****  
    If carte(x_detection(x,y)+1,y_detection(x,y)-1,0)=choix
      detection0(x_detection(x,y)+1,y_detection(x,y)-1,choix)
    EndIf
    ;**** bas droite****
    If carte(x_detection(x,y)+1,y_detection(x,y)+1,0)=choix
      detection0(x_detection(x,y)+1,y_detection(x,y)+1,choix)
    EndIf
    ;****bas gauche****
    If carte(x_detection(x,y)-1,y_detection(x,y)+1,0)=choix
      detection0(x_detection(x,y)-1,y_detection(x,y)+1,choix)
    EndIf
    ;**** haut gauche****
    If carte(x_detection(x,y)-1,y_detection(x,y)-1,0)=choix
      detection0(x_detection(x,y)-1,y_detection(x,y)-1,choix)
    EndIf 
  EndIf
  
EndProcedure

;******** choix des  grandes cases terre/mer parmi les 8*6 cases ***********
For y_carte=0 To 47 Step 8
  ; tirage = nombre binaire aléatoire complété  à  8 chiffres par LSet
  tirage=LSet(Bin(Random(255))  ,8,"0") 
  inc_tirage=0
  ; attribution des valeurs aux cases situées en haut à gauche des grandes cases
  For x_carte =0 To 63 Step 8
    inc_tirage=inc_tirage+1
    carte(x_carte,y_carte,0)=Val(Mid(tirage  ,inc_tirage,1))
  Next x_carte
Next y_carte

; remplissage du tableau en fonction des index des grandes cases
For y_carte=0 To 47 Step 8
  For x_carte=0 To 63 Step 8
    
    If carte(x_carte,y_carte,0)=1;en fonction de la valeur de l'index des cases, on remplie
       For j=0 To 7
        tirage=LSet(Bin(Random(255))  ,8,"0")
        inc_tirage=0
        For i=0 To 7
          inc_tirage=inc_tirage+1
          If Val(Mid(tirage  ,inc_tirage,1))=1
            carte(x_carte+i,y_carte+j,0)=#case_terre 
          Else
            carte(x_carte+i,y_carte+j,0)=#case_mer
            EndIf
        Next i
      Next j
    Else 
      For j=0 To 7
        For i=0 To 7
          carte(x_carte+i,y_carte+j,0)=#case_mer
        Next i
      Next j 
    EndIf 
    
    Next x_carte
  Next y_carte
  ;************création des bordures*************
  For y_carte=0 To 47
    For x_carte=0 To 63
      If x_carte=0 Or x_carte=63 Or y_carte=0 Or y_carte=47
        carte(x_carte,y_carte,0)=#case_bordure
      EndIf
    Next x_carte
  Next y_carte

;************légères modifications de la matrice(éviter les alignements trop importants***

For y_carte=1 To 44
  For x_carte=1 To 60
  ;**********éviter les alignements verticaux**********  
    If carte(x_carte,y_carte,0)+carte(x_carte,y_carte+1,0)+carte(x_carte,y_carte+2,0)=3*#case_terre And carte(x_carte+1,y_carte,0)+carte(x_carte+1,y_carte+1,0)+carte(x_carte+1,y_carte+2,0)=3*#case_mer 
     carte(x_carte+1,y_carte+Random(2),0)=#case_terre 
  EndIf
  
  If carte(x_carte,y_carte,0)+carte(x_carte,y_carte+1,0)+carte(x_carte,y_carte+2,0)=3*#case_mer And carte(x_carte+1,y_carte,0)+carte(x_carte+1,y_carte+1,0)+carte(x_carte+1,y_carte+2,0)=3*#case_terre
    carte(x_carte,y_carte+Random(2),0)=#case_terre 
  EndIf
 ;**********éviter les alignements horizontaux*********
    If carte(x_carte,y_carte,0)+carte(x_carte+1,y_carte,0)+carte(x_carte+2,y_carte,0)=3*#case_terre And carte(x_carte,y_carte+1,0)+carte(x_carte+1,y_carte+1,0)+carte(x_carte+2,y_carte+1,0)=3*#case_mer
       carte(x_carte+Random(2),y_carte+1,0)=#case_terre
    EndIf
    
    If carte(x_carte,y_carte,0)+carte(x_carte+1,y_carte,0)+carte(x_carte+2,y_carte,0)=3*#case_mer And carte(x_carte,y_carte+1,0)+carte(x_carte+1,y_carte+1,0)+carte(x_carte+2,y_carte+1,0)=3*#case_terre
      carte(x_carte+Random(2),y_carte,0)=#case_terre
    EndIf
    
  Next x_carte
Next y_carte

;**********bouchage des trous******************
y_carte=1
For x_carte=1 To 62
  If carte(x_carte,y_carte,0)=#case_mer
    detection0(x_carte,y_carte,#case_mer)
  EndIf
Next x_carte

y_carte=46
For x_carte=1 To 62
  If carte(x_carte,y_carte,0)=#case_mer
    detection0(x_carte,y_carte,#case_mer)
  EndIf
Next x_carte

x_carte=1 
For y_carte=1 To 46
  If carte(x_carte,y_carte,0)=#case_mer
    detection0(x_carte,y_carte,#case_mer)
  EndIf
Next y_carte

x_carte=62
For y_carte=1 To 46
  If carte(x_carte,y_carte,0)=#case_mer
    detection0(x_carte,y_carte,#case_mer)
  EndIf
Next y_carte

For y_carte=1 To 46       ;on remplace les cases visitées par des cases mer
  For x_carte=1 To 62     ;et les cases non visitées par des cases terres
    If carte(x_carte,y_carte,0)=#case_mer
      carte(x_carte,y_carte,0)=#case_terre
    Else
      If carte(x_carte,y_carte,0)=#case_visite
        carte(x_carte,y_carte,0)=#case_mer
        EndIf

      EndIf
    Next x_carte
  Next y_carte
  
  ;**********identification des îles******************
  For y_carte=1 To 46
    For x_carte=1 To 62
      If carte(x_carte,y_carte,0)=#case_terre
        inc_ile=inc_ile+1
        carte(x_carte,y_carte,1)=inc_ile
        detection0(x_carte,y_carte,#case_terre)
      EndIf
    Next x_carte
  Next y_carte
  
  For y_carte=1 To 46
    For x_carte=1 To 62
      If carte(x_carte,y_carte,0)=#case_visite
        carte(x_carte,y_carte,0)=#case_terre 
        EndIf
    Next x_carte
  Next y_carte
  

;*****************initialisation************************** 
InitMouse()
InitSprite() 
InitSprite3D() 
;*****************écrans********************************* 
OpenScreen(1024,768,32,"micro_wargame") ;ouverture d'un écran de profondeur 32 
UsePNGImageDecoder()
LoadFont(1,"arial",9,#PB_Font_Bold)
TransparentSpriteColor(-1,255,255,255);couleur de transparence : blanc(par défaut) 
;***********************sprites********************
LoadSprite(#spr_bordure,"bordure.png")
LoadSprite(#spr_rivage,"octogone_rivage.png")
LoadSprite(#spr_terre,"octogone_terre.png")
LoadSprite(#spr_rustine,"rustine.png")
LoadSprite(#spr_curseur,"curseur.png")


Repeat ; boucle principale 
  Delay(20) 
  ClearScreen(22,49,235); fond d'écran bleu
   
  For y_carte=0 To 47 ;affichage des bordures(sprite 24*24)
    For x_carte=0 To 63
      If  carte(x_carte,y_carte,0)=#case_terre
        DisplayTransparentSprite(#spr_rivage,x_carte*16-4,y_carte*16-4) 
      EndIf
       Next x_carte
    Next y_carte
    
    For y_carte=0 To 47;affichage de la terre(sprite 16*16)
    For x_carte=0 To 63
      If carte(x_carte,y_carte,0)=#case_terre 
       DisplayTransparentSprite(#spr_terre,x_carte*16,y_carte*16) 
    EndIf
    
    If carte(x_carte,y_carte,0)=#case_bordure; affichage de la bordure(sprite 16*16)
      DisplaySprite(#spr_bordure,x_carte*16,y_carte*16)
      EndIf
    Next x_carte
  Next y_carte
  
  For y_carte=1 To 45; bouchage des trous avec rustine(sprite 8*8)
    For x_carte=1 To 62
      If carte(x_carte,y_carte,0)+carte(x_carte+1,y_carte,0)+carte(x_carte+1,y_carte+1,0)+carte(x_carte,y_carte+1,0)=4*#case_terre 
        DisplayTransparentSprite(#spr_rustine,x_carte*16+12,y_carte*16+12)
      EndIf
       
    Next x_carte
  Next y_carte
  ;************évenements souris*************************
   ExamineMouse()
  
  x_souris=Int(MouseX()/16);correspondance entre pixels et cases du tableau
  y_souris=Int(MouseY()/16)
   
  StartDrawing(ScreenOutput())
  DrawingFont(FontID ())
  DrawingMode(4)
  FrontColor(255,255,0)
  BackColor(255,0,0)
  Locate(324,0)
  DrawText(" [Click droit] pour fermer | [Click gauche] pour connaître la surface de l'île ")
  FrontColor(255,255,255)
  
  
  Locate(MouseX()+24,MouseY())
  If carte(x_souris,y_souris,1)<>0
    DrawText("Île n° " + Str(carte(x_souris,y_souris,1))+" (sur "+Str(inc_ile)+" îles).")
  EndIf 
  
  If MouseButton(1)<>0
    surface_ile=0                        ; calcul de la surface des îles
     numero_ile=carte(x_souris,y_souris,1)
         
        For y_carte=1 To 46
          For x_carte=1 To 62
            If  carte(x_carte,y_carte,1)=numero_ile
              surface_ile=surface_ile+1
        EndIf
            Next x_carte
          Next y_carte
          Locate(MouseX()+24,MouseY()+24)
          DrawText("Surface = "+Str(surface_ile)+" km²")
        EndIf
 StopDrawing() 

DisplayTransparentSprite(#spr_curseur, MouseX()-10,MouseY()-10); sprite de la souris(30*31)
;****************************************************************** 
  
 FlipBuffers () 
 
Until MouseButton(2)<>0; on ferme si click du droit
CloseScreen()
End
Mon objectif : un mini-wargame en 16 couleurs (msx' style!):
une carte se créée(étape n°1)
on construit sa forteresse
on place son armée et ses armes
on massacre son voisin!!!
Et tout ça avec un minimum de gestion des ressources(récolter des potirons pendant 2h pour construire une étable ça m'énerve :mad: )

J'avais commencé qquechose sur les archipels il y a quelques temps, j'ai tout repris à zéro proprement:
maintenant il n'y a que trois matrices
j'utilise le convertisseur DEC-BIN de Pure Basic
on peut identifier une île et connaître sa surface(ça veut dire que je peux envoyer les soldats sur une île, diviser la carte en plusieurs pays....)

Pour remplir une carte aléatoirement, je procède en deux étapes:
je découpe la carte en grandes zones puis je les découpe en petites zones(tout ça avec des chaînes de caractères et les nombres binaires)
Ensuite je corrige les anomalies(trous, alignements trop importants...)
Et pour finir j'identifie toutes les zones créées


Questions

mon ordinateur refuse de passer en mode 16 couleurs :mad:

j'aurais pû travailler avec une seule matrice, mais ai-je le droit d'écrire:
carte(carte(x,y,0),carte(x,y,0),1) c'est à dire travailler avec deux couches différentes de la matrice?
Est-ce que travailler avec des sprites en 16 couleurs économise les capacités de l'ordi(comme ça, il peut tout mettre sur l'IA)?
Est-ce que le nombre de dimensions des matrices ralenti l'ordi(si c'est le cas, après la création de la carte, je peux tout envoyer dans une autre matrice)?

comment se superposent les sprites?
Exemple, dans les jeu en pseudo 3D, les perso peuvent passer devant ou derrière un obstacle.

où peut-on trouver des sprites de soldats, catapultes, .... vus d'en haut(c'est très rare!!!)
exemple( sprite 256 couleurs d'un jeu MSX2, retouché avec paint)
Image
Comme ça ce n'est pas très parlant, animez-le vous verrez!

Merci d'avance!
.. et merci tout court! Sans le forum j'aurai jamais réussi à commencer!

Voilà, ça fait beaucoup de questions(j'en ai plein d'autres :D)
Dernière modification par Huitbit le lun. 30/janv./2006 14:04, modifié 2 fois.
Elevé au MSX !
comtois
Messages : 5186
Inscription : mer. 21/janv./2004 17:48
Contact :

Message par comtois »

pour la copie d'écran , tu peux ajouter une touche et utiliser grabsprite() et saveSprite()

Code : Tout sélectionner

 FlipBuffers ()
  ;************ Le clavier ********************
 If ExamineKeyboard()
	 If KeyboardReleased(#PB_Key_F1)
	 	Ecran=GrabSprite(#PB_Any,0,0,1024,768)
	 	SaveSprite(Ecran,"SauveEcran.BMP",#PB_ImagePlugin_BMP)
	 EndIf
 EndIf
Tu prendras le format d'image qui te convient :)

Pour le reste de tes questions , je n'ai pas encore tout lu .
http://purebasic.developpez.com/
Je ne réponds à aucune question technique en PV, utilisez le forum, il est fait pour ça, et la réponse peut profiter à tous.
comtois
Messages : 5186
Inscription : mer. 21/janv./2004 17:48
Contact :

Message par comtois »

pour la résolution en 16 bits, faut peut-être que tu testes avant le résultat

Code : Tout sélectionner

  InitSprite()

  If ExamineScreenModes()
    While NextScreenMode()
      Debug Str(ScreenModeWidth())+"x"+Str(ScreenModeHeight())+"x"+Str(ScreenModeDepth())+"@"+Str(ScreenModeRefreshRate())+"Hz"
    Wend
  EndIf
http://purebasic.developpez.com/
Je ne réponds à aucune question technique en PV, utilisez le forum, il est fait pour ça, et la réponse peut profiter à tous.
comtois
Messages : 5186
Inscription : mer. 21/janv./2004 17:48
Contact :

Message par comtois »

carte(carte(x,y,0),carte(x,y,0),1) c'est à dire travailler avec deux couches différentes de la matrice?
Bien sûr que c'est possible, j'avoue que je n'ai pas vérifié , mais je ne vois pas pourquoi ça ne serait pas possible.
Est-ce que travailler avec des sprites en 16 couleurs économise les capacités de l'ordi(comme ça, il peut tout mettre sur l'IA)?
Est-ce que tu as regardé le jeu de Polux ? :)

Tu peux déjà pas mal charger la mule avant de la saturer.
comment se superposent les sprites?
Exemple, dans les jeu en pseudo 3D, les perso peuvent passer devant ou derrière un obstacle.
Ils s'affichent dans l'ordre que tu les écris
si tu veux que ton personnage passe derrière un arbre
DisplaySprite(#Perso,x,y)
DisplaySprite(#Arbre,x,y)
si tu le veux devant ,tu inverses les displays , en gros il faut que tu gères une profondeur , et tu affiches tes sprites par ordre de profondeur.
http://purebasic.developpez.com/
Je ne réponds à aucune question technique en PV, utilisez le forum, il est fait pour ça, et la réponse peut profiter à tous.
Gillou
Messages : 373
Inscription : sam. 28/août/2004 17:35
Localisation : Bretagne, 22
Contact :

Message par Gillou »

la méthode que tu propose carte(carte(x,y,0),carte(x,y,0),1) est possible mais pas très pratique à manipuler

pour utiliser plusieurs couche à ta matrice, tu peux faire comme ça


Structure couche
    couche1.l
    couche2.l
    couche3.l
EndStructure

Dim carte.couche(20,11,1)

carte(1,1,1)\couche1 = 1
carte(1,1,0)\couche3 = 3

Debug carte(carte(1,1,1)\couche1,carte(1,1,1)\couche2,1)\couche2
Debug carte(1,1,1)\couche1
Debug carte(1,1,0)\couche3


tu peux aussi ajouter une dimension à ton tableau.
L'ajout d'une dimension n'affecte pas à proprement parlé les performances système, elle augmente juste la mémoire utilisée par le programme et donc diminue la mémoire système disponible. (mais bon faut déjà créer un tableau bien énorme :) )

Et biensur plus tu fais de calcul sur ton tableau, plus tu ralentis ton ordi.
Avatar de l’utilisateur
Huitbit
Messages : 940
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

Message par Huitbit »

Merci pour les réponses!! :D
@Comtois
Je vais essayer tout ça!!!!
Pour ce qui est du jeu de Pollux, c'est une autre dimension!!!!!J'ai vu les photos d'écran
Wahoo!
Ses codes doivent être super optimisés
( j'ai une connexion de 40 kbs/s les bons jours alors pour l'instant j'ai un peu la flemme de le télécharger même si ça vaut le coup, en plus je suis en plein bac blanc ces temps-ci...)

Moi je ne connais aucune astuces de programmation, c'est pour cela que je m'inquiète car je ne fais pas dans la finesse et je compte mettre tout ce dont j'ai envie sur l'écran!!

Ton tutoriel est une des premières choses que j'ai regardé quand j'ai découvert PureBasic! :wink:

Quand j'aurai tout mis en place je compte bien l'éplucher soigneusement car il est très clair et je pense qu'il me sera bien utile!!

@Gillou
Je crois que je vais prendre l'option "ajouter des dimensions", ça ne demande pas trop d'efforts( puisque c'est déjà comme ça!)!!!

Hasta la vista!
Dernière modification par Huitbit le lun. 30/janv./2006 4:31, modifié 1 fois.
Elevé au MSX !
Gratteur
Messages : 147
Inscription : ven. 22/avr./2005 23:02

Message par Gratteur »

Si ça peut d'aider, je développe en ce moment un petit jeu online de gestion-stratégie-guerre, voici le code vraiment tout simple du système d'affichage de l'éditeur de carte (celui du jeu est un poil plus complexe mais les bases sont les mêmes) :

Code : Tout sélectionner

Procedure AffichageCarte()
  aff_ecran_x = GetGadgetState(#scrollbar_1)
  aff_ecran_y = GetGadgetState(#scrollbar_2)
  For h=0 To 8
    For j=0 To 18
      For i=0 To 24
        If h = 0 Or h = 4 Or h = 8
          Break 2
        EndIf
        If h = chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_b_num)\superposition And decors(i+aff_ecran_x,j+aff_ecran_y)\couche_b_num > 0
          DisplayTransparentSprite(chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_b_num)\sprite,(i*32),(j*32)-8)
        EndIf
        If h = chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_m_num)\superposition And decors(i+aff_ecran_x,j+aff_ecran_y)\couche_m_num > 0
          DisplayTransparentSprite(chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_m_num)\sprite,(i*32),(j*32)-8)
        EndIf
        If h = chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_h_num)\superposition And decors(i+aff_ecran_x,j+aff_ecran_y)\couche_h_num > 0
          DisplayTransparentSprite(chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_h_num)\sprite,(i*32),(j*32)-8)
        EndIf
      Next i
    Next j
  Next h
EndProcedure
(i,j) sont les coordonnées de la case de la carte concernée
h représente le niveau de superposition (h=0 est le niveau le plus bas, h=4 celui des personnages, h=8 au dessus de tout)
chipset(decors(i+aff_ecran_x,j+aff_ecran_y)\couche_b_num)\superposition représente donc le niveau de superposition du décors du chipset utilisé sur la case actuelle
decors(i+aff_ecran_x,j+aff_ecran_y)\couche_b_num est donc le décors du chipset utilisé en couche basse (idemne pour m et h, couches moyenne et haute)

Voila le code parle de lui-même.

J'ai fais un petit test avec scrolling fait cet été pour mon A-RPG "La Dernière Etreinte".
Si tu veux voir ce que le code ci-dessus donne tu peux télécharger ca (1,6 Mo) : http://ns.gratteur.free.fr/LDE/LDE(aout2005).zip

Bon courage.
Dernière modification par Gratteur le lun. 30/janv./2006 20:03, modifié 1 fois.
Avatar de l’utilisateur
Huitbit
Messages : 940
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

La route va être longue!!!

Message par Huitbit »

Super la démo 8) (par contre le lien vers le site ne veut pas fonctionner :cry: )

Avant de continuer j'ai décidé
-de tout mettre sous forme de procédures(car quand ça va s'allonger j'ai un peu peur pour la clarté!)
-de comprendre le fonctionnement des structures et des pointeurs (le résumé de Dobro et le site de Comtois sont assez clairs là dessus, à moi de faire l'effort!) car j'en aurai besoin (jusqu'à maintenant, j'ai tout fait pour les éviter :roll: ))

Mon projet est moins gigantesque que le tien, mais les techniques des RPG s'y adaptent à 100%(le tut de Comtois m'a plus que convaincu pour les structures et les pointeurs(même si j'y comprend pas grand chose pour l'instant :lol: !))

Ma prochaine étape sera de construire des forteresses de formes quelconques (c'est pour ça que j'ai créé la routine de détection, pour détecter, entre autres, les zones amies et ennemies)

Enfin pour l'instant, il faut que je consolide mes petites purebases (Comme dirait Jimi:"castles made of sand...").

De toute façon, il n'a pas le feu(comme ne dirait pas le Voodoo Chile :wink: !)
Elevé au MSX !
Dräc
Messages : 526
Inscription : dim. 29/août/2004 0:45

Message par Dräc »

Sages décisions que voila !

Pour les structures, tu n’auras aucun mal à comprendre et dès que tu t’y seras intéressé tu ne pourras plus t’en passer.
Pour te lancer, comprends les structures comme un moyen pratique de regrouper plusieurs variables.
Ainsi, un personnage de ton jeu peut avoir l’ensemble de ses caractéristiques regroupées dans une meme structure.
Disons qu’un personnage a pour caractéristiques :
-son Nom$ (pour avoir une exemple avec un string),
-sa jauge de vie
-des points d’action

Il te suffit alors de créer une structure Personnage comportant ces trois caractéristiques.

Code : Tout sélectionner

Structure Personnage
Nom$
Vie.l
PtAction.l
EndStructure
Maintenant que tu as définie ta structure, tu peux créer une variable personnage « MonPersonnage » de type Personnage (la structure)

Code : Tout sélectionner

MonPersonnage.Personnage
Tu accèdes aux différentes caractéristiques de ton personnage grace à l’opérateur « \ » comme suite :

-Pour le nom : MonPersonnage\Nom$
-Pour la jauge de vie : MonPersonnage\Vie
-Pour les points d’action : MonPersonnage\PtAction

que tu manipules de la même maniere que des variables.

Alors quel est l’interet des structures si c’est comme des variables regroupées ? Et bien justement, c’est regroupé sous un même nom!
Tout personnage de ton jeu sera de type « Personnage » et non plus éclaté en morceau dans ton code…
Tu peux créer aussi un type Forteresse pour tes constructions.
Cela apporte clarté et facilité de programmation.

Les structures ont d’autres utilités que tu comprendras avec les pointeurs.

Les pointeurs, par contre, sont plus subtils à saisir et tu ne seras parfaitement les manipuler qu’après un certain temps.
Saches que ce n’est pas nécessaire de les comprendre dans un premier temps mais dis toi que tot ou tard tu devras faire cet effort si tu souhaite faire un step dans ton niveau de programmation, car le pointeur est une notion fondamentale !!
Un très bon exercice complet pour apprendre les pointeurs est de programmer sa propre liste chainée (Linked List).

Bon courage à toi. :wink:
Avatar de l’utilisateur
Huitbit
Messages : 940
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

Ouah un toulousaing!

Message par Huitbit »

Merci pour les structures!
Si ça pouvait aller aussi vite pour les pointeurs :D !

Il me tarde de savoir à quoi ça sert (car certains programmes peuvent faire des choses identiques avec ou sans).

On gagne en rapidité? En simplicité dans les algorithmes complexes?
Y a-t-il des choses qui ne pourraient pas être faites sans?

Dans les sujets, on en parle, on les utilise mais on dit pas trop pourquoi!

De toute façon ça a l'air important alors faudra que je m'y mette!

PS: j'ai fait mes études à Toulouse (collège Aucamville; lycée St Sernin; Fac Rangueil)!
Il y fait presqu'aussi beau qu'en Guadeloupe :wink:
Elevé au MSX !
Dräc
Messages : 526
Inscription : dim. 29/août/2004 0:45

Message par Dräc »

En soit un pointeur est simple, c’est son application qui le rend difficile à appréhender au début.
Un pointeur ce n’est rien d’autre qu’une variable qui reçoit comme valeur une adresse mémoire.
Donc un pointeur = une adresse mémoire.

Le pointeur permet donc d’étiqueter une zone de la mémoire. On dit qu’il pointe cette zone mémoire.
Des zones mémoires tu en connais déjà certaines : toutes variables de ton code contenant des informations sont ni plus ni moins que des zones mémoires allouées.

En pointant une de ces zones, tu peux accéder à son contenu.
Soit en utilisant des commandes comme PeekB(), PeekL(), etc… soit une structure (tiens donc !)

Par exemple :

Soit « a.b = 10» est une variable de type byte.
Son adresse mémoire est donnée par l’opérateur « @ », soit « @a ».

Maintenant tu définis un pointeur « *pointeur » qui pointe la variable « a »

Code : Tout sélectionner

*pointeur = @a
Pour lire le contenu de « a » tu peux ecrires :

Code : Tout sélectionner

PeekB(*pointeur)
Avec une structure, tu types ton pointeur (rappelles toi, un pointeur est ainsi une variable, donc on peut le typer comme une varaible).
Ici, la structure BYTE est native (elle existe intrinsèquement dans PB)
En écrivant :

Code : Tout sélectionner

*pointeur.BYTE = @a
tu accède à la valeur de « a » en écrivant :

Code : Tout sélectionner

*pointeur\b
En typant ton pointeur, tu indiques au pointeur comment il doit interpréter les données de la zone mémoire pointé.
Il lira un BYTE, un WORD ou un LONG selon son type.
Si tu le types avec une structure maison, comme « Personnage » tu accèderas alors au contenu de la mémoire selon la définition de ta structure et de la meme manière qu’une variable classique.

Ainsi,

Code : Tout sélectionner

MonPersonnage.Personnage
*pointeur.Personnage = @MonPersonnage
*pointeur\PtAction retourne la meme valeur que MonPersonnage\ PtAction

C’est normal car tu as confondu la variable « MonPersonnage » et le pointeur « *pointeur »

Si tu écrires :

Code : Tout sélectionner

*pointeur.BYTE = @MonPersonnage
alors la valeur lue par *pointeur\b ne correspond à rien de pertinent car tu cherches à lire un byte de mémoire au lieu d’un string (champs Nom$ en début de la structure Personnage)
Un

Code : Tout sélectionner

*pointeur.STRING = @MonPersonnage
a donc plus de sens ici.

Pour en revenir à l’exemple de la variable « a », tu peux donc procéder comme suite :

Code : Tout sélectionner

Structure MyBYTE
b.b
EndStructure
a.b = 10
*pointeur.MyBYTE = @a
Debug *pointeur\b
Au risque de t’embrouiller, une autre possibilité (mais là j’exagère, c’est un cas d’école)

Code : Tout sélectionner

Structure MyBYTE
b.BYTE
EndStructure
a.b = 10
*pointeur.MyBYTE = @a
Debug *pointeur\b\b
Dans l’expression *pointeur\b\b, le premier « b » correspond à la variable b.BYTE de la structure. Comme b.BYTE est elle-même une variable typée par une structure, il faut utiliser l’opérateur « \b » pour accéder à la valeur, d’où le deuxième b.

Ce n’est pas indiqué dans la doc de PB, mais les types
Byte
Word
Long
Float
String
Existent nativement et on accède aux valeurs respectivement par
\b
\w
\l
\f
\s

En fait, une structure comme LONG n’est rien d’autre que

Structure LONG
l.l
EndStructure

Comme elles sont très utiles, PB les incorporent nativement.

Bref, pour résumer, un pointeur pointe une adresse mémoire et te permet de lire sont contenu.

Quel est l’avantage des pointeurs ?
Imagines que tu as une variable qui comporte beaucoup de données.

Pour passer cette variable à une procedure, tu as deux possibilités :

-Soit tu demandes à la procedure de dupliquer cette grosse variable en une deuxième afin d’y faire ses calculs : auquel cas la procedure doit copier les données -->perte de temps et de place mémoire.
-Soit tu lui donnes l’adresse de cette variable, auquel cas il n’y à pas de duplication de données aussi importantes soient-elles.
La procedure travaillera directement avec la zone mémoire de la variable.
La vitesse d’exécution est optimale et tu préserves ta mémoire libre (pas de duplication inutile)

Donc le pointeur te permet d’accéder au contenu de la mémoire simplement et rapidement.

Une autre caractéristique du pointeur, c'est qu'il est indépendant de la variable pointé (et donc du nom de cette variable)
En lui affectant une nouvelle adresse, tu peux donc te balader de block mémoire en block mémoire.
Donc je me serts principalement des pointeurs pour rendre mes procédures génériques (non specifiques à des variables) et gagner en productivité et en clarté… mon code est mieux structuré.
Dräc
Messages : 526
Inscription : dim. 29/août/2004 0:45

Re: Ouah un toulousaing!

Message par Dräc »

Huitbit a écrit :PS: j'ai fait mes études à Toulouse (collège Aucamville; lycée St Sernin; Fac Rangueil)!
Il y fait presqu'aussi beau qu'en Guadeloupe :wink:
Je veux bien croire qu’en saison des cyclones, les climats soient comparables :lol:
Avatar de l’utilisateur
Huitbit
Messages : 940
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

Thanks a lot!

Message par Huitbit »

Avec tout ça si je n'y arrive pas c'est que je veux pas!

ça me prendra un peu de temps( il y a un tsunami de copies d'élèves qui est prévu pour la fin du trimestre 8O )
mais j'espère que mon prochain message sera pour l'étape n°2 et que j'utiliserai les procedures, les structures et les pointeurs(et pour la suite, pourquoi pas quelques data!).

Pure merci!

PS: et pour les sprites, des pistes :?:
Sinon, je les ferai, mais c'et super dur avec une vue comme ça(c'est peut-être pour ça que c'est rare)!
(il y a longtemps, il ya eu Gauntlet mais les sprites n'étaient pas terribles, il y a eu aussi SIEGE mais idem).
J'avais pensé prendre un logiciel de 3D, dessiner puis mettre la caméra au dessus mais c'est trop balèze pour moi ces logiciels :( !
Elevé au MSX !
Avatar de l’utilisateur
Huitbit
Messages : 940
Inscription : jeu. 08/déc./2005 5:19
Localisation : Guadeloupe

Récursive? Itérative?

Message par Huitbit »

Je ne suis pas encore passé à l'étape 2 (trop de copies :mad: ) mais en fouinant sur le forum( sujet: pathfinding, recursivité(Dobro~Fweil...)), je suis tombé sur une question que je m'étais posée en faisant ma procédure detection(qui sert a repérer dans un tableau tous types de cases)

Voilà rapidement son fonctionnement:

choix d'une case dans le prog principal puis appel de detection0
********************
detection0
on memorise les coordonnées de la case choisie
on dit qu'on a visité la case

puis on teste les voisines
si il n'y a rien on revient à la case départ (dont les coordonnées sont mémorisées)
si il y a qquechose on appel detection1 qui est la copie conforme de detection0(mais qui appelle detection0)
******************

J'avais fait le choix de coupler ces deux procédures car je ne savais pas qu'une procédure pouvait s'appeler elle-même 8O.

Questions:


Est-ce un cas d'itérativité(ça se dit ça?)? De récursivité?

Est-ce que detection0 aurait pû s'appeller elle-même?

Comment sait-on si l'ordi va supporter la récursivité?

Si je veux utiliser des fonts(polices) particulières est-ce qu'il suffit de les mettre dans le même dossier que le prog (comme les images)?


Voilà un exemple d'image que je recherche:
Image

Si vous avez des archers, des catapultes... je prend!

A propos de la version 4 de PB....
ça serait dommage que toutes les sources en v3.94 doivent être retouchées! Peu de gens aiment remettre le nez dans des codes vieux de 6 mois!
Un patch v4 <-> v3.94 ça sera possible?Ou un petit mémo (sous forme de tutorial?)
Elevé au MSX !
Dr. Dri
Messages : 2527
Inscription : ven. 23/janv./2004 18:10

Message par Dr. Dri »

Je te rassure, la transition vers la version 4 est vraiment très simple...
Pour un code de plus de 1000 lignes, ca m'a pris tout au plus 30 secondes.
http://purebasic.hmt-forum.com/viewtopi ... 3425#43425

Voila comment j'ai procédé:
J'ai fait ue copie de la source que j'ai ouverte avec PB4
Apres j'ai appuyé sur F5
J'ai droit à un message d'erreur
Je corrige (si je sais pas comment je regarde dans ReadMe.html)
Y'a qu'à continuer jusqu'à ne plus avoir d'erreur et ô magie, ca fonctionne

Dri :D
Répondre