Here is an improved proof of concept for the C64. Still different from the TI-99/4A,
but still the same concept and more detailed than yesterday's post.
So, so much more work than needed on the TI-99/4A just to get the same result
on the C64.
10 print chr$(147)
100 rem copy rom routine
105 for i=0 to 26: read x: poke 828+i,x: next i
110 data 169,000,160,208,133,095,132,096 : rem LDA #0; LDY #$D0; STA 95, STY 96
115 data 169,000,160,224,133,090,132,091 : rem LDA #0; LDY #$E0; STA 90; STY 91
120 data 169,000,160,064,133,088,132,089 : rem LDA #0; LDY #$40; STA 88; STY 89
125 data 076,191,163 : rem JMP $A3BF
130 rem COPY $D000-$DFFF -> $3000-$3FFF
135 rem move char set rom into ram
140 poke 56334,peek(56334) and 254 : rem INTERRUPT OFF
145 poke 1,peek(1) and 251 : rem CHAR SET ROM ON
150 sys 828 : rem START COPY
155 poke 1,peek(1) or 4 : rem CHAR SET ROM OFF
160 poke 56334,peek(56334) or 1 : rem INTERRUPT ON
165 poke 53272,peek(53272) and 240 or 12 : rem CHAR SET RAM AT $3000
170 rem rewrite char [
175 for a=12504 to 12511: read ze: poke a,ze: poke a+1024,255-ze: next a
180 rem rewrite char #
185 for a=12568 to 12575: read ze: poke a,ze: poke a+1024,255-ze: next a
190 rem rewrite char &
195 for a=12592 to 12599: read ze: poke a,ze: poke a+1024,255-ze: next a
200 rem rewrite char ]
205 for a=12520 to 12527: read ze: poke a,ze: poke a+1024,255-ze: next a
210 rem rewrite char (
215 for a=12608 to 12615: read ze: poke a,ze: poke a+1024,255-ze: next a
220 rem rewrite char !
225 for a=12552 to 12559: read ze: poke a,ze: poke a+1024,255-ze: next a
230 rem rewrite char %
235 for a=12584 to 12591: read ze: poke a,ze: poke a+1024,255-ze: next a
240 rem rewrite char )
245 for a=12616 to 12623: read ze: poke a,ze: poke a+1024,255-ze: next a
700 data 15,16,32,64,255,128,128,128
710 data 128,128,128,128,128,128,128,128
720 data 128,128,128,128,128,128,128,255
730 data 255,0,0,0,255,0,0,0
740 data 0,0,0,0,0,0,0,255
750 data 255,3,5,9,241,17,17,17
760 data 17,17,17,17,17,17,17,17
770 data 17,17,17,17,18,20,24,240
800 print " []! []! "
810 print " #5% #2%"
820 print " &() &()"
Programming 6 sided dice
16318421 16318421
2426 2426
8 8
12345678 12345678
1 xxxx xxxxxxxx xxxxxxxx 15, 255, 255
2 x . xx 16, 0, 3
3 x . x x 32, 0, 5
4 x . x x 64, 0, 9
5 xxxxxxxx xxxxxxxx xxxx x 255, 255, 241 1+16+32+64+128
6 x . x x 128, 0, 17
7 x . x x 128, 0, 17
8 x x x 128, 0, 17
char=[ char=] char=!
1 x x x 128, 17
2 x x x 128, 17
3 x x x 128, 17
4 x x x 128, 17
5 x x x 128, 17
6 x x x 128, 17
7 x x x 128, 17
8 x x x 128, 17
char=# char=%
1 x x x 128, 0, 17
2 x x x 128, 0, 17
3 x x x 128, 0, 17
4 x x x 128, 0, 17
5 x x x 128, 0, 18
6 x x x 128, 0, 20
7 x xx 128, 0, 24
8 xxxxxxx xxxxxxxx xxxxx 255, 255, 240 16+32+64+128
char=& char=( char=)
12504 12505 12506 12507 12508 12509 12510 12511 -> [
12512 12513 12514 12515 12516 12517 12518 12519 -> English pound or (carrot vice)
12520 12521 12522 12523 12524 12525 12526 12527 -> ]
12528 12529 12530 12531 12532 12533 12534 12535 -> Up arrow
12536 12537 12538 12539 12540 12541 12542 12543 -> left arrow
12544 12545 12546 12547 12548 12549 12550 12551 -> space
12552 12553 12554 12555 12556 12557 12558 12559 -> !
12560 12561 12562 12563 12564 12565 12566 12567 -> "
12568 12569 12570 12571 12572 12573 12574 12575 -> #
12576 12577 12578 12579 12580 12581 12582 12583 -> $
12584 12585 12586 12587 12588 12589 12590 12591 -> %
12592 12593 12594 12595 12596 12597 12598 12599 -> &
12600 12601 12602 12603 12604 12605 12606 12607 -> '
12608 12609 12610 12611 12612 12613 12614 12615 -> (
12616 12617 12618 12619 12620 12621 12622 12623 -> )
