problème d'affichage

comtois · Message par **comtois** » dim. 11/févr./2007 8:38

sinon essaye ce code, il faut que tu actives ton débogueur

Debug "la résolution de fly = 1440*900"
Debug "soit 1440/100 = 15 sprites pour la largeur"
Debug "et 900/100 = 9 sprites pour la hauteur"
Debug "Ce qui fait 15*9 = 135 sprites pour couvrir l'écran."
Debug "On a donc 135 sprites de 100*100 pour le décor"
Debug "même en ajoutant une couche d'objets divers et une couche de personnage"
Debug "Je ne vois pas comment on peut atteindre 1000 sprites de 100*100 sur un écran ?"

fly · Message par **fly** » dim. 11/févr./2007 12:55

Comme je suis en train de créer un jeu du style de age of empire et de cossacks 2 qui ce passe à l'époque de napoleon.SI tu as déjà jouer à cossacks 2 tu as du remarquer que les armée était divisée en compagnie de 120 personnages chacune.IL suffit d'en avoir que quelque une à l'écran pour qu'on arrive à 1000 perso.

A quel mode utilise tu "FlipBuffers()" "0,1 ou 2" ?
Existe t'il un façon d'afficher une partie des sprites lors d'un cycle et l'autre partie le cycle suivant?

bernard13 · Message par **bernard13** » dim. 11/févr./2007 12:58

fly

j'aimerai voir un screen de ton jeu

comtois · Message par **comtois** » dim. 11/févr./2007 14:14

fly a écrit :Comme je suis en train de créer un jeu du style de age of empire et de cossacks 2 qui ce passe à l'époque de napoleon.SI tu as déjà jouer à cossacks 2 tu as du remarquer que les armée était divisée en compagnie de 120 personnages chacune.IL suffit d'en avoir que quelque une à l'écran pour qu'on arrive à 1000 perso.

Je ne connais pas ces jeux alors j'ai recherché des images histoire de bien me rendre compte, sur des images de cossaks on voit effectivement pas mal de personnages, mais ils ne font pas 100*100 , je ne connais pas la résolution du jeu, mais ils font en gros 32*64 guère plus. ça fait déjà une belle différence !
ça prend 4 à 5 fois moins de pixels.

et par curiosité j'ai repris un code et j'ai affiché 1000 sprites de 24*32 qui se balladent sur un écran de 800*600 ben c'est vite le bordel , on ne voit plus rien.

j'utilise cette image

Code : Tout sélectionner

Structure s_Sprite
    Direction.l              ; Direction de l'animation , Haut droite bas ou gauche 
    Colonne.l                ; Décalage en X pour la première image
    Ligne.l                  ; Décalage en Y pour la première image   
    ImageEnCours.l           ; Indique quelle image de l'animation est actuellement en cours 
    ImageMaxi.l              ; Nombre d'image maxi pour une animation , ici on a 3 images par direction
    TailleX.l                ; Dimension en X de chaque image 
    TailleY.l                ; Dimension en Y de chaque image
    TempsEnCours.l           ; Indique la durée d'affichage de l'image en cours
    TempsMaxi.l              ; Indique la durée maxi d'affichage d'une image avant de passer à la suivante
    x.l                      ; Position en X du sprite
    y.l                      ; Position en Y du sprite
    Vitesse.l                ; Vitesse déplacement 
EndStructure 

;Déclare 4 constantes 
Enumeration
    #AnimeHaut
    #AnimeDroite
    #AnimeBas
    #AnimeGauche
EndEnumeration 
#Nb = 119
#Sx = 800
#Sy = 600 
#Joueur = 3     ; Indique le No du personnage utilisé pour le joueur - Contrôlé au clavier
#VitesseGus = 1 ; Déplacement d'un pixel

;Déclare les procédures
Declare GestionClavier(*Sp.s_Sprite)
Declare AnimationSprite(*Sp.s_Sprite)
Declare DeplaceSprite(*Sp.s_Sprite)
Declare IAGus(*Sp.s_Sprite)
Declare AfficheTexte()

;On déclare un personnage  
Dim Gus.s_Sprite((#Nb+1)*8) ; ; 800 personnages de 0 à 7
For n=0 To #Nb
For Lig = 0 To 1
    For Col = 0 To 3
        Gus(NoGus)\Direction    = Random(3)                   ; On choisit une direction
        Gus(NoGus)\ImageMaxi    = 2                            ; (0,1,2) ce qui fait bien 3 images
        Gus(NoGus)\ImageEnCours = 0                            ; On se place sur la première image de l'animation
        Gus(NoGus)\TailleX      = 24                           ; Taille d'une image 
        Gus(NoGus)\TailleY      = 32                           ; Taille d'une image 
        Gus(NoGus)\TempsEnCours = ElapsedMilliseconds()      ; Initialise la durée d'affichage de l'ImageEnCours
        Gus(NoGus)\TempsMaxi    = 150                           ; Ajuster la vitesse de l'animation ici
        Gus(NoGus)\x            = 30+Random(#Sx-30)               ; Position à l'écran en X
        Gus(NoGus)\y            = 30+Random(#Sy-30)               ;  Position à l'écran en Y
        Gus(NoGus)\Colonne      = (Col*3) * Gus(NoGus)\TailleX ; Calcul la position en X de la première image 
        Gus(NoGus)\Ligne        = (Lig*4) * Gus(NoGus)\TailleY ; Calcul la position en Y de la première image
        NoGus + 1                                               ; Numéro du Gus suivant
    Next Col
Next Lig
Next n

;Initialise l'environnement nécessaire au fonctionnement des sprites et pour ouvrir un écran.
InitSprite()

;Initialise l'environnement propre à la gestion du clavier. 
InitKeyboard()

;Ouvre un nouvel écran avec les caractéristiques Largeur, Hauteur et Profondeur. 
OpenScreen(800,600,32,"Tut Sprite")

;Active le support du format PNG (Portable Network Graphic)
UsePNGImageDecoder() 
    
;Charge en mémoire le sprite 
If LoadSprite(0,"player.png")=0
    MessageRequester("Erreur","Impossible de charger le sprite Player.png",0)
    End ; Quitte le programme
EndIf    

Repeat
    ;Inverse le buffer d'arrière plan avec le buffer visible à l'écran. 
    ;La partie invisible du buffer remplace alors complètement La partie visible. 
    FlipBuffers()
    
    ;Efface l'écran courant avec la couleur specifiée. 
    ClearScreen(0)
    
    ;Gestion du clavier avec le sprite 2
    GestionClavier(@Gus(#Joueur))
    
  
    NoGus = 0
    For n=0 To #Nb
      For i=0 To 7
        ;Anime le sprite
        AnimationSprite(@Gus(NoGus))
        
        ;Deplace et affiche le sprite
        DeplaceSprite(@Gus(NoGus))
        
        ;Petite IA simpliste pour contrôler le déplacement des gus
        If NoGus<>#Joueur
            IAGus(@Gus(NoGus))
        EndIf 
        NoGus + 1
      Next i
    Next n
    
    If Second < ElapsedMilliseconds()
      Second = ElapsedMilliseconds()+1000
      fps = Frame_Counter
      Frame_Counter = 0
    Else
      Frame_Counter + 1
    EndIf
    
    StartDrawing(ScreenOutput())
      DrawText(0,0,"FPS : "+Str(fps))
      DrawText(100,0,Str(nogus))
      DrawingMode(#PB_2DDrawing_Outlined)
      Box(Gus(#Joueur)\x,Gus(#Joueur)\y,Gus(#Joueur)\Taillex,Gus(#Joueur)\Tailley,#Blue)
    StopDrawing() 

Until KeyboardPushed(#PB_Key_Escape)

End

Procedure GestionClavier(*Sp.s_Sprite)
    
    If ExamineKeyboard()
        
        ;La touche haut du curseur est appuyée
        If KeyboardPushed(#PB_Key_Up)
            *Sp\Direction=#AnimeHaut
            
            ;La touche droite du curseur est appuyée
        ElseIf KeyboardPushed(#PB_Key_Right)
            *Sp\Direction=#AnimeDroite
            
            ;La touche bas du curseur est appuyée
        ElseIf KeyboardPushed(#PB_Key_Down)
            *Sp\Direction=#AnimeBas
            
            ;La touche gauche du curseur est appuyée
        ElseIf KeyboardPushed(#PB_Key_Left)
            *Sp\Direction=#AnimeGauche
            
        Else
            *Sp\Vitesse=0
        EndIf
    EndIf    
    
EndProcedure

Procedure AnimationSprite(*Sp.s_Sprite)
    
    ;Test si la durée maxi d'affichage d'une image est dépassée 
    If ElapsedMilliseconds()-*Sp\TempsEnCours>*Sp\TempsMaxi
        
        ;Initialise la durée d'affichage
        *Sp\TempsEnCours=ElapsedMilliseconds()
        
        ;Incrémente l'image en cours, pour afficher l'image suivante.
        *Sp\ImageEnCours + 1
        
        ;On reboucle l'animation ici 
        If *Sp\ImageEnCours>*Sp\ImageMaxi
            *Sp\ImageEnCours = 0 
        EndIf 
        
    EndIf
    ClipSprite(0,*Sp\Colonne + *Sp\ImageEnCours * *Sp\TailleX, *Sp\Ligne + *Sp\Direction * *Sp\TailleY, *Sp\TailleX , *Sp\TailleY)
    
EndProcedure    
Procedure DeplaceSprite(*Sp.s_Sprite)
    
    Select *Sp\Direction
        Case #AnimeHaut
            *Sp\y - *Sp\Vitesse
        Case #AnimeDroite
            *Sp\x + *Sp\Vitesse
        Case #AnimeBas
            *Sp\y + *Sp\Vitesse
        Case #AnimeGauche
            *Sp\x - *Sp\Vitesse
    EndSelect
    
    ;Affiche le sprite à la nouvelle position
    DisplayTransparentSprite(0,*Sp\x, *Sp\y)
    
    ;Initialise la vitesse
    *Sp\Vitesse = #VitesseGus
    
EndProcedure

Procedure IAGus(*Sp.s_Sprite)
    
    ;Test la position des gus 
    d=Random(1000)
    If d < 80
      *Sp\Direction = Random(3)
    EndIf
    If *Sp\x > #Sx - *Sp\TailleX 
        *Sp\x = #Sx - *Sp\TailleX 
        *Sp\Direction + 1
    EndIf
    If *Sp\y > #Sy - *Sp\TailleY 
        *Sp\y = #Sy - *Sp\TailleY 
        *Sp\Direction + 1
    EndIf
    If *Sp\x < 0
        *Sp\x = 0 
        *Sp\Direction + 1
    EndIf
    If *Sp\y < 0
        *Sp\y = 0 
        *Sp\Direction + 1
    EndIf
    
    If *Sp\Direction > #AnimeGauche
        *Sp\Direction = #AnimeHaut
    EndIf    

EndProcedure

Backup · Message par **Backup** » dim. 11/févr./2007 14:19

il est en forme le comtois !!

tmyke · Message par **tmyke** » dim. 11/févr./2007 14:31

A oui, j'confirme , très cool le code...

mais c'est vite le bazar comme tu dis Comtois, et le frame rate en prend un
coup. Je sents bien que la carte a du mal à coller au 60 fps...
En 1280x1024 et 1600 p'tits bonzommes, je descends a 30 fps.

fly · Message par **fly** » dim. 11/févr./2007 14:39

Comtois je comprend que tu sois septique mais j'ai réussit à recuperer des animations de personnage de l'époque et le sprite fait bien 100*100.
Comme les perso sont regroupés en compagnie,le faite de les regarder par une vue de dessus cela implique que l'on va les voir se chevocher , ce qui va reduire considérablement l'espace pris par les personnages ce qui permettre d'en afficher 1000 facilement et d'avoir aussi le décors alentour.

comtois · Message par **comtois** » dim. 11/févr./2007 18:05

fly a écrit :Comtois je comprend que tu sois septique mais j'ai réussit à recuperer des animations de personnage de l'époque et le sprite fait bien 100*100.
Comme les perso sont regroupés en compagnie,le faite de les regarder par une vue de dessus cela implique que l'on va les voir se chevocher , ce qui va reduire considérablement l'espace pris par les personnages ce qui permettre d'en afficher 1000 facilement et d'avoir aussi le décors alentour.

C'est quoi le nom du jeu ? je suis curieux de voir ça. Parce que j'ai regardé cossaks les sprites ne font pas 100*100.

fly · Message par **fly** » dim. 11/févr./2007 19:07

C'est un mods pour american conquest qui s'appel european warfare. Mais il est vrai que les sprites sont plus gros que ceux de cossacks.

tmyke · Message par **tmyke** » dim. 11/févr./2007 19:34

Certes, afficher 1000 sprites (donc entités indépendantes en fait) il faut
aussi leurs donner un comportement cohérent, donc calculer ce comportement
pour les 1000 sprites, sans compter ceux que tu ne vois pas à l'ecran, car si il
y en a 1000 a l'ecran, il y en a au moins autant si ce n'est plus hors screen...

Chaud comme codage niveau opti...

comtois · Message par **comtois** » dim. 11/févr./2007 19:35

Revois à la baisse les caractéristiques de ton jeu, je viens de télécharger une démo de Age of empires 2 histoire de me faire une idée, les sprites sont petits ,ils n'y en a pas 1000 à l'écran, et les vues sont bien chargées

Déjà pour faire un jeu de cette taille là , ça va te prendre des mois, voire des années si tu bosses seul dessus. Contente toi de quelques centaines de personnages à l'écran de taille 64*64 maxi , ou plus gros pour les bâtiments éventuellement et ça pourra faire un très bon jeu.