Forum Liberty Basic France

Jeux » Shoot'em up '80 et petits problèmes à résoudre
Le 17/11/2020 à 22h39

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Reprise du message précédent

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

   
Le 17/11/2020 à 23h28

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
dessiner en dehors de la fenêtre

Peut-être en construisant le bmp dans un fichier (comme tu a construit une wav si mes souvenirs sont bons).
Normalement un fichier bmp c'est des données brutes, ça doit être faisable.

EDIT: Ah ben non, après vérification, ça ne ressemble à rien.
____________________
Roro

   
Le 19/11/2020 à 11h21

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Je n'avais pas pensé à cette idée, d'autant plus que j'ai déjà affiché des bitmaps en lisant leurs octets. C'était il y a très longtemps avec QBasic et j'avais inversé les couleurs (le brun s'affichait bleu) mais ça marchait. Que de souvenirs ;)

Citation:
après vérification, ça ne ressemble à rien.

Une erreur quelque part dans le codage du bitmap, ou un bitmap correct mais mal interprété (quels sont les paramètres qu'utilise JB/LB pour définir en interne un bitmap) ?
Je vais voir si j'ai deux minutes à consacrer à cette énigme, il peut être intéressant d'approfondir.

Première question qui me vient à l'esprit et que je me pose à moi-même mais qui peut s'adresser à tout un chacun : "Est-ce qu'on peut créer ce bitmap en mémoire plutôt que sur disque ?"



Edité par Christophe Le 19/11/2020 à 11h29
____________________
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 19/11/2020 à 11h51

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
J'ai affiché dans "Notepad++" un pixel dans un bmp de 10 x10 ça n'est pas très parlant.
Dans W32dasm (désassembleur) c'est encore pire.
Et "OLLY dbg" n'en a pas voulu
Concluse: L'empirisme c'est pas l'idéal
Faudrait voir ce que ça donne en hexadec.
____________________
Roro

   
Le 20/11/2020 à 12h50

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Y'a qu'à demander ;)

Tu pourras constater que j'ai abandonné (provisoirement) ma sale manie de la compactification à outrance du listing, et qu'on a beaucoup de boucles successives et non imbriquées. En contrepartie, hé bé, il est long : le voici en zip si tu préfères : définir bitmap

J'ai conservé mon système à datas parce qu'il était déjà écrit : on aurait très bien pu le remplacer par une instruction graphique dessinant un cercle ou un carré. Mais l'avantage de la grille de pixels, c'est qu'on sait précisément quel pixel on modifie, et vérifier ensuite si, dans le fichier bitmap, la modification a bien été faite au bon endroit.

A cette heure, je ne sais pas ce qu'il y a dans les octets 54 à 65 de ce fichier

Évidemment je ne retrouve plus rien de ma doc de l'époque, aussi je me suis aidé de Format Bitmap chez CCM et Format Bitmap chez Wikipedia.

Sur mon Wine/linux, en réécrivant le fichier bitmap sur le précédent, j'obtenais des statistiques cohérentes entre le programme et mon explorateur habituel, mais fausses... Maintenant, à chaque lancement du programme, le dernier bitmap créé est effacé : le nouveau fichier bitmap est garanti tout neuf, et je trouve les bonnes données.

Ceci dit, avec ce programme, on obtient la description du bitmap quand il est dans un fichier. Il serait intéressant de savoir comment il est organisé dans la mémoire de l'ordi avant son transfert sur le disque, ET si on a une chance de l'appeler directement à partir de la mémoire : ça permettrait de faire mes dessins de fond sans être gêné par la latence d'écriture/lecture de fichier sur son disque

Le listing :
Code VB :
 
'on dessine un bitmap et on le sauve sur disque
'et on affiche les données de son fichier

'dessin du bitmap
'caractéristiques du bitmap
nomi$="lebitmap"        'nom du bitmap en mémoire
nomf$="cestlebitmap.bmp"'nom du bitmap en fichier
coul0$="1 121 251"      'deux couleurs parmi 256*256*256 possibilités
coul1$="252 122 2"
 
'effacer le fichier généré par le précédent essai
' pour éviter d'éventuelles interférences
dim info$(10, 10)
if fileExists(DefaultDir$, nomf$) then kill nomf$
 
'matrice du bitmap
[bmpmap]
    '0=pixel de couleur coul0$
    '1=pixel de couleur coul1$ 
    'autant de chaines que dy/4
    'autant de données dans la chaine que dx/4
    data "00000000"
    data "01000010"
    data "00000010"
    data "00110010"
    data "00110010"
    data "00000010"
    data "01111110"
    data "10000001"
 
'réglages du programme
nomainwin
taillepix=1             '1 pixel à l'écran tiendra 1*taillepix pixels dans le bitmap
dx=8*taillepix          'largeur du futur bitmap sur l'écran
dy=8*taillepix          'hauteur

marge=5                 'pour que le bitmap sur l'écran soit bien au milieu de la graphicbox
gx=dx+2*marge           'largeur de la graphicbox
gy=dy+2*marge           'hauteur

 
 
'dimension de la fenêtre graphique
WindowWidth  = 800
WindowHeight = 600
UpperLeftX   = (DisplayWidth-WindowWidth)/2
UpperLeftY   = (DisplayHeight-WindowHeight)/2
 
marge=5
graphicbox #w.g, 25,25,gx,gy
texteditor #w.t, 25,25+gy+25,WindowWidth-50,WindowHeight-80-gy
 
open "créer bitmap" for graphics_nf_nsb as #w
    #w.t "!font liberation mono"
    #w "trapclose [quit]"
 
    'dessin du bitmap
    #w.g, "down"
 
    restore [bmpmap]
 
    for ligne=0 to 7
        read ligne$
 
        for colonne=0 to 7
            if mid$(ligne$,colonne+1,1)="1" then col$=coul0$ else col$=coul1$
 
            'placer le point
            p1x=colonne*taillepix+marge
            p1y=ligne*taillepix+marge
            p2x=p1x+taillepix
            p2y=p1y+taillepix
            #w.g, "color ";col$
            #w.g, "backcolor ";col$
 
            if taillepix=1 then
                #w.g, "set ";p1x;" ";p1y
            else
                #w.g, "place ";p1x;" ";p1y;"; boxfilled ";p2x;" ";p2y
            end if
        next
    next
    #w.g, "up"
 
    'créer le bitmap
    #w.g, "getbmp ";nomi$;" ";marge;" ";marge;" ";dx;" ";dy
 
    'sauvegarder le bitmap sur le disque
    bmpsave nomi$,nomf$ 
 
    'ouvrir le bitmap pour en extraire les infos
    open nomf$ for input as #f
 
    'lecture à blanc pour déterminer la quantité de données
    qtoct=0
    while eof(#f)<>-1
        car$=input$(#f,1)
        qtoct=qtoct+1
    wend
    close #f
    #w.t, "** Fichier sur disque :"
    #w.t, "nom : ";nomf$
    #w.t, "taille, octets : ";qtoct
    #w.t, ""
 
    'chargement du fichier en tableau
    dim fich(qtoct)
    open nomf$ for input as #f
    for a=0 to qtoct-1
        fich(a)=asc(input$(#f,1))
    next
    close #f
 
    'affichage de l'en-tête du fichier
    #w.t, "** En-tête du fichier bitmap :"
    m$="":for a=0 to 1:m$=m$+chr$(fich(a)):next:#w.t,"nombre magique : ";m$
 
    m$="":nbre=0:exp=0
    for a=2 to 5
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"taille du fichier bitmap, octets : ";m$;" ";nbre
 
    m$="":nbre=0:exp=0
    for a=6 to 7
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"identifiant (1) de l'entité ayant créé le bitmap : ";nbre
 
    m$="":nbre=0:exp=0
    for a=8 to 9
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"identifiant (2) de l'entité ayant créé le bitmap : ";nbre
 
    m$="":nbre=0:exp=0
    for a=10 to 13
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"octet de début des données : ";nbre
    #w.t,""
 
    'affichage de l'en-tête de l'image
    #w.t,"** en-tête de l'image"
    m$="":nbre=0:exp=0
    for a=14 to 17
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"taille du l'en-tête de l'image, octets : ";nbre
 
    m$="":nbre=0:exp=0
    for a=18 to 21
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"largeur de l'image, pixels : ";nbre
 
    m$="":nbre=0:exp=0
    for a=22 to 25
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"hauteur de l'image, pixels : ";nbre
 
    m$="":nbre=0:exp=0
    for a=26 to 27
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"nombre de plans : ";nbre
 
        m$="":nbre=0:exp=0
    for a=28 to 29
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"profondeur de couleurs, bits : ";nbre
 
    m$="":nbre=0:exp=0
    for a=30 to 33
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"méthode de compression : ";nbre
 
    m$="":nbre=0:exp=0
    for a=34 to 37
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"taille totale de l'image, octets : ";nbre
 
    m$="":nbre=0:exp=0
    for a=38 to 41
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"résolution horizontale de l'image, pixels/mètre : ";nbre
 
    m$="":nbre=0:exp=0
    for a=42 to 45
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"résolution verticale de l'image, pixels/mètre : ";nbre
 
    m$="":nbre=0:exp=0
    for a=46 to 49
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"nombre de couleurs dans la palette : ";nbre
 
    m$="":nbre=0:exp=0
    for a=50 to 53
        nbre=nbre+fich(a)*256^exp
        exp=exp+1
    next
    #w.t,"nombre de couleurs importantes dans la palette : ";nbre
    #w.t,""
 
    'affichage des données du fichier
    lng=0
    va$="":ch$=""
    #w.t,"** détail du fichier"
    #w.t,"N° octet ! octets                          ! caractères"
    for a=0 to qtoct-1
        va=fich(a)
        va$=va$+right$("000"+str$(va),3)+" "
        ch$=ch$+chr$(va)
        if lng=7 then
            noc$=right$("000000"+str$(a-lng),6):lng=0
            #w.t, noc$;" ! ";va$;" ! ";ch$
            va$="":ch$=""
        else
            lng=lng+1
        end if
    next
    #w.t, "!origin 0 0"
    wait
 
[quit]
    unloadbmp nomi$
    close #w
    end
 
 
function fileExists(path$, filename$) '(repris tel quel dans l'aide)
  'dimension the array info$( at the beginning of your program
  files path$, filename$, info$()
  fileExists = val(info$(0, 0)) 'non zero is true
end function
 
 




Edité par Christophe Le 20/11/2020 à 12h52
____________________
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 20/11/2020 à 15h12

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
j'ai abandonné (provisoirement) ma sale manie de la compactification

C'est sûr que ça rallonge, mais c'est plus facile à suivre et à comprendre.
Citation:
"définir bitmap"

Whaouu!!! Alors là tu m'épate, tu es un vrai pro de l'octet.
Citation:
la latence d'écriture/lecture de fichier

N'exagérons rien, la latence de transfert de quelques lignes c'est peanut.
Mais il est vrai que prendre dans la mémoire est intéressant

EDIT: Hey, mais je pense à truc, si on le met en tant que "segment" il est dans la mémoire.
Et il est récupérable depuis la mémoire
Mais bon, les segments, c'est pas évident à manipuler.
____________________
Roro

   
Le 20/11/2020 à 17h24

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Merci pour le pro ;)

Si on met le dessin en tant que segment, on pourra sans doutes le créer en dehors de la fenêtre, mais la difficulté consistera à le ramener dans la fenêtre (s'il existe des fenêtres avec ascenseurs, ça sous-entend qu'on peut dessiner à l'extérieur du cadre visible)

En tout cas, GETBMP dans un graphicbox renvoit un bitmap blanc quand le graphicbox se trouve en dehors de la fenêtre, alors que n'importe où dans la fenêtre, il fonctionne...

J'ai l'impression que JB/LB n'a pas été conçu pour le cas particulier d'animation que je voulais faire, et que continuer dans cette voie serait surement possible, mais avec des connaissances que je n'aurais jamais. Je vais me rallier à ta première proposition : utiliser le mode d'animation habituel ;)

Cependant, rien n’empêche de continuer à expérimenter, c'est toujours de la culture... Pour rappel : le but était d'espérer gagner le temps d'affichage de plusieurs instructions graphiques en les traitant hors-écran, et en affichant le résultat en une seule fois. Donc si on trouve la solution, on saura où la poster...
____________________
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 20/11/2020 à 17h51

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
On peut afficher hors fenêtre mais pas sûr que le getbmp y fonctionne.
Par contre le getbmp permet le drawbmp direct après (je vais m'en servir pour déplacer dans l'organigramme)
____________________
Roro

   
Le 23/11/2020 à 09h57

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Non, le getbmp n'y fonctionne pas.

Nouvel edit : la dimension verticale est bien celle attendue (ouf !) et j'ai corrigé une confusion entre octets et bit dans la profondeur de couleur, ce qui donnait une taille de fichier hallucinante. Problème réglé. Je laisse ce petit avertissement juste pour rappeler qu'on prend toujours des risques à essayer quelque chose d'inconnu ;) (et édité aujourd'hui à 11h11 à cause d'une erreur dans le programme : il reste une anomalie : le dessin du bitmap est celui attendu, la largeur, la proportion aussi... mais pas la hauteur. Je n'ai pas de souci avec la création du bitmap sur ma machine, mais... à prendre avec des pincettes tant que je n'aurais pas compris d’où vient le problème)

Juste un rapport d'étape pour fixer les idées en attendant d'y revenir, car je suis amené à faire autre chose et parce que j'y suis presque. Mais ça ne marche toujours pas.

Par rapport à la précédente version, j'ai supprimé la routine qui dessinait mon bitmap de fond au fur et à mesure du déroulement du jeu. A la place, je créée un fichier bitmap reprenant le jeu entier, et la fenêtre de jeu est comme un cadre qui défile sur le bitmap. Enfin, qui devrait, parce que "background x y" ne semble pas fonctionner.

Point intéressant : cyclesprite s'est mis à fonctionner sans que je sache pourquoi.

Le programme se termine tout seul au bout de 51 cycles d'animation du décor, par un goto sauvage mais bien élevé.

le tir est toujours opérationnel, même si on ne voit pas le lanceur, les missiles sont bien là
Voici le code :

Code VB :
 
'space inv pixelsdantan5

'mise en place du décor : fait
'déplacement du décor : en cours
'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
 
'initialisations
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=12            '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

'définir la fenetre principale
'(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]"
    gosub [creation_des_bitmaps]
 
    loadbmp "bak",nomf$
    '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 *****************

 
[drawingloop]
    'boucle d'animation

    'faut-il dessiner le décor ?
    '   rda=tour actuel d'animation depuis le dernier ré-affichage du décor
    '   rdn=nombre de tours d'animation entre deux affichages du décor
    '   rdo=nombre de dessins depuis le début du jeu
    if rda=rdn then
        rda=0
        if rdo>nblignes then goto [quit]
        #w.g "backgroundxy 0 ";rdo*dimbloc
        #w.g "drawsprites"
        rdo=rdo+1
    end if
    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
 
        'dé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
 
[creation_des_bitmaps]
'création des bitmaps à l'ancienne, et des sprites d'aujourd'hui
'(matrices de 8x8 pixels, 0=pixel éteint, 1=pixel allumé)

    '*** aliens
    restore [alien_anim0]:couleur$="red":nom$="alien0":gosub [creer_bitmap]
    numbmp=numbmp+1
 
    restore [alien_anim1]:couleur$="cyan":nom$="alien1":gosub [creer_bitmap]
    numbmp=numbmp+1
 
    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
    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 du joueur

    '*** explosions

    '*** décors de fond
    'étoiles

    'décor
    'on créée un bitmap, en entrant directement les octets dans un fichier

    'calculs préliminaires
    entetebmp=14 'entete bitmap
    enteteimg=40 'entete image
    zoneinco=12  'zone inconnue

    'la matrice du décor fait 51 lignes de 32 blocs
    'la profondeur de couleur est de 32 bit par pixel, 4 octets
    dimbloc=8*taillepix         'coté du bloc, en pixels
    nblignes=51                 'nombre de lignes de 8*taillepix pixels de haut constituant le décor
    nbpix=largeurs8*nblignes*dimbloc'8  'nombre de pixels du décor
    profcouleur=32              'profondeur de couleur, 4 octets=32 bits

    taillefic=entetebmp+enteteimg+zoneinco+nbpix*(profcouleur/8) 'taille totale du fichier

    'ouverture du fichier bitmap pour écriture sur le disque
    nomf$="voiciledecor.bmp"
    open nomf$ for output as #f
 
    'nombre magique
    nm$="BM"
    #f,nm$;
 
    'taille du fichier
    #f,dec2fich$(taillefic,4,0);'nombre, octets attendus, endian (0=poids faible d'abord)

    'entité ayant créé le bitmap, champ 1
    entcrea1=0
    #f,dec2fich$(entcrea1,2,0);
 
    'entité ayant créé le bitmap, champ 2
    entcrea2=0
    #f,dec2fich$(entcrea2,2,0);
 
    'adresse de la première donnée graphique
    oddon=entetebmp+enteteimg+zoneinco
    #f,dec2fich$(oddon,4,0);
 
    'taille de l'en-tête de l'image
    #f,dec2fich$(enteteimg,4,0);
 
    'largeur de l'image, en pixels
    #f,dec2fich$(largeurs8,4,0);
 
    'hauteur de l'image, en pixels
    hautimage=nbpix/largeurs8
    #f,dec2fich$(hautimage,4,0);
 
    'nombre de plans
    nbp=1
    #f,dec2fich$(nbp,2,0);
 
    'profondeur de couleurs
    #f,dec2fich$(profcouleur,2,0);
 
    'méthode de compression
    methcomp=3
    #f,dec2fich$(methcomp,4,0);
 
    'taille totale de l'image,en octets = ";ttimg
    ttimg=largeurs8*hautimage*(profcouleur/8)
    #f,dec2fich$(ttimg,4,0);
 
    'résolution horizontale de l'image, pixels par mètre
    resh=0
    #f,dec2fich$(resh,4,0);
 
    'résolution verticale de l'image, pixels par mètre
    resv=0
    #f,dec2fich$(resv,4,0);
 
    'nombre de couleurs de la palette
    nbcoulpal=0
    #f,dec2fich$(nbcoulpal,4,0);
 
    'nombre de couleurs importantes de la palette
    nbcoulimppal=0
    #f,dec2fich$(nbcoulimppal,4,0);
 
    'zone inconnue, 12 octets (masques alpha channels ?)
    ch$="0 255 0 0 255 0 0 255 0 0 255 0"
    for a=1 to 12
        b=val(word$(ch$,a))
        #f,chr$(b);
    next
 
    'ajouter les pixels
    'de gauche à droite, mais en partant par le bas de l'image
    '(le haut de l'image est en bas)

    col0$="0 0 0"       'couleur du vide spatial
    col1$="200 200 50"  'couleur terrain

    restore [decor] 'lecture de la matrice du décor
    for a=1 to nblignes
 
        rvb$=""
        read a$ 
        for c=1 to 32
            'pour chacune des lignes de la matrice
            '(un bloc de la matrice fait 8*taillepix pixels de côté)

            'explorer les blocs
            b$=mid$(a$,c,1)
 
            'déterminer la couleur du bloc
            if b$="0" then col$=col0$ else col$=col1$
 
            'définir la ligne de pixels pour un bloc
            r=val(word$(col$,1))
            v=val(word$(col$,2))
            b=val(word$(col$,3))
            for d=1 to dimbloc
                rvb$=rvb$+chr$(0)+chr$(r)+chr$(v)+chr$(b)   '(4 octets par pixel)
            next
 
            'et passer au bloc suivant
        next c
 
        'dupliquer la ligne 8*taillepix fois en vertical dans le fichier
        for ligne=1 to dimbloc
            #f,rvb$;
        next
    next
 
    close #f    'bitmap du fond créé, fermer le fichier

    return
 
[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
 
[quit]
    timer 0
    'unloadbmp "etoiles"
    unloadbmp "bak"
 
    for a=0 to numbmp-1
        unloadbmp nombmp$(a)
    next
 
    close #w
 
    end
 
 
'********************* fonctions *********************

function dec2octet$(nombre,octets,codage)
'affichage en octet et sur l'écran, d'une valeur en base 10
'on arrive avec le nombre décimal, le nombre d'octets souhaités, le codage
'on repart avec la chaine de caractère comprenant la valeur base 10 des octets, séparés par un espace

    n$=""
    n=nombre
    for a=octets-1 to 1 step -1
        d=256^a         'diviseur
        q=int(n/d) 'quotient
        r=n-d*q    'reste
        'du nombre, on retire le produit q*d
        n=n-q*d
        'et on obtient la valeur de l'octet, qu'on place dans une chaine
        if codage=1 then n$=n$+" "+str$(q) else n$=str$(q)+" "+n$
    next
    if codage=1 then n$=n$+" "+str$(r) else n$=str$(r)+" "+n$
 
    dec2octet$=n$
 
    end function
 
 
function dec2fich$(nombre,octets,codage)
'préparation d'une valeur en base 10 en octets en vue de son enregistrement en fichier
'on arrive avec le nombre décimal, le nombre d'octets souhaités, le codage
'on repart avec la chaine de caractère comprenant les octets à transférer en fichier

    n$=""
    n=nombre
    for a=octets-1 to 1 step -1
        d=256^a         'diviseur
        q=int(n/d) 'quotient
        r=n-d*q    'reste
        'du nombre, on retire le produit q*d
        n=n-q*d
        'et on obtient la valeur de l'octet, qu'on place dans une chaine
        if codage=1 then n$=n$+chr$(q) else n$=chr$(q)+n$
    next
    if codage=1 then n$=n$+chr$(r) else n$=chr$(r)+n$
 
    dec2fich$=n$
 
    end function
 
 
'*********************** datas ***********************
'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"
 
 
[alien_anim1]
    data "00111100"
    data "01011010"
    data "01111110"
    data "10000001"
    data "11111111"
    data "00100100"
    data "01000010"
    data "01000010"
 
 
[alien_anim2]
    data "00111100"
    data "01000010"
    data "01111110"
    data "10000001"
    data "11000011"
    data "00111100"
    data "00100100"
    data "00100100"
 
[missiles]
    data "00010000"
    data "00010000"
    data "00010000"
    data "00010000"
    data "00111000"
    data "01111100"
    data "00010000"
    data "00010000"
 
[vaisseau]
'à définir

[explosion]
'à définir, plusieurs bitmaps

[decor]
    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"
    data "11111111111000000000000111111111"
    data "11111111000000000000000000111111"
    data "11111110000000000000000000001111"
    data "11111100000000000111111000000111"
    data "11111000000000001111111110000111"
    data "11110000000000011111111110000011"
    data "11111000000000001111110000011111"
    data "11111000000000001111111001111111"
    data "11111000000000000111111111111111"
    data "11111100000000000111111111111111"
    data "11111111000000000000111111111111"
    data "11111111100000000000011111111111"
    data "11111110000000000000000011111111"
    data "11111000000000000000000000111111"
    data "11100000000000000000000000001111"
    data "11000000000000000000000000000001"
    data "10000000000000000111100000000001"
    data "10000000000011111111111000000001"
    data "11000000001111111111111111000001"
    data "11110000000011111111111000000001"
    data "11000000000000001111100000000001"
    data "10000000000000000111100000000001"
    data "10000000000000000000000000000001"
    data "10000000000000000000000000000001"
 
 




Edité par Christophe Le 23/11/2020 à 11h42
____________________
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 23/11/2020 à 11h58

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Il n'y a qu'avec LB qu'on peut déplacer le background, en JB ça crashe le prog.
Mais si tu fais plusieurs background, le changement se fait en douceur (je l'ai testé sur une ébauche de "Flipper")
____________________
Roro

   
Le 23/11/2020 à 13h16

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Oui je sais, je devrais être ailleurs, mais je n'ai pas de train à prendre non plus. Pas trouvé grand chose sur le net pour cette histoire de plantage, et le backgroundxy est bien dans l'aide de Justbasic2.

Dans cette recherche, je suis passé par le site LBBooster (le gars est venu se présenter une fois, si je me souviens bien, malheureusement je n'avais pas assez de pratique de JustBasic pour trouver un intérêt à basculer vers LBB) :
Citation:
The GETBMP command can 'see' graphics which are outside the currently visible window, so if you have a scrollable graphics window you can get its entire contents into a bitmap.

Ce qui, si je comprend bien, dit clairement que GETBMP ne peut capturer à l'extérieur de la fenêtre active, et que LBBooster pourra le faire si la fenêtre a des ascenseurs. Comme je met pas d'ascenseurs sur ma fenêtre, le problème est réglé.

Apparemment rien de plus pour le backgroundxy chez LBB, le mystère demeure.

Citation:
si tu fais plusieurs background, le changement se fait en douceur

Après tout, si je peux générer un bitmap de la taille de la fenêtre pendant que l'animation affiche le bitmap précédent, c'est gagné.

Encore faut-il que la procédure ne soit pas trop lente. Un disque dur classique est plus lent que la mémoire, et générer le décor le solliciterait deux fois par secondes, ça fait deux arguments pour créer le bitmap en mémoire. Ce qu'on fait, comme chacun sait, avec un ...GETBMP ;)

De toute manière, pas trop le temps de me pencher dessus, on verra plus tard.

à+, donc...
____________________
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 23/11/2020 à 15h00

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
le backgroundxy est bien dans l'aide de Justbasic2.

Ah, il faut tester, je suis toujours avec JB1 mais j'ai aussi JB2.
Citation:
LBBooster pourra le faire si la fenêtre a des ascenseurs

Le Booster a l'air d'avoir des fonctionnalités de LB (ça ressemble à un "crack" toléré)
Citation:
si je peux générer un bitmap de la taille de la fenêtre pendant que l'animation affiche le bitmap précédent, c'est gagné.

Et non car on ne peut pas mettre des sprites sur du bmp (background obligatoire)
Quand on draw un bmp il se met au premier plan. (d'où le nom de "back-ground").
Mais le paradoxe, c'est que le drawsprite lui, gère le premier plan

Tu a l'air grave occupé (champignons ? Fait gaffe à ce que tu mets dans la poêle).
____________________
Roro

   
Le 24/11/2020 à 17h53

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Pour les champignons, je prend ceux du super-marché, c'est théroriquement moins risqué ;)

Pour en revenir au listing, c'est quand même hallucinant de galérer à ce point sur des instructions aussi basiques. Le loup est caché dans cet extrait de code :
Code VB :
 
[drawingloop]
    'boucle d'animation, branchée par un timer toutes les 52 ms

    'animation du décor
    '   rda=tour actuel d'animation depuis le dernier ré-affichage du décor
    '   rdn=nombre de tours d'animation entre deux affichages du décor
    '   rdo=nombre de dessins depuis le début du jeu
    if rda=rdn then
        rda=0
        if rdo>nblignes then goto [quit]
        #w.g "backgroundxy 0 ";rdo*dimbloc
        #w.g "drawsprites"
        rdo=rdo+1
    end if
    rda=rda+1
 
    'animation des sprites
    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
 
        'dé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
 

L'animation des sprites se fait toutes les 56 ms, et l'animation du bitmap de fond, plus connu sous le nom officiel de "background", toutes les 12 animations des sprites : pour fixer les idées, ça correspond à 18 animations par seconde pour les sprites, et 1,5 animation par seconde pour le background.

Il y a trois blocs dans cette routine d'animation, qui sont, dans l'ordre :
animation du fond
animation des sprites
changement de sens des sprites au contact des bords de la fenetre

Cyclesprite : dans cette première version, l'animation du fond ne fonctionne pas, mais le cyclesprite, bien que pas défini à cet endroit, fonctionne au rythme de l'animation du fond. Je suppose que le cyclesprite est seulement effectif lors d'un "drawsprite" : le drawsprite qui affiche les sprites revient trop souvent pour qu'on puisse voir les changements de dessins (on en est à 18 images par secondes), alors que le drawsprite qui affiche le fond revient deux à trois fois par seconde, et là, on voit bien les dessins alterner.

Mais le problème principal est toujours le fond, qui reste désespérément fixe.

Si on modifie l'ordre des blocs, comme par exemple :
animation des sprites
animation du fond
changement de sens des sprites,

ou
animation des sprites
changement de sens des sprites
animation du fond,
le fond bouge comme attendu ! Mais reprend tout de suite sa position initiale, alors qu'il n'y a pas de "background bak" dans la boucle.

C'est un sacré casse-tête, ce truc...
____________________
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 24/11/2020 à 19h03

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
est seulement effectif lors d'un "drawsprite"

Oui, tout changement concernant les sprites ou le background doit être suivi de l'inévitable "Drawsprites" pour être prit en compte.

Avec ton dernier code les ^sprites vont bien mais le background clignote sans bouger

Plutôt que de faire défiler un background" (Il semble que le backgrouundxy ne marche pas (JB2) (je vais le tester tout seul); il faut faire plusieurs backgrounds (nombre en fonction de la vitesse et durée de l'animation) et les afficher tour à tour en boucle.
____________________
Roro

   
Le 24/11/2020 à 19h34

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Suite du: 24/11/2020 à 19h03
Ah ben si, le backgroundxy fonctionne (JB2)
Mets ce code dans un dossier avec ton bmp "voiciledecor"
Et clique sur "Go"
Code VB :
 
  nomainwin
  [test] '---------------------TEST--------------------
    WindowWidth = 595: WindowHeight = 300
    UpperLeftX = 10: UpperLeftY = 20
    BUTTON #t.go, "Go", [go], UL, 30, 30, 40, 25
    GRAPHICBOX #t.m, 5, 5, 580, 380
    OPEN "Test" FOR window_nf AS #t
    #t, "TRAPCLOSE [closetest]"
      loadbmp "fond","voiciledecor.bmp"
       #t.m, "background fond"
     #t.m, "drawsprites"
  wait
  [go]
    x=0
    for y=0 to 500
      #t.m, "backgroundxy ";x;" ";y
      #t.m, "drawsprites"
    next y
  wait
  [pause]
        timer 200, [temps]
        wait
        [temps]
        timer 0
  return
  [closetest]
      unloadbmp "fond"
    close #t
    END
 
____________________
Roro

   
Le 26/11/2020 à 00h03

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Testé, ça marche.

Dans un avenir proche, je change peu à peu le programme pour me rapprocher de mon schéma initial, et voir à quelle étape le backgroundxy ne fontionne plus.

a+
____________________
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 28/11/2020 à 00h13

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
Eh bien la bonne blague : ça fonctionne... Un grand merci à toi, Roland, pour m'avoir fourni une animation fonctionnelle du bacground à partir de laquelle j'ai pu expérimenter, et peu à peu me rapprocher de l'organisation de mon programme.

En fait, il fallait juste déplacer l'instruction de mouvement du décor : l'enlever de l'"if" modifiant sa position toutes les "rdo" animations de sprites, et la rajouter dans le bloc d'affichage des sprites.

Par contre, si dans l'"if" on supprime le drawsprites, les sprites n'alternent plus leurs différentes versions, donc je l'ai laissé.

Donc en code ça donne ceci :

Code VB :
 
[drawingloop]
    'boucle d'animation

    'faut-il dessiner le décor ?
    '   rda=tour actuel d'animation depuis le dernier ré-affichage du décor
    '   rdn=nombre de tours d'animation entre deux affichages du décor
    '   rdo=nombre de dessins depuis le début du jeu
    '   le décor est redessiné une fois toutes les "rda" tours d'animation
    if rda=rdn then
        rda=0
        if rdo>nblignes then goto [quit]
        '#w.g "backgroundxy 0 ";rdo*dimbloc 'mis en commentaire
        #w.g "drawsprites"
        rdo=rdo+1
    end if
    rda=rda+1
 

et un peu plus loin :
Code VB :
 
        '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 "backgroundxy 0 ";rdo*dimbloc*-1   'et copié ici
        #w.g "drawsprites"
 
    next
 


Voici le zip : /upload/space-inv-pixelsdantan5bis_bas.zip

Bonne nuit !
____________________
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 28/11/2020 à 01h22

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Ah oui, là c'est bon; mais si tu veux mettre un décor de planètes il faudra que le déplacement soit plus fluide, peut-être en mettant deux timer séparés (un plus rapide (24 images seconde ? et faible déplacement).
Hey, j'ai déposé une demande de "génération d'octets" chez les ricains; je remonterai les filets demain.
____________________
Roro

   
Le 28/11/2020 à 15h10

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Suite du: 28/11/2020 à 01h22
Purééééeee! Je n'avais pas capté que tu générais le fichier; c'est exactement ce qu'il me faut pour l'effacement de la grille, mais saperlipopette qu'est-ce que c'est ardu; du coup je vais ajouter dans le dossier "organigramme "un 'Effacement de la grille" avec un avertissement pour le temps de traitement; après tout on peut faire autre chose ou bailler aux corneilles pendant que ça mouline.
Ton code c'est carrément l'Himalaya. Rien que d'avoir enlevés les sauts de lignes je manque d'oxygène.

Note: tu devrais mettre un: "kill "voiciledecor.bmp" à la fermeture pour que tout soit bien sec. ;)
____________________
Roro

   
Le 28/11/2020 à 21h14

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 667
J'avoue ne pas y avoir pensé.

Je ne sais pas comment sera le programme finalisé, si on aura un seul gros programme qui fait tout, ou si le programme sera fourni avec les bitmaps nécessaires, rien n'est figé. L'avantage immédiat est d'avoir appris à générer un bitmap autrement qu'avec un bmpsave.

Citation:
si tu veux mettre un décor de planètes il faudra que le déplacement soit plus fluide, peut-être en mettant deux timer séparés (un plus rapide (24 images seconde ? et faible déplacement).
On peut animer au pixel unitaire, là ça saccade parce qu'on y va par saut de 8 pixels, et en effet, ça semble un peu trop. Je suppose que le défilement est trop rapide... Un tour sur internet devrait lever le doute (il doit bien y avoir des vidéos de ces vieux trucs en fonctionnement).

Dans la première version il y avait le décor, et les étoiles. Le décor avançait de 8 pixels quand les étoiles avançaient de 1 ou 2 pixels, et pour le moment, je ne sais pas comment concilier ces deux plans en un seul background. Si tu as une idée, je teste, mais je laisse tomber les étoiles, car il reste encore pas mal de défis à relever : on est au tout début de l'aventure)

Citation:
du coup je vais ajouter dans le dossier "organigramme "un 'Effacement de la grille" avec un avertissement pour le temps de traitement
Pour ma part - et c'est un peu vendre la peau de l'ours avant de l'avoir tué - je te propose de créer ton bitmap à tes besoins (tu n'as pas besoin des 16 milions de couleurs proposées par bmpsave ? ), avec peu de couleurs et une palette dans laquelle il suffit de changer une couleur, et plus de parcourir/modifier tous les pixels un à un).

Citation:
Rien que d'avoir enlevés les sauts de lignes je manque d'oxygène.

Mais qu'as-tu besoin d'enlever les sauts de ligne ? S'il faut faire plus concis, tu le dis, j'essaierai de m'y plier. Je suis du genre littéraire et j'écrirais facilement "si a est égal à deux" quand d'autres mettront un simple 'a=2 ;)

Si tu es sur un petit écran, je comprend que ce soit un peu galère, les blocs code=vb du forum rendant le listing plus difficile à lire que dans l'éditeur.

La grande difficulté quand on commente un listing, est de le faire pour être compréhensible par quelqu'un qui ne connait pas le programme, et inversement, lire les commentaires ne veut pas dire qu'on les comprend. La cause en est qu'on a tous un cheminement logique différent pour arriver au résultat, et qu'Untel utilisera des trucmuche rouges qui lui sont plus familiers, alors que Tel-Autre utilisera des parsecs bleus qu'il maitrise mieux. Le seul moyen est de faire abstraction de notre propre logique pour entrer dans la logique de l'auteur du listing, et c'est pas évident...
____________________
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 29/11/2020 à 00h32

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2327
Citation:
je laisse tomber les étoiles

Dommage, je préfère les étoiles au décor "sixties".
Si tu déplace moins en distance il faut accélérer la séquence, enfin...Trouver un compromis; les étoiles se prétaient à un déplacement lent, et en combinant x et y il y a moyen de donner une sensation de vertige (vertige cosmique, of course).
Citation:
Mais qu'as-tu besoin d'enlever les sauts de ligne ?

C'est pour pouvoir aller plus vite d'une partie du code à une autre, avec les sauts de lignes c'est la course à l'échalote, pardon, à la roulette, ou voir de plus "haut".
Mais les commentaires sont vraiment une grande aide et je regrette de ne pas avoir la patience d'en faire autant dans mes progs, mais je m'améliore, je nomme les blocs.
Tes com' sont vraiment très bien et très clairs, c'est le must
Citation:
j'écrirais facilement "si a est égal à deux"Retiens toi.

Retiens toi. ^^ :( :| :hi

Je donnerai des nouvelle de "l'éffaceur de grille" dans le topic concerné.
____________________
Roro

   
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