Disegnare Livelli In Modlaità Bitmap

[Fabbroz75]

 Ho provato a scrivere il seguente codice non ottimizzato, ed ho provato a disegnare un livello ( livello??! ).

quasi quasi.. comincio a scrivere un giocherello

Adesso devo capire come collidere sprite / sprite ( ho capito che c'è un bit da settare che controlla se è in collisione ) e provare almeno a far collidere con i colori nello schermo.. non dovrebbe essere cosi' difficile...

Uhmm.. vediamo... provo a fare un clone di Tron

Codice: [Seleziona]

; Code by Fabbroz75
; solo scopo didattico
; da ottimizzare ed ampliare

  *= $0801        
  .byte $0b,$08,$0a,$00,$9e
  .text "2061"
  .byte $00,$00,$00
        
 
initvic
        lda #$18
        sta $d018
      ;sta $d016
  
        lda #$00
        sta $d020
        sta $d021
        jsr $e544; cancella lo schermo
  
        ldx #$00
  ldy #$24  
code

; loop chiaramente ottimizzabile
; scritto terra terra solo per capire che sto facendo :)

  lda map,x
  sta $d800,x
  lda #$68
  sta $0400,x
  
  lda #$68
  sta $04f0,x
  lda #$02
  sta $d8f0,x
  
  lda #$68
  sta $05e0,x
  lda #$05
  sta $d9e0,x
  
  
  
;lp   lda #$80
;wt   cmp $d012
;     bne wt
    
     inx
     dey
  bne code
  
end  jmp end

map  byte  $00,$00,$01,$01,$03,$00,$00
  byte  $00,$00,$02,$01,$03,$00,$00
  byte  $00,$00,$03,$01,$03,$00,$00
  byte  $00,$00,$04,$01,$03,$00,$00
  byte  $00,$00,$05,$01,$03,$00,$00
  byte  $00,$00,$06,$01,$03,$00,$00



[iAN CooG]

 

Ho provato a scrivere il seguente codice non ottimizzato

:huh: e nemmeno provato immagino.
Seriamente, piantala di postare guazzabugli di codice scritto a caso, non sono utili a nessuno. Quando hai qualcosa di finito e funzionante, postalo, a meno che non stai chiedendo di farti correggere il programma e non riesci da solo.  

[Fabbroz75]

 Sto cercando di imparare... mi scuso se sono invadente.. ma almeno non mi perdo d'animo

Purtoppo non ho piu' 15 anni ed il tempo è quello che è per imparare..
Spero non diano fastidio.. e credo, di non essere l'unico ad aver voglia di imparare.. visto che nessuno nasce imparato ( ndr ).
Posto codici magari errati... ma sono pur sempre prove.

nessuna polemica.. anzi.

   

[Cbm]

 

Sto cercando di imparare... mi scuso se sono invadente.. ma almeno non mi perdo d'animo

Anche se concordo sul fatto che prima di pubblicare è meglio provare (metti per esempio che qualcuno che parte da zero cerchi un esempio, lo prenda come base per capire ed assimili concetti potenzialmente "svianti" credendo di trovarsi di fronte ad un "libro di testo" perchè lo iAN di turno non si è intromesso), fa piacere che tu voglia condividere le tue esperienze ed idee qui.
Io credo di saperne meno di te e colpevolmente ci passo molto meno tempo per progredire, ma non mi dispiace proporre un'idea o ragionare su qualcosa, anche se può sembrare banale. Penso che magari tanti visitatori non esperti hanno qualcosa di interessante da dire e non scrivono o chiedono mai sul forum programmazione perchè magari si sentono ridicoli e banali a parlare di cose anche elementari, da capitolo 1 di un manuale, trovandosi in mezzo ad esempi di carattere avanzato.
Quando per esempio ho provato quelle routine per simulare il flash, ripescando una vecchia discussione in merito, speravo proprio di stimolare la curiosità e la voglia di questi lettori (e parlo anche di chi non è registrato) dimostrando che anche delle piccole cose possono dare soddisfazione e un piccolo contributo alla divulgazione dell'argomento, come mi sembra succedesse più frequentemente nei primi tempi del forum programmazione che non ho vissuto ma che mi piacerebbe vedere sempre con maggiore vitalità e varietà.

Per cui se cercavi un incoraggiamento, eccotelo servito travestito da mattone da leggere.    
E infine mi scuso perchè sono andato fuori tema.

[Fox Cunning]

 Suvvia, bando alle morali e scriviamo un po' di codice [(testato) e funzionante].
Ma perché in modalità bitmap? Per una mappa a blocchi mi viene più naturale pensare alla modalità testo.
Il codice seguente è stato scritto secondo la celebre filosofia It Just Works:

Codice: [Seleziona]

;-----------------------------------------------------------------------------
;Visualizzazione mappe in modalità testo
;Codice di pubblico dominio :-)
;-----------------------------------------------------------------------------

processor 6502

;-----------------------------------------------------------------------------
;basic sys line
;-----------------------------------------------------------------------------
.org $801
.word lastb
.word $1bbe
.byte $9e
.byte $32,$30,$36,$31,$00
lastb
.word $00

;-----------------------------------------------------------------------------
;init
;-----------------------------------------------------------------------------
init
lda #$d8
sta $d016;Multi-colour mode
lda #$1b
sta $d011;Standard text mode
lda #$18
sta $d018;V-RAM @$400, C-RAM @$2000
lda #$00;bg colour
sta $d020
sta $d021
lda #$fc;Grey 1
sta $d022
lda #$ff;Grey 2
sta $d023

;-----------------------------------------------------------------------------
;readmap
;-----------------------------------------------------------------------------
readmap
ldx #$00

x_loop
lda map,x
sta $0400,x
lda #$f9;Notare che il colore è sempre lo stesso:
sta $d800,x; sarebbe meglio leggerlo da una colourmap
lda map + $100,x
sta $0400 + $100,x
lda #$f9
sta $d800 + $100,x

lda map + $200,x
sta $0400 + $200,x
lda #$f9
sta $d800 + $200,x

lda map + $300,x
sta $0400 + $300,x
lda #$f9
sta $d800 + $300,x

dex
bne x_loop



;-----------------------------------------------------------------------------
;extra_cool_loop
;-----------------------------------------------------------------------------
extra_cool_loop
jmp extra_cool_loop

;-----------------------------------------------------------------------------
;data
;-----------------------------------------------------------------------------
map
.incbin map.bin


.org $2000
charset
.incbin charset.bin
Includo un collegamento ai due file di cui sopra (map.bin e charset.bin) QUI.
Vista la mia imperizia, di certo non sarà un bel codice, ma funziona (It Just Works!).
Potresti voler usare una routine (o procedure) più generica per visualizzare la mappa.
Potresti voler usare un colore per ogni blocco, ci sono diversi metodi ed è abbastanza semplice.
Potresti anche voler usare mappe di dimensioni diverse da 40x25.
E così via.

[iAN CooG]

 grazie madinitaly, davvero  
:lol:

[Fabbroz75]

Suvvia, bando alle morali e scriviamo un po' di codice [(testato) e funzionante].
Ma perché in modalità bitmap?
 

Perche' ne so poco del c64
Tieni presente che il livello di conoscenza (programmatoria ) sul c64 è ( era ) pari a 0...
Adesso sto cominciando a capire un po di cose.. e gli strafalcioni che ho scritto

Sto cominciando a capire il funzionamente degli irq e la loro importanza sul c64.
...non posso certo imparare se non sbaglio...  :doh:

Mi è tornato finalmente il C64 ( anzi un C128 ) su cui programmare ( mi piace di piu' sviluppare sul computer vero ).

Domanda:
con cosa hai creato i vari .bin?

Grazie per i tuoi utili consigli
   

[Fox Cunning]

 Non ne sono un esperto neanche io, ma imparerai se sarai persistente.
Per quanto riguarda i file inclusi, la mappa è stata creata con un semplice editor esadecimale (il che, unito alla mia pigrizia, spiega perché è così brutta).
Per creare il charset, invece, c'è una moltitudine di programmi, molti dei quali ti permettono di lavorare direttamente sul vero C64. Una quantità di crosstools ti consentirà di ottenere buoni risultati lavorando invece sul tuo PC (CharPad, Cuneiform... non sono aggiornato, sicuramente ce ne sono di migliori).
Se hai tempo, prova a modificare la routine in modo che la mappa sia più colorata. Puoi sostituire il bianco con un altro colore scrivendo valori diversi in $D800-$DBE7.
Potresti usare una tabella a parte con una corrispondenza di colore per ogni carattere, oppure usare solo i primi 16 caratteri e mettere il codice del colore nei 4 bit più significativi di ogni byte della mappa stessa, ma ci sono tanti approcci anche migliori.
Buon divertimento!

[Fox Cunning]

 

... provo a fare un clone di Tron

Oggi avevo un po' di tempo da sprecare, così ho provato a fare un clone di Tron usando una mappa a blocchi in modalità testo/multicolour. Bisogna dire che non ho mai giocato a Tron in vita mia, né a nessun suo clone, né ho mai visto il film. Ho visto "The Black Hole", ma temo non sia la stessa cosa. Mi sono basato sulla descrizione del gioco che ho letto in due minuti sulla Wikipedia.
Il codice sorgente (ridondante!), insieme ai file inclusi (mappa, charset, titolo) e al PRG funzionante è in questo file.
È il mio primo programma per C64 scritto (interamente) in assembler, quindi potrebbe contenere (e sicuramente contiene) una certa quantità di errori. Ma funziona!
Mi sono accorto che usare una mappa di quasi 1kb per un gioco così è uno spreco: la mappa andrebbe semplicemente generata via codice!

Sto cominciando a capire il funzionamente degli irq e la loro importanza sul c64.

Ho provato a fornirti alcuni semplici esempi, ma non accontentarti della mia inesperienza!
Infine, molte routine sono ripetute, praticamente identiche, spesso due volte (per i due giocatori). Un'unica routine, parametrizzata, sarebbe più elegante ed economica, ma meno leggibile; ho lasciato le cose come stanno.

Non sono sicuro di aver fatto bene a mettere quel codice nel loop principale; d'altro canto funziona come dovrebbe, quindi mi accontento.
Sicuramente avrai visto/vedrai esempi migliori, ma dopotutto anche questo funziona. :stordita:

P.S.: oltre che per quella del codice, mi scuso per la scarsa qualità della grafica.

[Fabbroz75]

 Grazie infinite...

Il gioco è perfetto... la differenza è che le moto lasciano una scia colorata uniforme ( rossa o blue ).
Il fondale è una griglia ( quadrati vuoti per intenderci ) dove le moto passano lungo il perimetro di ogni quadrato.

Si potrebbe includere un suono in flanger ( una semplice nota bassa ) per simulare il motore.

Studiero' il codice anche se non ottimizzato.. ma almeno vedo cosa succede...
appena ho 5 min.. provo a riscriverlo provando ad ottimizzare/ampliare qlcosa e lo riposto.

Mi sembra di ritornare a 15 anni fa.. quando con gli amici si scriveva codice anche enormemente lungo ed errato... ma funzionante, solo per il gusto di vedere cosa accadeva :D

Grazie madinitaly
Fabbroz

[Fabbroz75]

 @madinitaly

Leggendo il tuo sorgente, mi sembra di aver capito che attraverso la gestione degli irq è  possibile passare da modalità bitmap a testo e viceversa( disegnare il logo, le scritte ( testo ) etc )... giusto?

Credo sia una parte importantissima e quindi va compresa al bit

Scusa se posso risultare poco preciso..
Ne deduco ( magari erronemente ), che senza questa gesitione, si puo' attivare un modo alla volta.

ah altra cosa... non usi sprite o sbaglio?... sembra che colori semplicemente una mappa predisegnata.
La collisione avviente testando i byte realtivi alla posizione dell'area di memoria "colorata/disegnata"?



ciao
 

[Fox Cunning]

 Ehilà.

mi sembra di aver capito che attraverso la gestione degli irq è  possibile passare da modalità bitmap a testo e viceversa( disegnare il logo, le scritte ( testo ) etc )... giusto?

Farlo tramite una routine di gestione degli interrupt è uno dei modi, suppongo abbastanza comune. Sicuramente meglio così che con un polling continuo di $d011-$d012. Ad ogni modo, sì, consente di cambiare modalità mentre lo schermo sta venendo disegnato, così puoi avere allo stesso tempo bitmap e caratteri.

Credo sia una parte importantissima e quindi va compresa al bit

Ci sono effetti più o meno complessi e altre routine che richiedono un tempismo perfetto (soprattutto quando si tratta di gestione dell'I/O); in quel caso la routine andrebbe studiata più che al bit, al ciclo di clock. D'altra parte, un giochino come questo non ha bisogno di tante complicazioni.

Ne deduco ( magari erronemente ), che senza questa gesitione, si puo' attivare un modo alla volta.

Come dicevo sopra, potresti anche fare un loop del tipo:

Codice: [Seleziona]

begin
...
lda $d012
cmp #$62
     beq textmode
     cmp #$01
bne begin
bitmapmode
lda #$1b
sta $d011
...
jmp begin
textmode
lda #$3b
sta $d011    
...
jmp begin
...
...ma non sarebbe stabile affatto.

ah altra cosa... non usi sprite o sbaglio?... sembra che colori semplicemente una mappa predisegnata.
La collisione avviente testando i byte realtivi alla posizione dell'area di memoria "colorata/disegnata"?

Niente sprite, è vero. L'unico utilizzo che può venirmi in mente sarebbe quello di usarli per i motocicli (un movimento più fluido non guasta mai). La collisione avviene assai semplicemente così:

Codice: [Seleziona]

lda (p1_pos),y
cmp #$00
bne p1_crash;CRASH!
Notare che abbiamo già aggiornato il puntatore p1_pos, ma non abbiamo ancora disegnato il motociclo in quella posizione. Prima di disegnare, usiamo il puntatore per leggere se c'era uno spazio vuoto.

Buon divertimento!

[iAN CooG]

 Complimenti madinitaly B)
Volevo solo far notare un errore, penso di distrazione.

Codice: [Seleziona]

readmap
  
  ;lda map + $300,x
  ;sta $07f0,x    ;OCCHIO! sovrascrivi codice a $0800-$08EF
  ;lda #$f9
  ;sta $dbf0,x    ;IDEM!   qui scrivi nel CIA1 ($DC00-$DCEF)

Visto che devi trasferire solo $2f0 bytes, sono di troppo

AH! una cosa riguardo al NON usare jmp $ea81: il codice di uscita dall'irq che hai usato e' esattamente quello che fa la jmp $ea81, direi che e' inutile in questo caso. Di solito si fa pla/rti manualmente solo se si lavora a tutta ram (kernal disattivato con $01=$35) o al limite se serve assolutamente risparmiare i 3 cicli aggiuntivi impiegati dalla jmp.

Per il resto hai fatto bene a lasciare il codice non ottimizzato, quello lo si puo' fare sempre dopo. Io ad esempio sono riuscito ad eliminare ben 145 bytes di codice, a furia di sfrondare, ma risulta piu' intricato da leggere =)

[Fox Cunning]

 

Codice: [Seleziona]

readmap
  
 ;lda map + $300,x
 ;sta $07f0,x   ;OCCHIO! sovrascrivi codice a $0800-$08EF
 ;lda #$f9
 ;sta $dbf0,x   ;IDEM!   qui scrivi nel CIA1 ($DC00-$DCEF)


Oops! Grazie per l'appunto, in effetti sono stato sbadato! Inizialmente la mappa partiva dalla cima dello schermo, distrazione mia quando ho modificato la routine per le nuove coordinate.

Sono anch'io della scuola per l'ottimizzazione in secundis: se ci sono errori da correggere o routine da modificare, è meglio farlo su un codice che sia quanto più leggibile.

[Alberto]

 Complimenti anche da parte mia per il tuo Tron

@ Fabbroz75

Non preoccuparti degli strafalcioni,tutti noi ne abbiamo fatti e continueremo a farne,e del resto sono inevitabili quando si vuole imparare. :lol: