Forum Liberty Basic France

Jeux » Shoot'em up '80 et petits problèmes à résoudre
Le 08/11/2020 à 13h38

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Voici qui devrait, à terme, ressembler à un "shoot them up' des années 80, je me suis fait plaisir avec des gros pixels et la façon de les programmer à l'époque.

par contre, je n'arrive pas à utiliser CYCLESPRITE : les sprites sont correctement créés et affichés, sauf que l'animation sur l'alien (les bitmaps qui devraient s'afficher alternativement sur le même sprite), ne fonctionne pas. J'arrive bien à les afficher tous, mais pas à les faire défiler. j'ai utilisé des couleurs différentes pour bien les différencier.

(Les sprites se retrouvent en bas de l'écran après avoir étés touchés par un missile : c'est normal, et ce n'est actuellement pas le problème)

Le listing :
Code VB :
'recherche sur sprites avec plusieurs bitmaps pour animation

'Peu à peu adapté à partir d'un programme de Rod (rodbird) trouvé dans les exemples
'    (invaders again.bas)

' ""
'Invaders again! use the mouse to move the gun right click to fire.
'Use this simple video game as a foundation for a more ambitious game.
'Used with permission.
' ""

 'nomainwin
'(inspiration : écran MSX screen8, 256*212 pixels, 256 couleurs, c'est juste pour l'ambiance)
taillepix=4 'nombre de pixels d'aujourd'hui pour représenter un pixel d'antan
largeurs8=256*taillepix
hauteurs8=212*taillepix
 
WindowWidth  = largeurs8
WindowHeight = hauteurs8
UpperLeftX   = (DisplayWidth-WindowWidth)/2
UpperLeftY   = (DisplayHeight-WindowHeight)/2
graphicbox #w.g, 0,0,largeurs8,hauteurs8
open "Invaders" for graphics_nf_nsb as #w
#w "trapclose [quit]"
 
[initialise]
    x = 1
    y = 2
    adir = -10        'alien direction
    aspeed = 1.01     'alien acceleration
    base = 540        'base line of gun
    dim bullet(6,2)   'bullet x,y
    dim alien(6,2)    'alien x,y
    dim nombmp$(4)    'dimensionné au nombre de bitmaps générés
    numbmp=0          'numéro du bitmap actuellement défini

'création des bitmaps à l'ancienne, et des sprites d'aujourd'hui
'(matrices de 8x8 pixels, 0=pixel éteint, 1=pixel allumé)
[alien_anim0]
    data "00111100"
    data "01000010"
    data "01111110"
    data "10000001"
    data "11000011"
    data "00111100"
    data "01000010"
    data "10000001"
    restore [alien_anim0]:couleur$="red":nom$="alien0":gosub [creer_bitmap]
    numbmp=numbmp+1
 
[alien_anim1]
    data "00111100"
    data "01011010"
    data "01111110"
    data "10000001"
    data "11111111"
    data "00100100"
    data "01000010"
    data "01000010"
    restore [alien_anim1]:couleur$="cyan":nom$="alien1":gosub [creer_bitmap]
    numbmp=numbmp+1
 
[alien_anim2]
    data "00111100"
    data "01000010"
    data "01111110"
    data "10000001"
    data "11000011"
    data "00111100"
    data "00100100"
    data "00100100"
    restore [alien_anim2]:couleur$="green":nom$="alien2":gosub [creer_bitmap]
    nom$=nombmp$(0)+" "+nombmp$(1)+" "+nombmp$(2)
 
    for n = 1 to 6
        alien(n,x) = 200+70*n
        alien(n,y) = 0
        #w.g "addsprite alien";str$(n);" ";nom$
        '#w.g "cyclesprite alien";str$(n);" 1"
    next
    numbmp=numbmp+1
 
[missiles]
    data "00010000"
    data "00010000"
    data "00010000"
    data "00010000"
    data "00111000"
    data "01111100"
    data "00010000"
    data "00010000"
    restore [missiles]:couleur$="yellow":nom$="missile":gosub [creer_bitmap]
    nom$=nombmp$(3)
    for n = 1 to 6
        bullet(n,x) = 400
        bullet(n,y) = base
        #w.g "addsprite bullet";str$(n);" ";nom$
    next
    numbmp=numbmp+1
 
[vaisseau]
'à définir

[explosion]
'à définir, plusieurs bitmaps

 
'définir le décor
'box background
for i = 0 to 150
    j = 256 - i
    #w.g "down ; backcolor ";j/3;" ";j/3;" ";j/3
    #w.g "color ";j/3;" ";j/3;" ";j/3
    #w.g "place ";i;" ";i
    #w.g "boxfilled ";largeurs8 - i;" ";hauteurs8 - i
next
 
'stars
for n = 1 to 100
    c = int(rnd(0)*255)
    #w.g "color ";c;" ";c;" ";c;" ; set ";150+rnd(0)*largeurs8-150;" ";150+rnd(0)*hauteurs8-150
next
#w.g "getbmp bak 0 0 ";largeurs8;" ";hauteurs8
#w.g "background bak";
 
'start the keyboard checking event
#w.g "when mouseMove [track]"
#w.g "when leftButtonUp [fire]"
#w.g "setfocus"
 
 
' now start the timer to repeatedly call the drawing loop
timer 56, [drawingloop]
'timer 200, [drawingloop]

'now sit and wait
wait
 
 
'****************** sous-programmes *****************

[creer_bitmap]
    #w.g, "down"
 
    'préparer le fond du sprite
    #w.g, "backcolor black;color black"
    #w.g, "place 0 0 ; boxfilled ";8*taillepix;" ";16*taillepix
 
    'pour chaque ligne de datas,
    '   dessiner les points opaques et les points transparents
    for ligne=0 to 7
        read ligne$
 
        for colonne=0 to 7
 
            if mid$(ligne$,colonne+1,1)="1" then
                'le point est opaque
                'il apparait en noir sur le masque
                'et dans la couleur du sprite sur le sprite
                colmask$="black"
                colspr$=couleur$
            else
               'le point est transparent
                'il apparait en blanc sur le masque
                'et en noir sur le sprite
                colmask$="white"
                colspr$="black"
            end if
 
            'placer le point
            '   sur le masque
            p1x=colonne*taillepix
            p1y=ligne*taillepix
            p2x=p1x+taillepix
            p2y=p1y+taillepix
            #w.g, "color ";colmask$
            #w.g, "backcolor ";colmask$
            #w.g, "place ";p1x;" ";p1y;"; boxfilled ";p2x;" ";p2y
 
            '   sur le sprite
            p3x=p1x
            p3y=p1y+8*taillepix
            p4x=p3x+taillepix
            p4y=p3y+taillepix
            #w.g, "color ";colspr$
            #w.g, "backcolor ";colspr$
            #w.g, "place ";p3x;" ";p3y;"; boxfilled ";p4x;" ";p4y
        next
    next
 
    'créer le bitmap du futur sprite
    #w.g, "getbmp ";nom$;" 0 0 ";8*taillepix;" ";16*taillepix
    nombmp$(numbmp)=nom$
 
    #w.g, "up"
    return
 
 
[drawingloop]
    for n = 1 to 6
 
        'move the bullets
        if bullet(n,y) = 540 then
            bullet(n,x) = gunX
        else
            bullet(n,y) = bullet(n,y) -10
            for c= 1 to 6
                'check for collision
                #w.g, "spritecollides alien";str$(c);" list$"
                if left$(list$,6) = "bullet" then
                    'playwave "media\bump.wav",async
                    a = val(mid$(list$,7,1))
                    bullet(a,x) = gunX
                    bullet(a,y) = base
                    alien(c,y) = 600
                    list$ = ""
                end if
            next
            if bullet(n,y) < -40 then bullet(n,y) = base : bullet(n,x) = gunX
        end if
 
        'move the aliens
        alien(n,x) = alien(n,x) + adir
        if alien(n,x) < 0 or alien(n,x) > 760 then bounce=1
 
 
        'place the sprites and draw
        #w.g "spritexy bullet";str$(n);" ";bullet(n,x);" ";bullet(n,y)
        #w.g "spritexy alien";str$(n);" ";alien(n,x);" ";alien(n,y)
        #w.g "cyclesprite alien";str$(n);" 1"
        #w.g "drawsprites"
 
    next
 
    'if we hit a wall bounce
    if bounce then
        bounce = 0
        adir = adir * -1
        adir = adir*aspeed
        for m = 1 to 6
            alien(m,y) = alien(m,y)+20
        next
    end if
    wait
 
 
    [fire]
    'find the first free bullet and launch it
    for b = 1 to 6
        if bullet(b,y)=base then
            bullet(b,y) = base-1
            exit for
        end if
    next
    wait
 
    [track]
    'keep the launch pad lined up with the mouse
    gunX = MouseX-20
    wait
 
    [quit]
    timer 0
    unloadbmp "bak"
    for a=0 to numbmp-1
        unloadbmp nombmp$(a)
    next
 
    close #w
 
    end
 
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 08/11/2020 à 15h33

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Un écran de un mètre carré c'est bien, mais faudrait penser aux écrans moins ambitieux; comme par exemple les 1024 x 600.
J'ai redimensionné mais je n'ai pas le vaisseau tireur.
Je vais essayer de voir ton soucis de cyclesprite

EDIT: Je pense que: print #w.g, "addsprite SpriteName bmp1 bmp2 bmp3 ... bmpLast" (que je ne trouve pas dans ton listing)
Est inamovible pour pouvoir utiliser cyclesprite
____________________
Roro

   
Le 08/11/2020 à 20h18

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
1024*600 ? Utiliserais-tu un Eee-PC ? Taillepix=2 devrait convenir. Taillepix=1 ne fonctionne pas mais je n'ai pas cherché à savoir pourquoi.

Citation:
J'ai redimensionné mais je n'ai pas le vaisseau tireur.

C'est normal, car il est resté à l'emplacement défini dans le programme initial, donc comme on a réduit la hauteur de la fenêtre, eh bien il est en dessous, mais ça n'empêche pas les missiles d'apparaitre sur la fenêtre. il est prévu que les dimensions et positions soient adaptées en fonction de "taillepix", mais c'est pas encore le cas.

Citation:
Je pense que: print #w.g, "addsprite SpriteName bmp1 bmp2 bmp3 ... bmpLast" (que je ne trouve pas dans ton listing

Si, il y est, dans [alien_anim2]. Sous les datas, on a : Code TEXT :
nom$=nombmp$(0)+" "+nombmp$(1)+" "+nombmp$(2)


puis dans la boucle qui suit : Code TEXT :
#w.g "addsprite alien";str$(n);" ";nom$


ce qui devrait aboutir, si la boucle est à la valeur 3, à la chaine Code TEXT :
"addsprite alien3 alien0 alien1 alien2"


D'ailleurs, l'écrire a permis de réaliser qu'on pourrait confondre le nom du sprite avec celui du bitmap, et j'ai renommé le sprite en alienw, ce qui donne : Code TEXT :
"addsprite alienw3 alien0 alien1 alien2"


Quand on lance le programme en mode normal (le triangle bleu) on ne voit que le premier bitmap de "alienw". Mais quand on lance en mode débug (la coccinelle) on sait que dans ce mode le programme est plus lent, et on voit très fugacement les trois bitmaps apparaitre, puis c'est le premier bitmap qui revient en avant jusqu'au mouvement suivant.

Je concocte une version à bitmaps externes, pour voir.
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 08/11/2020 à 23h44

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Un western après, voici une version plus classique du logiciel : il est là pour la discussion, et si on le lance tel quel, il ne trouvera pas ses bitmaps, je fournis listing et bitmaps dans le zip en dessous.

Mais, toujours le même résultat, je n'arrive pas à déterminer la bonne position pour placer le cyclesprite...
Code VB :
 
'recherches sur sprites avec plusieurs bitmaps pour animation
'on ne génère plus les bitmaps des sprites
'on utilise des bitmaps existants

 'nomainwin
'(inspiration : écran MSX screen8, 256*212 pixels, 256 couleurs, c'est juste pour l'ambiance)
'taillepix=4 'nombre de pixels d'aujourd'hui pour representer un pixel d'antan
'largeurs8=256*taillepix
'hauteurs8=212*taillepix
largeurs8=800
hauteurs8=600
 
WindowWidth  = largeurs8
WindowHeight = hauteurs8
UpperLeftX   = (DisplayWidth-WindowWidth)/2
UpperLeftY   = (DisplayHeight-WindowHeight)/2
graphicbox #w.g, 0,0,largeurs8,hauteurs8
open "Invaders" for graphics_nf_nsb as #w
#w "trapclose [quit]"
 
[initialise]
    x = 1
    y = 2
    adir = -10        'alien direction
    aspeed = 1.01     'alien acceleration
    base = 540        'base line of gun
    dim bullet(6,2)   'bullet x,y
    dim alien(6,2)    'alien x,y
    dim nombmp$(4)    'dimensionné au nombre de bitmaps générés

'définir le décor
'box background
for i = 0 to 150
    j = 256 - i
    #w.g "down ; backcolor ";j/3;" ";j/3;" ";j/3
    #w.g "color ";j/3;" ";j/3;" ";j/3
    #w.g "place ";i;" ";i
    #w.g "boxfilled ";largeurs8 - i;" ";hauteurs8 - i
next
 
'stars
for n = 1 to 100
    c = int(rnd(0)*255)
    #w.g "color ";c;" ";c;" ";c;" ; set ";150+rnd(0)*largeurs8-150;" ";150+rnd(0)*hauteurs8-150
next
#w.g "getbmp bak 0 0 ";largeurs8;" ";hauteurs8
#w.g "background bak";
 
 
'création des bitmaps
nombmp$(0)="alien0"
nombmp$(1)="alien1"
nombmp$(2)="alien2"
nombmp$(3)="missile"
 
loadbmp nombmp$(0),nombmp$(0)+".bmp"
loadbmp nombmp$(1),nombmp$(1)+".bmp"
loadbmp nombmp$(2),nombmp$(2)+".bmp"
loadbmp nombmp$(3),nombmp$(3)+".bmp"
 
'pour animation de 3 bitmaps sur les sprites "alienw"
nom$=nombmp$(0)+" "+nombmp$(1)+" "+nombmp$(2)
 
'lie les bitmaps "alien" aux sprites "alienw"
for n = 1 to 6
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw";str$(n);" ";nom$
    '#w.g "cyclesprite alienw";str$(n);" 1"
next
 
'lie le bitmap "missile" au sprite "bullet
for n = 1 to 6
    bullet(n,x) = 400
    bullet(n,y) = base
    #w.g "addsprite bullet";str$(n);" ";nombmp$(3)
next
 
 
'start the keyboard checking event
#w.g "when mouseMove [track]"
#w.g "when leftButtonUp [fire]"
#w.g "setfocus"
 
 
' now start the timer to repeatedly call the drawing loop
timer 56, [drawingloop]
'timer 200, [drawingloop]

'now sit and wait
wait
 
 
[drawingloop]
    for n = 1 to 6
 
        'move the bullets
        if bullet(n,y) = 540 then
            bullet(n,x) = gunX
        else
            bullet(n,y) = bullet(n,y) -10
            for c= 1 to 6
                'check for collision
                #w.g, "spritecollides alienw";str$(c);" list$"
                if left$(list$,6) = "bullet" then
                    'playwave "media\bump.wav",async
                    a = val(mid$(list$,7,1))
                    bullet(a,x) = gunX
                    bullet(a,y) = base
                    alien(c,y) = 600
                    list$ = ""
                end if
            next
            if bullet(n,y) < -40 then bullet(n,y) = base : bullet(n,x) = gunX
        end if
 
        'move the aliens
        alien(n,x) = alien(n,x) + adir
        if alien(n,x) < 0 or alien(n,x) > 760 then bounce=1
 
 
        'place the sprites and draw
        #w.g "spritexy bullet";str$(n);" ";bullet(n,x);" ";bullet(n,y)
        #w.g "spritexy alienw";str$(n);" ";alien(n,x);" ";alien(n,y)
        '#w.g "cyclesprite alienw";str$(n);" 1"
        #w.g "drawsprites"
 
    next
 
    'if we hit a wall bounce
    if bounce then
        bounce = 0
        adir = adir * -1
        adir = adir*aspeed
        for m = 1 to 6
            alien(m,y) = alien(m,y)+20
        next
    end if
    wait
 
 
    [fire]
    'find the first free bullet and launch it
    for b = 1 to 6
        if bullet(b,y)=base then
            bullet(b,y) = base-1
            exit for
        end if
    next
    wait
 
    [track]
    'keep the launch pad lined up with the mouse
    gunX = MouseX-20
    wait
 
    [quit]
    timer 0
    unloadbmp "bak"
    for a=0 to numbmp-1
        unloadbmp nombmp$(a)
    next
 
    close #w
 
    end
 


Le listing avec ses bitmaps dans ce zip :
shoot em up version bitmap
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 09/11/2020 à 01h07

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
Utiliserais-tu un Eee-PC

Non, c'est un HP mini
Citation:
ce qui devrait aboutir, si la boucle est à la valeur 3, à la chaine

Tu devrais essayer avec la procédure classique (non boucle)
Citation:
je n'arrive pas à déterminer la bonne position pour placer le cyclesprite...

N'a-tu pas oublié le "drawsprite"
Citation:
"addsprite alienw3 alien0 alien1 alien2"

Je pense qu'il faut donner un nom au sprite multiple
print #w.g, "addsprite SPRITENAME bmp1 bmp2 bmp3 ... bmpLast"
Je testerai demain, avec les yeux en face des trous.
____________________
Roro

   
Le 09/11/2020 à 09h42

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Nouvelle tentative ce matin en supprimant la gestion des bitmaps par tableaux et en codant en dur leur noms, je crois bien qu'on ne peut pas faire plus "classique", et on a atteint la base qui permet d'expérimenter.

Les boucles qui restent sont celles qui ont été définies dans le programme exemple, j'ai juste scindé en deux, une qui attribue les bitmaps des aliens, et l'autre ceux des missiles, mais je ne vois pas de raison pour que le fonctionnement change à cause de cette modif.

Dans le programme exemple il n'y avait pas de cyclesprite, l'auteur n'avait donc pas prévu cette option , peut-être qu'il s'y serait pris autrement s'il voulait faire du cyclesprite.

Le nouveau listing "base de travail" :
Code VB :
 
'recherches sur sprites avec plusieurs bitmaps pour animation
'on ne génère plus les bitmaps des sprites
'on utilise des bitmaps existants, et on a aussi abandonné
'la gestion des bitmaps par des tableaux

 'nomainwin
'(inspiration : écran MSX screen8, 256*212 pixels, 256 couleurs, c'est juste pour l'ambiance)
'taillepix=4 'nombre de pixels d'aujourd'hui pour representer un pixel d'antan
'largeurs8=256*taillepix
'hauteurs8=212*taillepix
largeurs8=800
hauteurs8=600
 
WindowWidth  = largeurs8
WindowHeight = hauteurs8
UpperLeftX   = (DisplayWidth-WindowWidth)/2
UpperLeftY   = (DisplayHeight-WindowHeight)/2
graphicbox #w.g, 0,0,largeurs8,hauteurs8
open "Invaders" for graphics_nf_nsb as #w
#w "trapclose [quit]"
 
[initialise]
    x = 1
    y = 2
    adir = -10        'alien direction
    aspeed = 1.01     'alien acceleration
    base = 540        'base line of gun
    dim bullet(6,2)   'bullet x,y
    dim alien(6,2)    'alien x,y
    dim nombmp$(4)    'dimensionné au nombre de bitmaps générés

'définir le décor
'box background
for i = 0 to 150
    j = 256 - i
    #w.g "down ; backcolor ";j/3;" ";j/3;" ";j/3
    #w.g "color ";j/3;" ";j/3;" ";j/3
    #w.g "place ";i;" ";i
    #w.g "boxfilled ";largeurs8 - i;" ";hauteurs8 - i
next
 
'stars
for n = 1 to 100
    c = int(rnd(0)*255)
    #w.g "color ";c;" ";c;" ";c;" ; set ";150+rnd(0)*largeurs8-150;" ";150+rnd(0)*hauteurs8-150
next
#w.g "getbmp bak 0 0 ";largeurs8;" ";hauteurs8
#w.g "background bak";
 
 
'chargement des bitmaps
loadbmp "alien0","alien0.bmp"
loadbmp "alien1","alien1.bmp"
loadbmp "alien2","alien2.bmp"
loadbmp "missile","missile.bmp"
 
'lie les bitmaps "alien" aux sprites "alienw"
for n = 1 to 6
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw";str$(n);" alien0 alien1 alien2"
    #w.g "cyclesprite alienw";str$(n);" 1"
next
 
'lie le bitmap "missile" au sprite "bullet
for n = 1 to 6
    bullet(n,x) = 400
    bullet(n,y) = base
    #w.g "addsprite bullet";str$(n);" missile"
next
 
 
'start the keyboard checking event
#w.g "when mouseMove [track]"
#w.g "when leftButtonUp [fire]"
#w.g "setfocus"
 
 
' now start the timer to repeatedly call the drawing loop
timer 56, [drawingloop]
'timer 200, [drawingloop]

'now sit and wait
wait
 
 
[drawingloop]
    for n = 1 to 6
 
        'move the bullets
        if bullet(n,y) = 540 then
            bullet(n,x) = gunX
        else
            bullet(n,y) = bullet(n,y) -10
            for c= 1 to 6
                'check for collision
                #w.g, "spritecollides alienw";str$(c);" list$"
                if left$(list$,6) = "bullet" then
                    'playwave "media\bump.wav",async
                    a = val(mid$(list$,7,1))
                    bullet(a,x) = gunX
                    bullet(a,y) = base
                    alien(c,y) = 600
                    list$ = ""
                end if
            next
            if bullet(n,y) < -40 then bullet(n,y) = base : bullet(n,x) = gunX
        end if
 
        'move the aliens
        alien(n,x) = alien(n,x) + adir
        if alien(n,x) < 0 or alien(n,x) > 760 then bounce=1
 
 
        'place the sprites and draw
        #w.g "spritexy bullet";str$(n);" ";bullet(n,x);" ";bullet(n,y)
        #w.g "spritexy alienw";str$(n);" ";alien(n,x);" ";alien(n,y)
        #w.g "cyclesprite alienw";str$(n);" 1"
        #w.g "drawsprites"
 
    next
 
    'if we hit a wall bounce
    if bounce then
        bounce = 0
        adir = adir * -1
        adir = adir*aspeed
        for m = 1 to 6
            alien(m,y) = alien(m,y)+20
        next
    end if
    wait
 
 
    [fire]
    'find the first free bullet and launch it
    for b = 1 to 6
        if bullet(b,y)=base then
            bullet(b,y) = base-1
            exit for
        end if
    next
    wait
 
    [track]
    'keep the launch pad lined up with the mouse
    gunX = MouseX-20
    wait
 
    [quit]
    timer 0
    unloadbmp "bak"
    unloadbmp "alien0"
    unloadbmp "alien1"
    unloadbmp "alien2"
    unloadbmp "missile"
 
    close #w
 
    end
 


Et son zip contenant tout ce qu'il faut :
shoot em up version bitmapbis
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 09/11/2020 à 10h04

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Pour diminuer le nombre de variables qui pourraient être inappropriées, j'ai remplacé chez moi, dans le listing ci-dessus, la section :
Code VB :
 
'lie les bitmaps "alien" aux sprites "alienw"
for n = 1 to 6
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw";str$(n);" alien0 alien1 alien2"
    #w.g "cyclesprite alienw";str$(n);" 1"
next
 


par :
Code VB :
 
'lie les bitmaps "alien" aux sprites "alienw"
'for n = 1 to 6
    n=1
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw1 alien0 alien1 alien2"
    #w.g "cyclesprite alienw1 1"
 
    n=n+1
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw2 alien0 alien1 alien2"
    #w.g "cyclesprite alienw2 1"
 
    n=n+1
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw3 alien0 alien1 alien2"
    #w.g "cyclesprite alienw3 1"
 
    n=n+1
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw4 alien0 alien1 alien2"
    #w.g "cyclesprite alienw4 1"
 
    n=n+1
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw5 alien0 alien1 alien2"
    #w.g "cyclesprite alienw5 1"
 
    n=n+1
    alien(n,x) = 200+70*n
    alien(n,y) = 0
    #w.g "addsprite alienw6 alien0 alien1 alien2"
    #w.g "cyclesprite alienw6 1"
'next


Rien de changé, toujours que le premier bitmap qui s'affiche et pas les autres.

En mode debug, et je ne sais pas si c'est seulement de l'ordre de l'artifact, mais on voit bien l'affichage très fugace des trois bitmaps à chaque nouveau déplacement, et seulement quand on bouge la souris.

Tu avais raison, sur l'autre fil, on s'achemine vers un dépannage qui sort du cadre de la discussion. Mais comme on a commencé, je serais d'avis de continuer, et une fois qu'on aura trouvé la solution, je placerais le résumé dans une discussion dédiée, ce sera plus clair pour tout le monde.



Edité par Christophe Le 09/11/2020 à 10h10
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 09/11/2020 à 11h46

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Je n'ai pas encore regardé le code. A savoir que je ne suis pas féru en cyclesprite, et donc
Je mets là la procédure extraite de: http://libertybasic.fr/forum/topic-290+gamemaker.php qui fonctionne
Code VB :
 
    loadbmp "MAP", "bmp\map\";map$
    #3b.map, "drawbmp MAP 0 0"
    print #3b.map, "background MAP"
 
    sprites$ = "perso1d perso2d perso3d perso4d perso1s perso2s perso3s perso4s "+_
               "perso1q perso2q perso3q perso4q perso1z perso2z perso3z perso4z"
    for s = 1 to 16
        loadbmp word$(sprites$,s), "bmp\"+word$(sprites$,s)+".bmp"
    next
    #3b.map, "addsprite perso1 perso1z perso2z perso3z perso4z"  'création des 4 sprites pour chaque futures direction de déplacement...
    #3b.map, "addsprite perso2 perso1d perso2d perso3d perso4d"
    #3b.map, "addsprite perso3 perso1s perso2s perso3s perso4s"
    #3b.map, "addsprite perso4 perso1q perso2q perso3q perso4q"
 
    for SpriteCourant = 1 to 4
        #3b.map, "spritexy perso";SpriteCourant;" ";pCX*lc;" ";pCY*lc   'place tous les sprites du personnage là.
        #3b.map, "cyclesprite perso";SpriteCourant;" 1"
        #3b.map, "spritevisible perso";SpriteCourant;" off"
    next
    SpriteCourant = 3
    #3b.map, "spritevisible perso";SpriteCourant;" on"
    #3b.map, "drawsprites"   'affiche le sprite courant.
wait
 
 


EDIT: Avec le 09/11/2020 à 09h42
cyclesprite a l'air de fonctionner, mais un peu trop rapide.
____________________
Roro

   
Le 09/11/2020 à 16h59

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Suite du: 11h46
Et voici la procédure de déplacement:
Code VB :
 
    mX = MouseX
    mY = MouseY
    icp = 6   'incrément de déplacement en pixels.
    #3b.map, "spritexy? perso";SpriteCourant;" cursX cursY"   'coordonnées actuelles du personnage   <------
    dir = direction(cursX,cursY,mX,mY)    'fonction qui donne la direction du déplacement... destinée à utiliser le sprite adéquat. (gauche droite)
    for s=1 to 4 : #3b.map, "spritevisible perso";s;" off" : next
    SpriteCourant = dir
    #3b.map, "spritexy perso";SpriteCourant;" ";cursX;" ";cursY
    #3b.map, "spritevisible perso";SpriteCourant;" on"  'ne montre QUE le sprite concerné par la direction choisie.
    do
        #3b.map, "spritexy? perso";SpriteCourant;" cursX cursY"
        cx = int(cursX/lc)+1             'position du sprite exprimé en n° de case pour la variable tableau
        cy = int(cursY/lc)+1
        if cx+dpx(dir)>0 and cx+dpx(dir)<ncx and cy+dpy(dir)>0 and cy+dpy(dir)<ncy and cas$(cx+dpx(dir),cy+dpy(dir)) = "x" then
            nx = cursX + dpx(dir)*icp
            ny = cursY + dpy(dir)*icp
            #3b.map, "spritexy perso";SpriteCourant;" ";nx;" ";ny      'cheminement du sprite... tranquilou...
            #3b.map, "drawsprites"
 
____________________
Roro

   
Le 10/11/2020 à 19h39

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Il est sympa, ton GameMaker, avec ses maisons de western en papier. Trop mignon ;) L'animation fonctionne. J'ai utilisé le programme trouvé dans la discussion que tu avais mise en lien.

Citation:
EDIT: Avec le 09/11/2020 à 09h42
cyclesprite a l'air de fonctionner, mais un peu trop rapide.

Si c'est moins rapide et dans le bon ordre quand tu augmente la valeur du timer, c'est tout bon. Mais chez moi ça marche pas.

Il y a aussi l'exemple SPRTTST2.BAS (pour JustBasic2) qui, chez moi, fonctionne. Je fournis le listing pour la discussion, mais il faut charger le programme à partir du dossier des exemples si on veut qu'il charge les bitmaps :
Code VB :
 
    loadbmp "smiley1", "sprites\smiley1.bmp"
    loadbmp "smiley2", "sprites\smiley2.bmp"
    loadbmp "smiley3", "sprites\smiley3.bmp"
    loadbmp "smiley4", "sprites\smiley4.bmp"
    loadbmp "landscape", "sprites\bg1.bmp"
    WindowHeight = 300
    WindowWidth = 400
    'graphicbox #wg, 0, 0, 400, 300
    open "sprite test" for graphics_nf_nsb as #wg
    print #wg, "background landscape";
    print #wg, "addsprite smiley smiley1 smiley2 smiley3 smiley4";
    print #wg, "addsprite smiler smiley1 smiley2 smiley3 smiley4";
    print #wg, "addsprite smiled smiley1 smiley2 smiley3 smiley4";
    print #wg, "addsprite smiles smiley1 smiley2 smiley3 smiley4";
    print #wg, "cyclesprite smiley 1 once"
    print #wg, "cyclesprite smiler 1"
    print #wg, "cyclesprite smiled 1"
    print #wg, "cyclesprite smiles 1"
 
    timer 50, [cycle]
 
[cycle]
    x = x + 2
    print #wg, "spritexy smiley "; x; " "; x
    print #wg, "spritexy smiler "; 100-x; " "; x
    print #wg, "spritexy smiled "; 100-x; " "; 100-x
    print #wg, "spritexy smiles "; x; " "; 100-x
    print #wg, "drawsprites";
    print #wg, "spritecollides smiley list$"
    if list$ > "" then print #wg, "cyclesprite smiley 1 once"
    if x >= 100 then timer 0
    wait
 


Apparemment, il n'y a pas trente-six possibilités : il suffirait de placer ce CYCLESPRITE après avoir créé le sprite avec ADDSPRITE, puis de lancer l'animation avec TIMER. J'ai vu que tu avais, en plus, mis un cyclesprite dans la boucle d'animation sur ton programme. J'ai essayé les deux possibilités sur le mien, et jusqu'à présent, sans succès. Je serais d'avis de laisser tomber CYCLESPRITE pour le moment et de continuer la conception du programme.

J'ai dans l'idée un scrolling vertical, et donc un fond qui descend par pas de 8 pixels d'antan (pour rappel, le pixel d'antan est le pixel d'aujourd'hui multiplié par taillepix, et c'est ce qui te valais l'affichage trop grand pour ton écran). Cela s'annonce pas trop compliqué graphiquement, avec un gros sprite ou un gros bitmap, mais je ne vois pas comment faire réagir le vaisseau spatial à ce décor (une collision avec le décor=un crash, et il ne doit pas y avoir de crash sur les parties transparentes du décor). je n'ai pas vu d'instruction dédiée, je suppose qu'il faut la programmer nous-même.
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 11/11/2020 à 01h22

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Pour le scrolling vertical il suffit d'une map du double en hauteur et qui boucle.
Pourquoi veut-tu faire une collision avec la map (décor) ? Les collisions c'est entre des sprites.
Plus de bla bla demain, parce que là, c'est la nuit.

EDIT:
Citation:
Mais chez moi ça marche pas.

Paye toi un pc d'occase, dans les "Cash Converters" on en trouve à vraiment pas cher.
____________________
Roro

   
Le 11/11/2020 à 12h34

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Un PC sous Windows même à pas cher, c'est "niet" et non négociable ;) Et tu viens de me rappeler que j'ai aussi un vieil eee-PC de vacance, tournant sous XP et toujours fonctionnel...

On ajoute un plus au jeu en plaçant un décor mobile qu'il ne faut pas toucher. J'ai de mémorables souvenirs dans lesquels l’inénarrable mauvaise foi des joueurs ne peut être retenue en totalité : le décor avançait de plusieurs pixels à la fois (probablement 8), donc il suffisait qu'on soit à moins de 8 pixels du décor pour qu'on se le prenne dans la figure à l'animation d'après. Donc paf ! crashé. Même si, optiquement, il n'y avait pas contact l'instant d'avant. Que de bras levés au ciel, d'indignation et de grands cris devant une assistance rigolarde "Mais ça passait ! j'te jure que ça passait !"... Même problème avec les pixels transparents du décor, placés pour faire plus "naturel". Sacrés souvenirs ;)

Ici, comme d'habitude, je suis dans l'expérimentation : j'ai vu des exemples de scrolling sur le forum et dans les programmes exemples et je ne suis pas inquiet à ce niveau-là. Par contre, la difficulté sera d'interroger assez rapidement une matrice pour savoir si le vaisseau du joueur est au dessus d'une zone libre, ou pas, et de brancher sur une routine de crash si nécessaire. Je serais déjà content si "ça marche", et on verra après pour la jouabilité.

Je vais voir si j'ai deux minutes cet aprèm pour un premier jet.
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 11/11/2020 à 16h55

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
pour savoir si le vaisseau du joueur est au dessus d'une zone libre, ou pas

Ah mais tu veux faire des montagnes à éviter ?
Va falloir y mettre des courbes de niveaux (pour l'altitude).
Mais là tu t'oriente vers un simulateur de vol.
____________________
Roro

   
Le 15/11/2020 à 12h46

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Plus tard, le simulateur de vol ;) j'en suis toujours avec mon jeu façon "eighties"

J'ai créé et animé le décor sur une trentaine d'étapes, ça reste très basique et expérimental.

Je m'arrête là pour aujourd'hui, il y a encore deux-trois petits trucs qui ne vont pas dans l'animation, mais il y a d'autres choses à faire dans la vraie vie, et globalement on avance.

Je n'ai pas touché au mouvements des sprites et à leur limites.

Le programme s'arrête tout seul lorsqu'il atteint le nombre d'étapes d'animation du décor.

La transition entre deux étapes de déplacement du décor est "saccadée", comme s'il y avait un écran noir qui s'affichait alors qu'il n'en faudrait pas.

zx1 et zy1 pourraient être remplacés par zéro : je les ai mis en place pour créer le dessin en dehors des parties visibles de la fenêtre, pensant que ça irait plus vite à dessiner et que ça ne produirait pas d'artefact visible pendant l'animation. Mais ça n'a pas marché, et je les ai initiés à zéro plutôt que de les remplacer par zéro.

Le listing : (j'ai mis le taillepix=2 pour les petits écrans ;)

Code VB :
 
'mise en place du décor : fait
'déplacement du décor : en cours de finition
'position du vaisseau dans la fenetre : à faire
'écartement proportionnel des sprites : à faire

'Peu à peu adapté à partir d'un programme de Rod (rodbird) trouvé dans les exemples

nomainwin
 
'(inspiration : écran MSX screen8, 256*212 pixels, 256 couleurs, c'est juste pour l'ambiance)
taillepix=2 'nombre de pixels d'aujourd'hui pour representer un pixel d'antan
largeurs8=256*taillepix
hauteurs8=212*taillepix
 
WindowWidth  = largeurs8
WindowHeight = hauteurs8
UpperLeftX   = (DisplayWidth-WindowWidth)/2
UpperLeftY   = (DisplayHeight-WindowHeight)/2
graphicbox #w.g, 0,0,largeurs8,hauteurs8
open "Invaders" for graphics_nf_nsb as #w
#w "trapclose [quit]"
 
[initialise]
    x = 1
    y = 2
    adir = -10        'alien direction
    aspeed = 1.01     'alien acceleration
    base = 540        'base line of gun
    dim bullet(6,2)   'bullet x,y
    dim alien(6,2)    'alien x,y
    dim nombmp$(4)    'dimensionné au nombre de bitmaps générés
    numbmp=0          'numéro du bitmap actuellement défini
    rdn=20            'nombre de tours d'animation entre deux re-dessins du décor
    rda=0           'tour actuel d'animation depuis le dernier re-dessin
    rdo=0           'nombre de redessins depuis l'origine

'création des bitmaps à l'ancienne, et des sprites d'aujourd'hui
'(matrices de 8x8 pixels, 0=pixel éteint, 1=pixel allumé)
[alien_anim0]
    data "00111100"
    data "01000010"
    data "01111110"
    data "10000001"
    data "11000011"
    data "00111100"
    data "01000010"
    data "10000001"
    restore [alien_anim0]:couleur$="red":nom$="alien0":gosub [creer_bitmap]
    numbmp=numbmp+1
 
[alien_anim1]
    data "00111100"
    data "01011010"
    data "01111110"
    data "10000001"
    data "11111111"
    data "00100100"
    data "01000010"
    data "01000010"
    restore [alien_anim1]:couleur$="cyan":nom$="alien1":gosub [creer_bitmap]
    numbmp=numbmp+1
 
[alien_anim2]
    data "00111100"
    data "01000010"
    data "01111110"
    data "10000001"
    data "11000011"
    data "00111100"
    data "00100100"
    data "00100100"
    restore [alien_anim2]:couleur$="green":nom$="alien2":gosub [creer_bitmap]
    nom$=nombmp$(0)+" "+nombmp$(1)+" "+nombmp$(2)
 
    for n = 1 to 6
        alien(n,x) = n*30*taillepix
        alien(n,y) = 0
        #w.g "addsprite alien";str$(n);" ";nom$
        '#w.g "cyclesprite alien";str$(n);" 1"
    next
    numbmp=numbmp+1
 
[missiles]
    data "00010000"
    data "00010000"
    data "00010000"
    data "00010000"
    data "00111000"
    data "01111100"
    data "00010000"
    data "00010000"
    restore [missiles]:couleur$="yellow":nom$="missile":gosub [creer_bitmap]
    nom$=nombmp$(3)
    for n = 1 to 6
        bullet(n,x) = largeurs8/2
        bullet(n,y) = base
        #w.g "addsprite bullet";str$(n);" ";nom$
    next
    numbmp=numbmp+1
 
[vaisseau]
'à définir

[explosion]
'à définir, plusieurs bitmaps

[decor]
    'largeur=256/8=32
    'hauteur=212/8=26.5
    'on va spécifier 24 lignes pour le décor, ce qui laisse une ligne et demi pour les stats
    'nombre de cases : largeur*hauteur=24*32=768
    nbcases=768
    npas=27
 
    'écran de départ, affichage de haut en bas
    data "10000000000000000000000000000001" '1
    data "10000000000000000000000000000001"
    data "10000000000000000111100000000001"
    data "11000000000000001111100000000001"
    data "11110000000011111111111000000001" '5
    data "11000000001111111111111111000001"
    data "10000000000011111111111000000001"
    data "10000000000000000111100000000001"
    data "11000000000000000000000000000001"
    data "11100000000000000000000000001111" '10
    data "11111000000000000000000000111111"
    data "11111110000000000000000011111111"
    data "11111111100000000000011111111111"
    data "11111111000000000000111111111111"
    data "11111100000000000111111111111111" '15
    data "11111000000000000111111111111111"
    data "11111000000000001111111001111111"
    data "11111000000000001111110000011111"
    data "11110000000000011111111110000011"
    data "11111000000000001111111110000111" '20
    data "11111100000000000111111000000111"
    data "11111110000000000000000000001111"
    data "11111111000000000000000000111111"
    data "11111111111000000000000111111111" '24

    'lignes supplémentaires,
    'chaque ligne supplémentaire apparaitra en haut de l'écran
    'et poussera les lignes déjà affichées vers le bas
    data "10000000000000000011111110000001"
    data "10000000000000000010000010000001"
    data "10000000000000000011000110000001"
    data "10000000000000000011111110000001"
    data "10000000000000000001111100000001"
    data "10000000000000000000111000000001"
    data "10001000000000000000010000000001"
    data "10011100000000000000000000000001"
    data "10001111000000000000000000000001"
    data "10000001110000000011111110000001"
    data "10000000011000000010000010000001"
    data "10000000000000000011000110000001"
    data "10000000000000000011111110000001"
    data "10000000000000000001111100000001"
    data "10000000000000000000111000000001"
    data "10000001110000000000010000000001"
    data "10000111100000000000000000000001"
    data "10011111111100000000000000000001"
    data "10000111000000000011111110000001"
    data "10000000000000000010000010000001"
    data "10000000000000000011000110000001"
    data "10000000000000000011111110000001"
    data "10000011000000000001111100000001"
    data "10000111100000000000111000000001"
    data "10000011000000000000010000000001"
    data "10000000000000000000000000000001"
    data "10000000000000000000000000000001"
 
    dim ecran(nbcases)
    restore [decor]
    tr=0
    for a=1 to 24
        read a$
        for b=1 to 32
            ecran(tr)=val(mid$(a$,b,1))
            tr=tr+1
        next
    next
 
'dessin initial du fond du jeu
    zx1=0
    zy1=0
    zx2=zx1+largeurs8
    zy2=zy1+hauteurs8
    zyetoile=zy2+npas*taillepix
 
    'fond noir
    #w.g, "cls"
    #w.g, "down"
    #w.g, "backcolor black;color black"
    #w.g "place ";zx1;" ";zy1
    #w.g "boxfilled ";zx2;" ";zy2+npas*taillepix
 
    'étoiles
    #w.g "size ";taillepix
    for n = 1 to 100
        c = int(rnd(0)*255)
        r=int(rnd(0)*20)
        v=int(rnd(0)*20)
        b=int(rnd(0)*20)
        #w.g "color ";c+r;" ";c+v;" ";c+b
        #w.g "set ";zx1+rnd(0)*largeurs8;" ";zy1+rnd(0)*zyetoile
    next
 
    'étoiles placées en bitmap pour utilisation dans les prochaines animations
    #w.g "getbmp etoiles ";zx1;" ";zy1;" ";largeurs8;" ";zyetoile
 
    'terrain, dessiné "par dessus" les étoiles
    c$="brown"
    #w.g, "backcolor ";c$;" "
    #w.g, "color ";c$
    carre8=8*taillepix
 
    #w.g "size 1"
    for a=0 to nbcases-1
        if ecran(a)=1 then
            x1=zx1+a mod 32*carre8
            y1=zy1+int(a/32)*carre8
            x2=x1+carre8
            y2=y1+carre8
            #w.g "place ";x1;" ";y1
            #w.g "boxfilled ";x2;" ";y2
        end if
    next
 
    #w.g "segment decor"
    'on capture l'écran portant les étoiles et le terrain, et on en fait un bitmap
    #w.g "getbmp bak ";zx1;" ";zy1;" ";largeurs8;" ";hauteurs8
 
    'qu'on place en fond d'écran
    #w.g "background bak";
    'fin de la création initiale du décor

 
'start the keyboard checking event
    #w.g "when mouseMove [track]"
    #w.g "when leftButtonUp [fire]"
    #w.g "setfocus"
 
 
' now start the timer to repeatedly call the drawing loop
    timer 56, [drawingloop]
    'timer 200, [drawingloop]

'now sit and wait
wait
 
 
'****************** sous-programmes *****************

[creer_bitmap]
    #w.g, "down"
 
    'préparer le fond du sprite
    #w.g, "backcolor black;color black"
    #w.g, "place 0 0 ; boxfilled ";8*taillepix;" ";16*taillepix
 
    'pour chaque ligne de datas,
    '   les "0" deviendront des pixels transparents du sprite,
    '   les "1" deviendront des pixels visibles

    for ligne=0 to 7
        read ligne$
 
        for colonne=0 to 7
            if mid$(ligne$,colonne+1,1)="1" then
                'le point est opaque
                'il apparait en noir sur le masque
                'et dans la couleur du sprite sur le sprite
                colmask$="black"
                colspr$=couleur$
            else
               'le point est transparent
                'il apparait en blanc sur le masque
                'et en noir sur le sprite
                colmask$="white"
                colspr$="black"
            end if
 
            'placer le point sur le masque
            p1x=colonne*taillepix
            p1y=ligne*taillepix
            p2x=p1x+taillepix
            p2y=p1y+taillepix
            #w.g, "color ";colmask$
            #w.g, "backcolor ";colmask$
            #w.g, "place ";p1x;" ";p1y;"; boxfilled ";p2x;" ";p2y
 
            'placer le point sur le sprite
            p3x=p1x
            p3y=p1y+8*taillepix
            p4x=p3x+taillepix
            p4y=p3y+taillepix
            #w.g, "color ";colspr$
            #w.g, "backcolor ";colspr$
            #w.g, "place ";p3x;" ";p3y;"; boxfilled ";p4x;" ";p4y
        next
    next
 
    'créer le bitmap du futur sprite
    #w.g, "getbmp ";nom$;" 0 0 ";8*taillepix;" ";16*taillepix
    nombmp$(numbmp)=nom$
 
    #w.g, "up"
    return
 
 
[drawingloop]
    'boucle d'animation

    'faut-il dessiner le décor ?
    '   rda=tour actuel d'animation depuis le dernier re-dessin
    '   rdn=nombre de tours d'animation entre deux re-dessins du décor
    '   rdo=nombre de dessins depuis le début du jeu
    if rda=rdn then rda=0:gosub [redessine_decor] else rda=rda+1
 
 
    'gérer le déplacement des missiles et
    'et détecter leur collision avec un alien
    for n = 1 to 6
 
        'move the bullets
        if bullet(n,y) = 540 then
            bullet(n,x) = gunX
        else
            bullet(n,y) = bullet(n,y) -10
            for c= 1 to 6
                'check for collision
                #w.g, "spritecollides alien";str$(c);" list$"
                if left$(list$,6) = "bullet" then
                    'playwave "media\bump.wav",async
                    a = val(mid$(list$,7,1))
                    bullet(a,x) = gunX
                    bullet(a,y) = base
                    alien(c,y) = 600
                    list$ = ""
                end if
            next
            if bullet(n,y) < -40 then bullet(n,y) = base : bullet(n,x) = gunX
        end if
 
        'mdéplacer les aliens
        alien(n,x) = alien(n,x) + adir
        if alien(n,x) < 0 or alien(n,x) > 760 then bounce=1
 
 
        'faire apparaitre les sprites à leurs nouvelles positions
        #w.g "spritexy bullet";str$(n);" ";bullet(n,x);" ";bullet(n,y)
        #w.g "spritexy alien";str$(n);" ";alien(n,x);" ";alien(n,y)
        #w.g "cyclesprite alien";str$(n);" 1"
        #w.g "drawsprites"
 
    next
 
    'Si les aliens touchent le bord de l'écran
    '   on inverse leur sens de déplacement
    '   et on les fait descendre de 20 pixels
    if bounce then
        bounce = 0
        adir = adir * -1
        adir = adir*aspeed
        for m = 1 to 6
            alien(m,y) = alien(m,y)+20
        next
    end if
    wait
 
 
 
[fire]
    'find the first free bullet and launch it
    for b = 1 to 6
        if bullet(b,y)=base then
            bullet(b,y) = base-1
            exit for
        end if
    next
    wait
 
[track]
    'keep the launch pad lined up with the mouse
    gunX = MouseX-20
    wait
 
[redessine_decor]
 
    'rdo=nombre de dessins du décor depuis le début du jeu
    'si on a atteint le nombre de dessins prévus on arrête le jeu
    rdo=rdo+1
    if rdo>npas then gosub [quit]
 
    'dans le tableau de l'écran, on fait descendre toutes les lignes
    'de terrain (32 cases par ligne d'écran)
    for a=nbcases-1 to 32 step -1
        ecran(a)=ecran(a-32)
    next
 
    'on lit la ligne de terrain suivante
    read a$
 
    'qu'on intègre en première place dans le tableau de l'éran
    for a=0 to 31
        ecran(a)=val(mid$(a$,a+1,1))
    next
 
    'et on redessine le décor :
    'afficher les étoiles un pixel plus bas que précédemment
    '   rdo=nombre de re-dessins depuis le début du jeu
    #w.g, "cls"
 
    'fond noir
    #w.g, "cls"
    #w.g, "down"
    #w.g, "backcolor black;color black"
    #w.g "place ";zx1;" ";zy1
    #w.g "boxfilled ";zx2;" ";zy2
 
    'dessiner les étoiles
    #w.g "drawbmp etoiles 0 ";0+(rdo+npas)*taillepix
 
    'afficher le terrain par dessus
    c$="brown"
    #w.g, "backcolor ";c$;" "
    #w.g, "color ";c$
    carre8=8*taillepix
 
    #w.g "delsegment decor"
    #w.g "size 1"
    for a=0 to nbcases-1
        'si la case du tableau correspond à du terrain
        if ecran(a)=1 then
            x1=zx1+a mod 32*carre8
            y1=zy1+int(a/32)*carre8
            x2=x1+carre8
            y2=y1+carre8
            #w.g "place ";x1;" ";y1
            #w.g "boxfilled ";x2;" ";y2
        end if
 
    next
    #w.g "segment decor"
 
    'on re-créée le bitmap de fond
    #w.g "getbmp bak ";zx1;" ";zy1;" ";largeurs8;" ";hauteurs8'-npas

    'qu'on réattribue au fond
    '#w.g "drawbmp bak 0 0"
    #w.g "background bak";
 
    return
 
[quit]
    timer 0
    #w.g "delsegment decor" 'rend la mémoire occupée par le dessin du décor
    unloadbmp "etoiles"
    unloadbmp "bak"
 
    for a=0 to numbmp-1
        unloadbmp nombmp$(a)
    next
 
    close #w
 
    end
 
 




Edité par Christophe Le 15/11/2020 à 12h51
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 15/11/2020 à 18h49

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Ah mhah tu es passé d'un extrême dans l'autre pour les dimensions.

Mais purée pourquoi tu n'a pas mis ta floppée de data en fichier, tu n'aime pas les fichiers ?
Et pourquoi tu redessine le décor ? C'est de ça que proviennent les clignotements.
Si tu mets le décor en tant que background il reste permanent derrière les sprites.
____________________
Roro

   
Le 15/11/2020 à 23h06

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Tiens, le forum vient de me sauver la mise : un météore a traversé l'environnement de mon disque dur, et les remous quantiques qu'il a engendré ont fait un sac de noeuds dans les amarres: mon JB ne voulait plus charger le fichier, "os error : systeme non prêt", qu'il répétait. Un coup de copier-coller, du listing du forum à l'éditeur JB, puis sauvegarde "par dessus" le fichier malade, et le voilà restauré. J'avais toujours la version d'avant, mais il aurait fallu que je réécrive beaucoup de choses...

Citation:
Ah mhah tu es passé d'un extrême dans l'autre pour les dimensions.

Dimensions de l'écran, ou dimensions du pavé de datas ? Pour les datas, c'est juste un "petit" bloc. Le jeu une fois opérationnel devrait durer trois ou quatre minutes par tableau, avec cinq ou six tableaux différents (j'ai pas d'autre mots à l'esprit que ce "tableau" mais j'en trouve pas d'autres : habituellement à la fin d'un tableau on a un boss et une fois qu'on a vaincu le boss on entame le tableau suivant). Donc au total, au moins un quart d'heure, au rythme d'une ligne de data toutes les demi-seconde, 15*60*2=1800 lignes de datas dans le programme pour les décors.

Citation:
Mais purée pourquoi tu n'a pas mis ta floppée de data en fichier, tu n'aime pas les fichiers ?

Si on part sur 3 minutes de jeu par tableau, ça me fait 360 lignes de data. Sachant qu'une donnée dans une ligne data du décor représente 8*8=64 pixels, et qu'il y a 32 données par ligne, cela nous fait 32*64=2048 pixels par ligne de data, et comme il y a 360 lignes de datas, on obtient un bitmap de fond de 2048*360=737 280 pixels, ce qui, pour une largeur de 256 pixels, donnerait une hauteur de 2880 pixels, c'est tout à fait à la portée de notre matériel.

Les datas, c'est pour travailler à l'ancienne, parce que dans l'ancien temps, il fallait avoir un lecteur k7 pour sauvegarder et lire un fichier, que ça prenait une plombe pour retrouver et charger un fichier - quand ça marchait - et que, dans ces conditions-là, le data, c'était bien commode.

La raison accessoire est que ça me permet de travailler sur la carte du jeu directement dans le programme, sans avoir à ouvrir un fichier supplémentaire à coté.

Il y a quarant ans de cela, en regardant les jeux vidéo, on se doutait que ce qui défilait sur l'écran n'étaient pas des lignes, des cercles et des points, mais une matrice de dessins prédéfinis qu'on faisait avancer d'un pas à chaque fois, et c'est le but ici : que le décor soit généré par une matrice qu'on fait avancer. Or, le mode de fonctionnement de JB/LB demande qu'on utilise un bitmap de fond. Il faut donc que mes datas soient converties en bitmap au fur et à mesure : si j'utilise directement un bitmap de 256*2880 pixels, je ne suis plus dans les années 80...

Pour l'instant, chaque case de la matrice ne contient que des 0 et des 1 : 0 il n'y a rien, 1 c'est le terrain. Comme c'est vraiment très "carré" je vais définir pour la même case plusieurs versions de dessin qui permettront d'arrondir le dessin final, pour que ce soit plus esthétique, et il me faudra au moins 9 valeurs, 10 si on compte la case vide, et qui seront codées de 0 à 9 dans la ligne de data.

Citation:

Et pourquoi tu redessine le décor ? C'est de ça que proviennent les clignotements.
Si tu mets le décor en tant que background il reste permanent derrière les sprites.

Parce que pour le moment c'est tout ce que j'ai trouvé de mieux pour convertir mes datas en bitmap au fil de l'exécution. "background" serait une instruction à n'appeler qu'une fois ?
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 16/11/2020 à 09h08

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
"background" serait une instruction à n'appeler qu'une fois ?

"background" Est Obligatoire pour utiliser les sprites.
Citation:
je ne suis plus dans les années 80

Je ne vois vraiment pas l'intérêt de se compliquer la vie.
La complexité que tu mets à la génération risque de manquer au "game design".
____________________
Roro

   
Le 16/11/2020 à 15h56

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Citation:
Je ne vois vraiment pas l'intérêt de se compliquer la vie.
La complexité que tu mets à la génération risque de manquer au "game design".

Oui, mais là, c'est moi qui suis aux commandes ;)

Et puis datas ou fichiers, on s'en moque, du moment que ça me fait travailler les sprites et les background pour que je finisse enfin par savoir comment ça marche, et là, je te ferais un jeu au design "eighties" mais à la mécanique bien actuelle. Mais pour le moment, ici, on reste dans le thème fixé, avec une complexité qu'on va essayer de garder abordable.

Citation:
"background" Est Obligatoire pour utiliser les sprites.
J'ai bien vu, mais on l'appelle quand, et comment on le fait bouger sans ce flash noir entre chaque mouvement ?
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 16/11/2020 à 20h06

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
[quote]mais on l'appelle quand, et comment on le fait bouger[/quote
Le backgrouwnd on le met au début et il ne bouge pas; mais on peut le changer en cours de prog, (sans clignotement)
Pour bouger le fond soit on fait tout en bmp, soit on fait un sprite "décor" et on joue sur les "spritevisible on/off"
Mais c'est possible qu'en LB il y ait du "backgroundMove"

Edit: On peut aussi faire une dizaines de background et les afficher en séquence bouclée pour faire comme un défilement
____________________
Roro

   
Le 17/11/2020 à 22h39

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Citation:
Le background on le met au début et il ne bouge pas; mais on peut le changer en cours de prog, (sans clignotement)

Je pense aussi que le clignotement ne vient pas du background, mais du temps d'affichage du bitmap des étoiles, et de calcul du dessin du terrain. Et cela, sur une machine moderne, donc le projet va probablement en rester là, cette animation étant la pièce maitresse du projet.

Ceci dit, as-tu déjà essayé de dessiner en dehors de la fenêtre, et de capturer ce dessin en bitmap ? Je n'ai pas réussi mais j'étais persuadé qu'on pouvait le faire, aurais-je rêvé ou confondu avec un autre langage ?

L'avantage espéré : dessiner en dehors de la fenêtre permettrait de ne pas afficher la construction du fond durant la boucle d'animation des sprites, mais seulement son résultat. Et là, il n'y aurait plus de clignotement, et je pourrais même répartir la création du dessin sur plusieurs boucles.

(j'ai commencé à regarder ton Croise-Mots, mais il est trop tard ce soir et je continuerais demain)

Bonne nuit !



Edité par Christophe Le 17/11/2020 à 22h44
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia7+ Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Jeux » Shoot'em up '80 et petits problèmes à résoudre  

 |  |

1 Utilisateur en ligne : 0 Administrateur, 0 Modérateur, 0 Membre et 1 Visiteur
Utilisateur en ligne : Aucun membre connecté
Répondre
Vous n'êtes pas autorisé à écrire dans cette catégorie