6502 problemi assemblatore di numeri casuali

Question

sto giocando intorno con 6502 assembler qui: http://skilldrick.github.io/easy6502

ho fatto questa che mette solo un pixel di colore casuale in un posto a caso sullo schermo:

LDY #$00 ; Clear Y 

loop: 
JSR genPos ; Put new position in memory 
LDA $fe ; Get random number for color 
STA ($10), Y ; Put pixel on screen 
JMP loop 

genPos: 
STA $10 ; Store accumulator in low 
LDA $fe ; Get new random number (WHY, oh why?) 
AND #$03 ; Mask out low two bits (=numbers 0-3) 
CLC  ; Clear carry flag 
ADC#2  ; Add 2 (= numbers 2-5) 
STA $11 ; Store number in high 
RTS 

Sono cercando di utilizzare il minor numero possibile di istruzioni. Il mio problema è che se non metto un extra LDA $fe nella sub routine genPos i pixel sono disegnati in un modello molto strano dove se ho l'addizionale LDA il codice funziona perfettamente. Non riesco a capire perché - qualcuno può darmi un suggerimento?

saluti, Jacob

Answer 1

Sta già facendo un buon byte basso! Questa linea:

LDA $fe ; Get new random number (WHY, oh why?) 

prosegue per decidere alto Byte , e se non si genera un nuovo numero casuale, il valore y dipenderà i più bassi due bit del valore x, causando le diagonali che stai vedendo: il valore di x & 3 è sempre uguale quale segmento dello schermo il valore è in corso di elaborazione su, il che significa che si ottiene un modello come

█ █ █ █ █ █ █ █ \ 
█ █ █ █ █ █ █ █  | 
█ █ █ █ █ █ █ █  | x & 3 == 0 in $200-$2FF 
█ █ █ █ █ █ █ █  | 
█ █ █ █ █ █ █ █ /
█ █ █ █ █ █ █ █ \ 
█ █ █ █ █ █ █ █ | 
█ █ █ █ █ █ █ █ | x & 3 == 1 in $300-$3FF 
█ █ █ █ █ █ █ █ | 
█ █ █ █ █ █ █ █ /
    █ █ █ █ █ █ █ █ \ 
    █ █ █ █ █ █ █ █ | 
    █ █ █ █ █ █ █ █ | x & 3 == 2 in $400-$4FF 
    █ █ █ █ █ █ █ █ | 
    █ █ █ █ █ █ █ █/
    █ █ █ █ █ █ █ █ \ 
    █ █ █ █ █ █ █ █ | 
    █ █ █ █ █ █ █ █ | x & 3 == 3 in $500-$5FF 
    █ █ █ █ █ █ █ █ | 
    █ █ █ █ █ █ █ █/

Answer 2

L'algoritmo applicato con la LDA è:

[random 1] -> [11:10] 
[random 1] -> [10] 
[random 2]&3 + 2 -> [11] 
(repeat) 

Se non si riesce a ricaricare a da $ fe allora stai facendo:

[random 1] -> [11:10] 
[ramdom 1] -> [10] 
[random 1]&3 + 2 -> [11] 
(repeat) 

Pertanto sia il byte basso che quello alto del pixel indirizzato è una funzione dello stesso numero casuale. Non sono indipendenti. Ciò crea una correlazione tra di loro. Che si manifesta nello schema che vedi. Se il tuo schermo fittizio fosse largo 256 pixel sarebbe una diagonale diretta; in base al fatto che vedi 8 strisce, posso dedurre che il tuo output deve essere in realtà 256/8 = 32 pixel di larghezza.

Il problema non è che tu abbia torto a dire che "il numero casuale nell'accumulatore ... dovrebbe fare un buon byte basso per l'indirizzo dello schermo". è che lo stai usando anche per il byte alto. Lo stai usando per entrambi. Il byte alto è una funzione diretta del byte basso. Quindi ci sono un sacco di byte alti che non colpiranno mai perché non soddisfano il vincolo che è high=(low&3)+2. Quei pixel rimangono spenti.