[C64] Routine 80x50 in ASM

[KymyA]

Allora gente...
...so che MOLTO probabilmente fotterà una sega a tutti però ho scritto, da stamattina, una routine per Commodore64 che possa gestire una "grafica" in formato 80x50 usando i caratteri del C64.
La routine è:

SYS 49152,X,Y,Colore

con X da 0 a 79, Y da 0 a 49 e Colore da 0 a 15

La routine si occupa di
1. Controllare se la cella video dove verrà allocato il "pixellone" contiene già un carattere del set
2. Trasformare le coordinate passate in cella video ($0400-$07E
3. Calcolare il pixellone da accendere
4. Calcolare il nuovo carattere
5. Pokare il carattere ed il suo colore


Il problema è che c'è qualcosa che non va nei calcoli. Non so perché prima funzionava, poi da un certo punto mi sfasa il punto acceso. Inoltre il codice è auto-modificante per ottimizzare la dimensione ed i calcoli.
Qualcuno vuol dare un contributo?
Perché lo sto facendo? Così... per non perdere l'allenamento e perché voglio riprodurre un engine pseudo3d (tipo doom) su C64.

[koba44]

PRIMERO!1!!

[LordOrion]

Perché lo sto facendo? Così... per non perdere l'allenamento e perché voglio riprodurre un engine pseudo3d (tipo doom) su C64.

Ma vai a figa va'...

[KymyA]

brutte persone

non dico altro

[KymyA]

Cmq trovato l'errore...
era logico....

adesso le coordinate le converte correttamente.

Adesso c'è n'altra cosa che non funzia... il pixellone sottostante non viene riconosciuto correttamente ... c'è un inversione della coordinata X con quella Y

[Falegname Geppetto]

secondo me
Prima di usare una funzione, il C deve riconoscere il tipo di ritorno e il
tipo dei parametri che la funzione si aspetta.

Lo standard ANSI del C ha introdotto un nuovo e migliore metodo per fare
questa dichiarazione rispetto alle precedenti versioni di C (ricordiamo
che tutte le nuove versioni del C aderiscono ora allo standard ANSI).

L'importanza della dichiarazione e' doppia:


viene fatta per avere un codice sorgente piu' strutturato e percio'
facile da leggere ed interpretare;
permette al compilatore C di controllare la sintassi delle chiamate di
funzioni.


Il modo in cui questo viene fatto dipende dallo scopo della funzione.
Fondamentalmente, se una funzione e' stata definita prima di essere usata
(call) allora e' possibile semplicemente usare la funzione. Nel caso
contrario, e' obbligatorio dichiarare la funzione; la dichiarazione
stabilisce in modo semplice il ritorno della funzione ed il tipo dei
parametri utilizzati da questa.

E' buona norma (e solitamente viene fatto) dichiarare tutte le funzioni
all'inizio del programma, sebbene non sia strettamente necessario.

Per dichiarare un prototipo di funzione bisogna semplicemente stabilire il
ritorno della funzione, il nome della funzione e tra le parentesi elencare
il tipo dei parametri nell'ordine in cui compaiono nella definizione di
funzione.

Ad esempio:
int strlen(char[]);

Questo dichiara che una funzione di nome "strlen" ritorna un valore integer
ed accetta una singola stringa come parametro.

Nota: le funzioni e le variabili possono essere dichiarate sulla stessa
linea di codice sorgente. Questa procedura era molto piu' diffusa
nei giorni del pre-ANSI C; da allora le funzioni solitamente vengono
dichiarate separatamente all'inizio del programma. La prima procedura
risulta ancora perfettamente valida, purche' venga rispettato l'ordine
in cui gli oggetti compaiono nella definizione della funzione.

Ad esempio:

int length, strlen(char[]);

dove "length" e' una variabile, e "strlen" e' la funzione (come
nell'esempio precedente).

[Fruttolo]

Adesso c'è n'altra cosa che non funzia... il pixellone sottostante non viene riconosciuto correttamente ... c'è un inversione della coordinata X con quella Y

Inverti i nomi di X e Y, facile

[Pierluigi]

?SYNTAX ERROR

[KymyA]

risolto... quasi...va tutto bene tranne... quando raggiunge un certo valore di coordinata che mi sballa tutto. avrò dimenticato il CARRY da qualche parte.
Io trovo molto stimolante e rilassante fare ste robe.
E' da stamattina che ci sbatto il crapino.
Non ne fotte un cazzo a nessuno?

Questa la routine che trasforma lo spazio 80x50 in coordinate video/colore: ($58 coordX; $59 coordY)
Per ora nessuna ottimizzazione: l'ho scritto di getto.

trasf_coord
	LDA $59
	CLC
	ROR
	CLC
	ROL
	TAX
	INX 
	LDA tabella_row,X
	STA posizione_schermo	
	STA posizione_colore	
	LDA tabella_row+1,X	
	ADC #$04	
	STA posizione_schermo+1	
	ADC #$D4	
	STA posizione_colore+1	
		
	LDA $58	
	CLC	
	ROR	
	STA $5A	
	LDA posizione_schermo	
	CLC	
	ADC $5A	
	BCC trasf_coord1	
	LDY posizione_schermo+1
	INY
	STY posizione_schermo+1			
trasf_coord1
	STA posizione_schermo
	; Stessa cosa per il colore
	LDA $58	
	CLC	
	ROR	
	STA $5A	
	LDA posizione_colore	
	CLC	
	ADC $5A	
	BCC trasf_coord2	
	LDY posizione_colore+1
	INY
	STY posizione_colore+1			
trasf_coord2
	STA posizione_colore
	RTS

tabella_row
	.byte $00,$00, $00,$28, $00,$50, $00,$78, $00,$A0, $00,$C8, $00,$F0, $01,$18, $01,$40, $01,$68, $01,$90, $01,$B8, $01,$E0
	.byte $02,$08, $02,$30, $02,$58, $02,$80, $02,$A8, $02,$D0, $02,$F8, $03,$20, $03,$48, $03,$70, $03,$98, $03,$C0			
 
posizione_schermo
	.byte 0,0 ; FalegnameGeppetto sukaminchia
	
posizione_colore
	.byte 0,0

[KymyA]

No... non va... ma vacca troia!

Superate le coord 11,11 si rincoglionisce ed ho notato che se vado in diagonale (0,0 - 1,1 - 2,2 - 3,3 ... ) ok, ma se plotto in 5,7 e poi in 6,8 swappa x con y
ma vaff

[Falegname Geppetto]

Hai seguito il mio tutorial? Dovrebbe funzionare...


Inviato dal mio iPhone utilizzando Tapatalk

[Pierluigi]

10 print ciao
20 goto 10
run

[gnappinox1]

Posto solo per dire che l'assembler è il linguaggio del demonio e che sono stato fortunato a studiarlo solo 1 anno, mi vengono ancora i brividi se ci penso

Inviato dal mio Nexus 7 utilizzando Tapatalk

[Recidivo]

Posto solo per dire che l'assembler è il linguaggio del demonio e che sono stato fortunato a studiarlo solo 1 anno, mi vengono ancora i brividi se ci penso

Inviato dal mio Nexus 7 utilizzando Tapatalk

Assembly.
prego.

Ecco mi hai fatto loggare da pc solo per poter indire tu come eretico della programmazione metterti all'indice e aspettare con calma che venga il tuo turno per arderti li, dove fu arso Savonarola.

tie'. immondo:

MY_ASM_START

rD   equ  r2
rN   equ  r7

ifdef x64
    num_VAR     equ r8
    table_VAR   equ r9
else
    data_size   equ (REG_SIZE * 5)
    crc_table   equ (REG_SIZE + data_size)
    num_VAR     equ [r4 + data_size]
    table_VAR   equ [r4 + crc_table]
endif

SRCDAT  equ  rN + rD + 4 *

CRC macro op:req, dest:req, src:req, t:req
    op      dest, DWORD PTR [r5 + src * 4 + 0400h * t]
endm

CRC_XOR macro dest:req, src:req, t:req
    CRC xor, dest, src, t
endm

CRC_MOV macro dest:req, src:req, t:req
    CRC mov, dest, src, t
endm

CRC1b macro
    movzx   x6, BYTE PTR [rD]
    inc     rD
    movzx   x3, x0_L
    xor     x6, x3
    shr     x0, 8
    CRC     xor, x0, r6, 0
    dec     rN
endm

MY_PROLOG macro crc_end:req
    MY_PUSH_4_REGS
    
    mov     x0, x1
    mov     rN, num_VAR
    mov     r5, table_VAR
    test    rN, rN
    jz      crc_end
  @@:
    test    rD, 7
    jz      @F
    CRC1b
    jnz     @B
  @@:
    cmp     rN, 16
    jb      crc_end
    add     rN, rD
    mov     num_VAR, rN
    sub     rN, 8
    and     rN, NOT 7
    sub     rD, rN
    xor     x0, [SRCDAT 0]
endm

MY_EPILOG macro crc_end:req
    xor     x0, [SRCDAT 0]
    mov     rD, rN
    mov     rN, num_VAR
    sub     rN, rD
  crc_end:
    test    rN, rN
    jz      @F
    CRC1b
    jmp     crc_end
  @@:
    MY_POP_4_REGS
endm

MY_PROC CrcUpdateT8, 4
    MY_PROLOG crc_end_8
    mov     x1, [SRCDAT 1]
    align 16
  main_loop_8:
    mov     x6, [SRCDAT 2]
    movzx   x3, x1_L
    CRC_XOR x6, r3, 3
    movzx   x3, x1_H
    CRC_XOR x6, r3, 2
    shr     x1, 16
    movzx   x3, x1_L
    movzx   x1, x1_H
    CRC_XOR x6, r3, 1
    movzx   x3, x0_L
    CRC_XOR x6, r1, 0

    mov     x1, [SRCDAT 3]
    CRC_XOR x6, r3, 7
    movzx   x3, x0_H
    shr     x0, 16
    CRC_XOR x6, r3, 6
    movzx   x3, x0_L
    CRC_XOR x6, r3, 5
    movzx   x3, x0_H
    CRC_MOV x0, r3, 4
    xor     x0, x6
    add     rD, 8
    jnz     main_loop_8

    MY_EPILOG crc_end_8
MY_ENDP

MY_PROC CrcUpdateT4, 4
    MY_PROLOG crc_end_4
    align 16
  main_loop_4:
    movzx   x1, x0_L
    movzx   x3, x0_H
    shr     x0, 16
    movzx   x6, x0_H
    and     x0, 0FFh
    CRC_MOV x1, r1, 3
    xor     x1, [SRCDAT 1]
    CRC_XOR x1, r3, 2
    CRC_XOR x1, r6, 0
    CRC_XOR x1, r0, 1
 
    movzx   x0, x1_L
    movzx   x3, x1_H
    shr     x1, 16
    movzx   x6, x1_H
    and     x1, 0FFh
    CRC_MOV x0, r0, 3
    xor     x0, [SRCDAT 2]
    CRC_XOR x0, r3, 2
    CRC_XOR x0, r6, 0
    CRC_XOR x0, r1, 1
    add     rD, 8
    jnz     main_loop_4

    MY_EPILOG crc_end_4
MY_ENDP

end

e si io mi ci sego su sta roba:

https://it.wikipedia.org/wiki/Assembly#C-asm

[Fruttolo]

FOT
TES
EGA
UNE
MER
ITA
NER
CHI
AHH

[gnappinox1]

Assembly.
prego.

Ecco mi hai fatto loggare da pc solo per poter indire tu come eretico della programmazione metterti all'indice e aspettare con calma che venga il tuo turno per arderti li, dove fu arso Savonarola.

cut...

C non sei stato il primo e non sarai l'ultimo, ma sarai sempre presente nel mio cuore.

Se dovessi camminare in una valle oscura, non temerei alcun assembler o garbage-collector, perché tu sei con me.
Infine quando un segmentation fault porrà fine alla mia esistenza terrena, finirò nei campi elisi,
un luogo ove una malloc non restituirà mai NULL e mi dimenticherò per sempre delle include guards.

Grazie al sacro GCC la mia parola verrà scritta una volta e compilata per tutte le macchine del mondo ti lascio questo esempio di riconciliazione

void mergesort(int *a, int *b, int l, int r){
  int i,j,k,m;
  if(r > l) {
    m = (r+l)/2;
    mergesort(a,b,l,m);
    mergesort(a,b,m+1,r);
    for(i = m+1; i > l; i--)
      b[i-1] = a[i-1];
    for(j = m; j < r; j++)
      b[r+m-j] = a[j+1];
    for(k = l; k <= r; k++)
      a[k] = b[i] < b[j] ? b[i++] : b[j--];
  }
}

void ordina(int *a, int l, int r)
{
  int *b = calloc(r - l + 1, sizeof(int));
  if(!b) { fprintf(stderr,"Errore di allocazione\n"); exit(-1); }
  mergesort(a,b,l,r);
  free(b);
}

E si, conosco come mischiare C ed Assembly, la cosa è figa, anche se non mi ha mai attirato più di tanto anche per lavorare con i singoli bit preferisco il C

[LordOrion]

Allora gente...
...so che MOLTO probabilmente fotterà una sega a tutti però ho scritto, da stamattina, una routine per Commodore64 che possa gestire una "grafica" in formato 80x50 usando i caratteri del C64.
La routine è:

SYS 49152,X,Y,Colore

con X da 0 a 79, Y da 0 a 49 e Colore da 0 a 15

La routine si occupa di
1. Controllare se la cella video dove verrà allocato il "pixellone" contiene già un carattere del set
2. Trasformare le coordinate passate in cella video ($0400-$07E
3. Calcolare il pixellone da accendere
4. Calcolare il nuovo carattere
5. Pokare il carattere ed il suo colore


Il problema è che c'è qualcosa che non va nei calcoli. Non so perché prima funzionava, poi da un certo punto mi sfasa il punto acceso. Inoltre il codice è auto-modificante per ottimizzare la dimensione ed i calcoli.
Qualcuno vuol dare un contributo?
Perché lo sto facendo? Così... per non perdere l'allenamento e perché voglio riprodurre un engine pseudo3d (tipo doom) su C64.

Ma se vuoi lavorare in grafica sul C64, perche' invece di usare quella merda di 80x50 non accedi alla memoria video direttamente tramite il VIC e ti spari i 320x200 ?

[Geralt di Rivia]

Recidivo, rinfrescami, tu eri spectrumiano o commodoriano?

[Recidivo]

Recidivo, rinfrescami, tu eri spectrumiano o commodoriano?

Ebbi il vic20 bianco e lindo immacolato.
Passai al c64 marroncino con sommo gaudio e da lì partii con la programmazione in BASIC .
Era il 1984 e leggevo:


Però con lo spectrum ci giocavo a casa di un mio amico, che poi in fine mi ha donato.

[Recidivo]

C non sei stato il primo e non sarai l'ultimo, ma sarai sempre presente nel mio cuore.

Se dovessi camminare in una valle oscura, non temerei alcun assembler o garbage-collector, perché tu sei con me.
Infine quando un segmentation fault porrà fine alla mia esistenza terrena, finirò nei campi elisi,
un luogo ove una malloc non restituirà mai NULL e mi dimenticherò per sempre delle include guards.

Grazie al sacro GCC la mia parola verrà scritta una volta e compilata per tutte le macchine del mondo ti lascio questo esempio di riconciliazione

void mergesort(int *a, int *b, int l, int r){
  int i,j,k,m;
  if(r > l) {
    m = (r+l)/2;
    mergesort(a,b,l,m);
    mergesort(a,b,m+1,r);
    for(i = m+1; i > l; i--)
      b[i-1] = a[i-1];
    for(j = m; j < r; j++)
      b[r+m-j] = a[j+1];
    for(k = l; k <= r; k++)
      a[k] = b[i] < b[j] ? b[i++] : b[j--];
  }
}

void ordina(int *a, int l, int r)
{
  int *b = calloc(r - l + 1, sizeof(int));
  if(!b) { fprintf(stderr,"Errore di allocazione\n"); exit(-1); }
  mergesort(a,b,l,r);
  free(b);
}

E si, conosco come mischiare C ed Assembly, la cosa è figa, anche se non mi ha mai attirato più di tanto anche per lavorare con i singoli bit preferisco il C

Oh e non ci dovrebbe essere bisogno di dire che scherzavo, perché vedo che l'hai presa come dovrebbe.
;-)