Quanto tempo free ha kymya?
Mentre lavori dico
Visualizzazione Stampabile
Quanto tempo free ha kymya?
Mentre lavori dico
Perchè NO.Citazione:
Originariamente Scritto da LordOrion
Mi è venuta 'sta cosa così... tanto per...
lo trovo stimolante.
Ho QUASI risolto tutto. Non ho capito perché se supero le coordinate 11 si rincoglionisce... forse la tabella dove ho mappato le singole righe per velocizzare avrò sbagliato qualcosa.
Avevo pensato di prendere il numero di riga e moltiplicarlo per 40. Per velocizzare la moltiplicazione per 40, posso sommare due moltiplicazioni: una per 32 (che corrisponde a 5 ROL) ad una per 8 (che corrisponde a 3 ROL). Quindi far fare 3 ROL, memorizzare il valore risultante, altri 2 ROL e sommare con il valore memorizzato.
Lavoro su minimo 3 pc alla volta (2 fisici dai quali mi collego ad almeno 3 VM contemporaneamente) e comunque ogni tanto mi trovo ad aspettare le macchine. O alla pausa pranzo...Citazione:
Originariamente Scritto da fulviuz
Certo, considera che stavo per addormentarmi, ho visto la notifica, letto il messaggio mi sono scompisciato dal ridere :rullezza::rotfl: ed ho acceso il pc per rispondere più o meno a tono :asd::asd:Citazione:
Originariamente Scritto da Recidivo
Dunque... so che continuerete a sbattervene il cazzo però...
...adesso la routine di plot 80x50 FUNZIONA!!!!
Adesso sto scrivendo la routine per tracciare una linea tra due punti utilizzando l'algoritmo di Bresenham che mi pare molto veloce.
E' troppo divertente! Cmq la parte per plottare il singolo punto è lunga 380byte circa comprese tabelle e buffer.
Avevo trovato un suo vecchio gioco in una compialtion su cassetta (di quelle da edicola) ai tempi del C64 :uhm:Citazione:
Originariamente Scritto da ABS
Mi potete aiutare su una questione matematica (byte signed)???
Vabbè, praticamente ho ottenuto e memorizzato il valore assoluto del delta tra due coordinate ( praticamente ABS(x2-x1) ) come byte signed.
Adesso devo calcolare il valore negativo. Come si fa?
praticamente ho:
A = ABS(X2-X1)
B = ABS(Y2-Y1)
C = -ABS(Y2-Y1) = -B
Avendo A e B, come calcolo C?
(tenete presente che i byte sono signed, quindi da -127 a 128 come valore e
00000010 = +2
00000001 = +1
00000000 = 0
11111111 = -1
11111110 = -2)
https://it.wikipedia.org/wiki/Complemento_a_dueCitazione:
Originariamente Scritto da KymyA
C = ( 0 - B )
cazzo che soluzione semplice ed elegante!
grazie bellooohhh!
Ti mando il prg compilato appena finito.
Ciao Lord...
tu che sei bravo e mi capisci, se volessi "assemblerizzare" questa formula :
potrei scrivere, considerando che sono byte signed :Codice:x= x + q
y= y + s
d= d + 2 * (a + b)
???Codice:LDA line_x
CLC
ADC line_Q
STA line_X
LDA line_Y
CLC
ADC line_S
STA line_Y
LDA line_A
CLC
ADC line_B
CLC
ROL
ADC line_D
STA line_D
Perché ho "tradotto" tutto l'algoritmo ma mi spara punti a capocchia. Non ho mai "lavorato" con byte signed!
Kymy, vado a "rimembranze" in quanto e' una vita che non smanetto l'assembly del 6510, ma se non sbaglio l'ALU della cpu gestisce da sola l'artimetica signed. Dai una occhiata al manuale del set di instruzioni.
A occhio e croce direi che va bene :uhm:Citazione:
Originariamente Scritto da KymyA
Prendi questo parere con molta fotteseganzaCitazione:
Originariamente Scritto da KymyA
https://www.c64-wiki.com/wiki/ROL
Doubling signed integers in this way requires programming efforts to keep the sign bit from mixing with the other bits, causing erratic sign-changes.
Invece credo sia corretto: Usare lo shift per moltiplicare per due rischia di far uscire il bit di segno, es:Citazione:
Originariamente Scritto da Fruttolo
ROL 10001011 = 00010110!!
prova cosi:
Codice:LDA line_x // A <-X
CLC
ADC line_Q: // A = A + Q
STA line_X: // Q = A
LDA line_Y // A = Y
CLC
ADC line_S // A = A + S
STA line_Y // Y = A
LDA line_A // A = a
CLC
ADC line_B // A = A + B
CLC
STA temp // temp = A
ADC temp // A = A + temp (= 2 * A )
CLC
ADC line_D // A = A + D
STA line_D // D = A
inutile.... l'assembly è ELEGANTE. Bella soluzione. invece di ROLlare, sommare a se stesso... provo...
Bof, la soluzione "elegante" si comporterebbe in modo diverso a seconda del fatto che l'operando e' positivo o negativo. Sommare se stesso e' un trick ma non la cosa piu' efficente: 3 isturzioni contro 1 del ROL e un byte di memoria extra.Citazione:
Originariamente Scritto da KymyA
Codice:LDA line_x // A <-X
CLC
ADC line_Q: // A = A + Q
STA line_X: // Q = A
LDA line_Y // A = Y
CLC
ADC line_S // A = A + S
STA line_Y // Y = A
LDA line_A // A = a
CLC
ADC line_B // A = A + B
BMI negative
CLC
ROL
JMP end
negative:
CLC
STA temp // temp = A
ADC temp // A = A + temp (= 2 * A )
end:
CLC
ADC line_D // A = A + D
STA line_D // D = A
ottimizzo dopo.
continua a non funzionare. vediamo se riesco a debuggare in qualche modo.
Sto utilizzando Relaunch64 (Java) come IDE (DASM) e Vice.
Sotto di BREAK e Z ... è l'unica strada per giungere alla soluzione. Rottura di palle, ma stimolante.
Fino al calcolo della d, tutto ok...
Dai... che sento che la soluzione è sotto mano dai!
Mi sa che l'algoritmo è come al cazzo. controllato uno step alla volta e, almeno l'unico caso provato, quello che ho scritto segue l'algoritmo:
preso da qui : https://it.wikipedia.org/wiki/Algori...a_di_BresenhamCodice:swap = 0;
DX = x2 - x1;
DY = y2 - y1;
//siccome scambio DY e DX ho sempre DX>=DY allora per sapere quale coordinata occorre cambiare uso una variabile
if (abs(DX) < abs(DY)) {
swap(DX, DY);
swap = 1;
}
//per non scrivere sempre i valori assoluti cambio DY e DX con altre variabili
a = abs(DY);
b = -abs(DX);
//assegna le coordinate iniziali
x = x1;
y = y1;
//il nostro valore d0
d = 2 * a + b;
//s e q sono gli incrementi/decrementi di x e y
q = 1;
s = 1;
if (x1 > x2) q = -1;
if (y1 > y2) s = -1;
disegna_punto(x, y);
disegna_punto(x2, y2);
for (k = 0; k < -b; k+=1) {
if (d > 0) {
x= x + q; y= y + s;
d= d + 2 * (a + b);
}
else {
x = x + q;
if (swap==1) { y = y + s; x = x - q; }
d = d + 2 * a;
}
disegna_punto(x, y);
}
(nb: provata in vb, funziona. quindi l'algoritmo è ok)