Memory struggle

I have really struggled to do ROM to RAM mapping on the C64 and Atari 8-bit. The processes is very much alike, between the two systems. The problem is making the process consistent. Additionally, re-running the same program with the same memory calls causes crashes. I have in the time being just made 1.1 versions very simple. I wanted to use the same graphics that I made for the TI-99/4A. In theory that is possible. I just have not been able to consistently do so.

My compromise:

Instead of using this code:

100 MEMTOP=PEEK(106) 

110 GRTOP=MEMTOP-4 

120 POKE 106,GRTOP

140 GRAPHICS 0 

160 CHROM=PEEK(756)*256 

170 CHRAM=GRTOP*256 

500 FOR N=0 TO 1023 

510 POKE CHRAM+N,PEEK(CHROM+N) 

520 NEXT N 

540 POKE 756,GRTOP

Preview screenshots of Dragon and Dice 1.1

Just posting some progress screen shots of Dragon and Dice 1.1 shown on TI-99/4A 

Screen shot of Atari 800XL

Working on version 1.1 D&D dice program

So the basic logic is laid out for rolling different D&D dice and has been completed. Now to make the program a little nicer for the Atari, C64, and TI-99/4A computers. So I'm going to make the dice graphical.   I may make this app available for every possible platform I can program on. Below is the layout of the 6 sided (6D) dice I did tonight with just a text editor. 

TI-dice

call char(33,"0101010101010101")

char !=33
12341234
_______x 1 01  
_______x 2 01  
_______x 3 01
_______x 4 01
_______x 5 01 
_______x 6 01
_______x 7 01
_______x 8 01

call char(42,"00000708102040FF")
call char(43,"0000FC0C14244484")

char *=42        char +=43          
12341234         12341234
________  1 00   ________  1 00
________  2 00   ________  2 00 
     xxx  3 07   xxxxxx__  3 FC
____x___  4 08       xx__  4 0C
___x____  5 10      x x__  5 14
__x_____  6 20     x  x__  6 24
_x______  7 40    x   x__  7 44
xxxxxxxx  8 FF   x    x__  8 84


call char(64,"8585858991A1C181")

                 char @=64
                 12341234
                 x    x x  1 85
                 x    x x  2 85
                 x    x x  3 85
                 x   x  x  4 89
                 x  x   x  5 91
                 x x    x  6 A1
                 xx     x  7 C1
                 x      x  8 81

call char(94,"FF")

char ^=94
12341234
xxxxxxxx  1 FF

call char(36,"8080808080808080") 

char $
12341234
x         1 80
x         2 80
x         3 80
x         4 80
x         5 80
x         6 80
x         7 80 
x         8 80

Simple D&D dice roller for C64, Atari XL, and TI-99/4A (Ver 1.0)

I only tested this code with the C64, Atari XL and TI-99/4a (standard basic).
This will likely work on more platforms with little or no modifications
See the note on the bottom for the TI-99/4A.

Atari 800XL output

TI-99/4A output

Code for C64 AND ATARI

10 PRINT "DRAGON AND DICE"
20 PRINT "A) ROLL 4D"
30 PRINT "B) ROLL 6D"
40 PRINT "C) ROLL 8D"
50 PRINT "D) ROLL 10D"
60 PRINT "E) ROLL 12D"
70 PRINT "F) ROLL 20D"
80 PRINT "G) ROLL FOUR 6D"
85 PRINT "Z) QUIT"
90 INPUT A$
100 IF A$="A" THEN 200
110 IF A$="B" THEN 300
120 IF A$="C" THEN 400
130 IF A$="D" THEN 500
140 IF A$="E" THEN 600
150 IF A$="F" THEN 700
160 IF A$="G" THEN 800
170 IF A$="Z" THEN 1000
180 PRINT "----"
190 GOTO 10
200 D=INT(1+4*RND(1))
210 PRINT "YOU ROLLED A "
220 PRINT D
230 PRINT "WITH 4D"
240 PRINT "--"
250 GOTO 10
300 D=INT(1+6*RND(1))
310 PRINT "YOU ROLLED A "
320 PRINT D
330 PRINT "WITH 6D"
340 PRINT "--"
350 GOTO 10
400 D=INT(1+8*RND(1))
410 PRINT "YOU ROLLED A "
420 PRINT D
430 PRINT "WITH 8D"
440 PRINT "--"
450 GOTO 10
500 D=INT(1+10*RND(1))
510 PRINT "YOU ROLLED A "
520 PRINT D
530 PRINT "WITH 10D"
540 PRINT "--"
550 GOTO 10
600 D=INT(1+12*RND(1))
610 PRINT "YOU ROLLED A "
620 PRINT D
630 PRINT "WITH 12D"
640 PRINT "--"
650 GOTO 10
700 D=INT(1+20*RND(1))
710 PRINT "YOU ROLLED A "
720 PRINT D
730 PRINT "WITH 20D"
740 PRINT "--"
750 GOTO 10
800 D1=INT(1+6*RND(1))
802 D2=INT(1+6*RND(1))
804 D3=INT(1+6*RND(1))
806 D4=INT(1+6*RND(1))
810 PRINT "YOU ROLLED A "
820 PRINT D1;" ";D2;" ";D3;" ";D4
830 PRINT "WITH FOUR 6D"
840 PRINT "--  --  --  --"
850 GOTO 10
1000 END

For the TI-99/4A computer, change the randomize calls with this format: 

D=INT(1+4*RND)
D=INT(1+6*RND)

ugBASIC 1.17.1 RELEASED

ugBASIC 1.17.1 RELEASED!

A new version of ugBASIC, the open source isomorphic BASIC compiler, has been released.

This version for multiple compliable computer ports 

ATARI 400/800/XL/XEGS implements an improved DOJO protocol, allowing for multiplayer games thanks to the integration with FujiNet. It also contains numerous additional keywords, serial support, and specific optimizations for ATARI computers.

Full list of Atari supported:

Atari 400, 

Atari 800

Atari 1200XL, 

Atari 130XE, 

Atari 600XL, 

Atari 65XE, 

Atari 800XE, 

Atari 800XL, 

Atari XEGS

Commodore 64 and Commodore VIC-20, in addition to containing numerous corrections and implementations, has many new instructions related to joystick movement, text positioning and character detection. It is now possible to define functions and perform sums and counts on arrays.

ugBASIC is a cross compiler for Linux and Windows, for writing games in the BASIC language, running on dozens of different home computers and 8-bit consoles. There is also a convenient integrated IDE for Microsoft Windows and even a sandbox, if you do not want to install anything.