W atari odmierzać dokładny czas jest bardzo trudno, bo cykle procesora są bezustannie wywłaszczane przez pokaźną liczbę przeszkadzajek, więc liczenie cykli daje różne rezultaty w różnych warunkach. Proponowałbym dwa rozwiązania:
1) rejestr VCOUNT, który w systemie PAL co ramkę (1/50s) liczy od 0 do 155.
2) przerwania POKEYa. Jeśli się nie mylę, to jak to ma być opóźnienie, to nawet nie trzeba używać przerwań: można je wyłączyć przez SEI i pollować rejestr IRQST czekając na skasowanie bitu odpowiadającego danemu przerwaniu.

A w win7 jest w ogóle Quick Launch? Przypinanie programów do paska zadań doskonale go zastępuje i jest nawet lepsze. Trochę może irytować, że ikony odpalonych programów nie różnią się właściwie od nieodpalonych, ale na szczęście w opcjach można łatwo przełączyć, żeby uruchomiona aplikacja wyglądała jak na starszych windowsach (żeby poza ikoną miała też nazwę itd). Po zmniejszeniu ikon pasek zadań wygląda praktycznie identycznie jak dawniej, tylko pokazywanie pulpitu jest koło zegarka :)

Takiemu to się powodzi ;)

Ja sobie kupie jak się pojawi, bo mi się podoba. Teraz siedzę na RC i nie miałem żadnych problemów. Wg mnie 7 ma najbardziej dopracowany UI (dopinanie aplikacji do paska zadań zamiast quicklauncha jest miodzio) i nawet zostawiłem sobie te szkło i aero (tylko odchudzone o wszystkie rozmywania i przenikania, żeby reakcja systemu była percepcyjnie szybsza), bo wszystko fajnie współgra. A trzeba pamiętać, że jako stary oldschoolowiec we wcześniejszych systemach tępiłem wszelkie wodotryski i miałem ustawiony klasyczny wygląd z win2k (vistę też dało się tak skonfigurować).

Oczywiście jak ktoś z góry ma nastawienie "M$ SUXX" to i siódemka go nie przekona

No to niech oryginalna "powolna" pamięć atari nie będzie na stałe w banku zerowym, tylko niech będzie dowolnie przełączana w dowolny bank przykrywając szybki bank jaki tam był (lub niech wypełnia pustą przestrzeń jeśli byłaby wmapowana w nieużywany obszar). Po przełączeniu jej wyżej mamy szybki bank zerowy, a wciąż mamy dostęp do pamięci atari tylko w innym miejscu. Jeszcze jakby można było tak zrobić osobno dla odczytu i dla zapisu to byłoby super (scenariusz: ustawiamy pamięć atari w banku zerowym dla zapisu i gdzieś wyżej dla odczytu. W rezultacie czytając z banku zerowego czytamy z pamięci szybkiej, a zapisując zapisujemy wolno do atari. Takim trikiem można w błyskawicznym tępie przepisać blok z pamięci szybkiej do atari).

Chodziło mi o rozpisanie wejścia _enter tak, aby nie robić tego jsr:

_enter
    ldx _d
    lda t3-$e0,x
    sta _d
    cmp t4-$e0,x
    bcc _d1
    rts

_enter2
    ldx _d
    lda t1-$e0,x
    sta _d
    cmp t2-$e0,x
    bcc _d1
    rts

_d1 lda #$20
    adc _e
    sta _e
    bcs _d2
    lda _d
    adc #-$08
    sta _d
_d2 rts
;
t1      dta $e2,$e3,$e4,$e5,$e6,$e7,$e8,$e9,$ea,$eb,$ec,$ed,$ee,$ef
        dta $f0,$f1,$f2,$f3,$f4,$f5,$f6,$f7,$f8,$f9,$fa,$fb,$fc
t2      dta $e2,$e3,$e4,$e5,$e6,$e7,$FF,$FF,$ea,$eb,$ec,$ed,$ee,$ef
        dta $FF,$FF,$f2,$f3,$f4,$f5,$f6,$f7,$FF,$FF,$fa,$fb,$fc

t3      dta $e4,$e5,$e6,$e7,$e8,$e9,$ea,$eb,$ec,$ed,$ee,$ef,$f0,$f1
        dta $f2,$f3,$f4,$f5,$f6,$f7,$f8,$f9,$fa,$fb,$fc,$fd,$fe
t4      dta $e4,$e5,$e6,$e7,$FF,$FF,$FF,$FF,$ec,$ed,$ee,$ef,$FF,$FF
        dta $FF,$FF,$f4,$f5,$f6,$f7,$FF,$FF,$FF,$FF,$fc,$fd,$fe

Jeżeli masz 512 bajtów miejsca na tablice (lub mniej jeżeli |Dom(_d)| < 256) to można trochę potablicować. Jeżeli nigdzie się nie walnąłem, to można tak:

_enter jsr _enter2
_enter2              
              
    ldx _d
    lda t1,x
    sta _d
    cmp t2,x
    bcc _d1
    rts
_d1 lda #$20
    adc _e
    sta _e
    bcs _d2
    lda _d
    adc #-$08
    sta _d
_d2 rts
    
; x:      0,1,2,3,4,5,6,7, 8, 9,10,11,12,13,14,15,16,17,18,19,20    
t1  .byte 2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22
t2  .byte 2,3,4,5,6,7,0,0,10,11,12,13,14,15, 0, 0,18,19,20,21,22

Idea jest taka, że wspomniana procedura jest wołana 2 lub 4 razy, można więc zamknąć dwa wywołania w jednym. t1[x] == x + 2. Na każde dwa pierwotne wywołania _e jest modyfikowane maksymalnie raz i to wtedy, gdy _d & 7 == (6 lub 7). Do tej decyzji służy tablica t2, która dodatkowo determinuje wartość flagi C: t2[x] < t1[x] gdy _d & 7 == (6 lub 7), t2[x] >= t1[x] wpp. Drugi trick, (który jest niezależny) pomaga zaoszczędzić 7/32 cyklu: jest większe prawdopodobieństwo, że _e się nie przepełni, niż to, że się przepełni, więc bardziej prawdopodobna ścieżka powinna być krótsza, czyli skok powinien być wykonywany gdy się przepełni.

EDIT:

Jeżeli _enter jest wołane często, a masz dodatkowe 512 bajtów, to można spreparować tablice dla wywołania podwójnego (poczwórnego dla oryginalnego algorytmu). t1'[x] == x + 4; t2'[x] < t1'[x] gdy _d & 7 in {4,5,6,7}; t2'[x] >= t1'[x] wpp.

offtopic: Miałem ją na kasecie. Zarąbista! Szkoda, że nie ma działającej file'ówki.

Chyba, że mówimy o prawdziwym literlace Rybagsa :)

No właśnie ja jade, ale nie wiem jeszcze czy sam czy uda mi się kogoś wyciągnąć, a skoro jedno miejsce, to nie odzywam się dopóki nie okaże się, czy jadę sam :)

Lynx Developer Docs