mirror of
https://github.com/deater/dos33fsprogs.git
synced 2024-11-04 20:06:09 +00:00
1829 lines
27 KiB
C
1829 lines
27 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
|
|
#include <SDL.h>
|
|
|
|
#include "gr-sim.h"
|
|
#include "tfv_zp.h"
|
|
#include "6502_emulate.h"
|
|
|
|
#include "apple2_font.h"
|
|
|
|
/* 280x192 hi-res mode */
|
|
#define HGR_XSIZE 280
|
|
#define HGR_YSIZE 192
|
|
#define HGR_X_SCALE 2
|
|
#define HGR_Y_SCALE 2
|
|
|
|
/* 40x48 low-res mode */
|
|
#define GR_XSIZE 40
|
|
#define GR_YSIZE 48
|
|
#define GR_X_SCALE 14
|
|
#define GR_Y_SCALE 8
|
|
|
|
/* 40 column only for now */
|
|
#define TEXT_XSIZE 40
|
|
#define TEXT_YSIZE 24
|
|
#define TEXT_X_SCALE 14
|
|
#define TEXT_Y_SCALE 16
|
|
|
|
static int xsize=GR_XSIZE*GR_X_SCALE;
|
|
static int ysize=GR_YSIZE*GR_Y_SCALE;
|
|
|
|
static int debug=0;
|
|
|
|
/* Zero page addresses */
|
|
#define WNDLFT 0x20
|
|
#define WNDWDTH 0x21
|
|
#define WNDTOP 0x22
|
|
#define WNDBTM 0x23
|
|
#define CH 0x24
|
|
#define CV 0x25
|
|
#define GBASL 0x26
|
|
#define GBASH 0x27
|
|
#define BASL 0x28
|
|
#define BASH 0x29
|
|
#define BAS2L 0x2A
|
|
#define BAS2H 0x2B
|
|
#define H2 0x2C
|
|
#define V2 0x2D
|
|
#define MASK 0x2E
|
|
#define COLOR 0x30
|
|
#define INVFLG 0x32
|
|
#define YSAV 0x34
|
|
#define YSAV1 0x35
|
|
#define CSWL 0x36
|
|
#define CSWH 0x37
|
|
#define FIRST 0xF0
|
|
#define SPEEDZ 0xF1
|
|
#define FLASH 0xF3
|
|
#define TEMP 0xFA
|
|
|
|
static int text_mode=0xff;
|
|
static int text_page_1=0x00;
|
|
static int hires_on=0x00;
|
|
static int mixed_graphics=0xff;
|
|
|
|
static int plaid_mode=0;
|
|
|
|
void set_plaid(void) {
|
|
plaid_mode=1;
|
|
}
|
|
|
|
void clear_plaid(void) {
|
|
plaid_mode=0;
|
|
}
|
|
|
|
void soft_switch(unsigned short address) {
|
|
|
|
switch(address) {
|
|
case TXTCLR: // $c050
|
|
text_mode=0x00;
|
|
break;
|
|
case TXTSET: // $c051
|
|
text_mode=0xff;
|
|
break;
|
|
case MIXCLR: // $c052
|
|
mixed_graphics=0x00;
|
|
break;
|
|
case MIXSET: // $c053
|
|
mixed_graphics=0xff;
|
|
break;
|
|
case LOWSCR: // $c054
|
|
text_page_1=0x00;
|
|
break;
|
|
case HISCR: // $c055
|
|
text_page_1=0xff;
|
|
break;
|
|
case LORES: // $c056
|
|
hires_on=0x00;
|
|
break;
|
|
case HIRES: // $c057
|
|
hires_on=0xff;
|
|
break;
|
|
default:
|
|
fprintf(stderr,"Unknown soft switch %x\n",address);
|
|
break;
|
|
}
|
|
}
|
|
|
|
int soft_switch_read(unsigned short address) {
|
|
|
|
switch(address) {
|
|
case TEXT_RD: // $c01a
|
|
return text_mode;
|
|
case MIXED_RD: // $c01b
|
|
return mixed_graphics;
|
|
case PAGE2_RD: // $c01c
|
|
return text_page_1;
|
|
case HIRES_RD: // $c01d
|
|
return hires_on;
|
|
default:
|
|
fprintf(stderr,"Unknown soft switch read %x\n",address);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static SDL_Surface *sdl_screen=NULL;
|
|
|
|
int grsim_input(void) {
|
|
|
|
SDL_Event event;
|
|
int keypressed;
|
|
|
|
|
|
while ( SDL_PollEvent(&event)) {
|
|
|
|
switch(event.type) {
|
|
|
|
case SDL_KEYDOWN:
|
|
keypressed=event.key.keysym.sym;
|
|
switch (keypressed) {
|
|
|
|
case SDLK_ESCAPE:
|
|
return 27;
|
|
case 'a'...'z':
|
|
case 'A'...'Z':
|
|
return keypressed;
|
|
case SDLK_UP:
|
|
return 11;
|
|
case SDLK_DOWN:
|
|
return 10;
|
|
case SDLK_RIGHT:
|
|
return 21;
|
|
case SDLK_LEFT:
|
|
return 8;
|
|
default:
|
|
printf("Unknown %d\n",keypressed);
|
|
return keypressed;
|
|
}
|
|
break;
|
|
|
|
|
|
case SDL_JOYBUTTONDOWN:
|
|
case SDL_JOYAXISMOTION:
|
|
printf("Joystick!\n");
|
|
break;
|
|
|
|
default:
|
|
printf("Unknown input action!\n");
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static unsigned int color[16]={
|
|
0, /* 0 black */
|
|
0xe31e60, /* 1 magenta */
|
|
0x604ebd, /* 2 dark blue */
|
|
0xff44fd, /* 3 purple */
|
|
0x00a360, /* 4 dark green */
|
|
0x9c9c9c, /* 5 grey 1 */
|
|
0x14cffd, /* 6 medium blue */
|
|
0xd0c3ff, /* 7 light blue */
|
|
0x607203, /* 8 brown */
|
|
0xff6a3c, /* 9 orange */
|
|
0x9d9d9d, /* 10 grey 2 */
|
|
0xffa0d0, /* 11 pink */
|
|
0x14f53c, /* 12 bright green */
|
|
0xd0dd8d, /* 13 yellow */
|
|
0x72ffd0, /* 14 aqua */
|
|
0xffffff, /* 15 white */
|
|
};
|
|
|
|
static unsigned int hcolor[8]={
|
|
0, /* 0 black */
|
|
0x2ad600,
|
|
// 0x14f53c, /* 1 bright green */
|
|
// 0xff44fd, /* 2 purple */
|
|
0xc530ff,
|
|
0xffffff, /* 3 white */
|
|
0, /* 4 black */
|
|
0xff6a3c, /* 5 orange */
|
|
0x14cffd, /* 6 medium blue */
|
|
0xffffff, /* 7 white */
|
|
};
|
|
|
|
static unsigned int hcolor_hack[8][2]={
|
|
{0,0}, // 0000 KK
|
|
{0,0}, // 0010 KK
|
|
{1,1}, // 0100 OO
|
|
{1,3}, // 0110 OW
|
|
{2,0}, // 1000 BK
|
|
{2,2}, // 1010 BB
|
|
{3,3}, // 1100 WW
|
|
{3,3}, // 1110 WW
|
|
};
|
|
|
|
|
|
|
|
/* a = ycoord */
|
|
static int gbascalc(unsigned char a) {
|
|
|
|
unsigned char s,c;
|
|
|
|
/* input ABCD EFGH */
|
|
s=a; /* store a on stack */
|
|
c=a&1;
|
|
a=a>>1; /* lsr */
|
|
a=a&0x3; /* mask */
|
|
a=a|0x4; /* 00001FG */
|
|
ram[GBASH]=a;
|
|
a=s;
|
|
|
|
a=a&0x18; /* 000D E000 */
|
|
|
|
/* if odd */
|
|
if (c) {
|
|
a=a+0x7f+1;
|
|
}
|
|
ram[GBASL]=a;
|
|
a=a<<2;
|
|
a=a|ram[GBASL];
|
|
ram[GBASL]=a;
|
|
|
|
if (debug) printf("GBAS=%02X%02X\n",ram[GBASH],ram[GBASL]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int scrn(unsigned char xcoord, unsigned char ycoord) {
|
|
|
|
unsigned char a,y,c;
|
|
|
|
a=ycoord;
|
|
y=xcoord;
|
|
|
|
c=a&1;
|
|
a=a>>1;
|
|
gbascalc(a);
|
|
a=ram[y_indirect(GBASL,y)];
|
|
|
|
if (c) {
|
|
return a>>4;
|
|
}
|
|
else {
|
|
return a&0xf;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int scrn_page(unsigned char xcoord, unsigned char ycoord, int page) {
|
|
|
|
unsigned char a,y,c;
|
|
|
|
a=ycoord;
|
|
y=xcoord;
|
|
|
|
c=a&1;
|
|
a=a>>1;
|
|
gbascalc(a);
|
|
ram[GBASH]+=page;
|
|
a=ram[y_indirect(GBASL,y)];
|
|
|
|
if (c) {
|
|
return a>>4;
|
|
}
|
|
else {
|
|
return a&0xf;
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static short gr_addr_lookup[24]={
|
|
0x400,0x480,0x500,0x580,0x600,0x680,0x700,0x780,
|
|
0x428,0x4a8,0x528,0x5a8,0x628,0x6a8,0x728,0x7a8,
|
|
0x450,0x4d0,0x550,0x5d0,0x650,0x6d0,0x750,0x7d0,
|
|
};
|
|
|
|
|
|
|
|
static void draw_lowres(unsigned int *out_pointer,int gr_start, int gr_end) {
|
|
|
|
int i,j,yy,xx;
|
|
int gr_addr,gr_addr_hi;
|
|
int temp_col;
|
|
unsigned int *t_pointer;
|
|
|
|
t_pointer=out_pointer+(gr_start*40*GR_X_SCALE*GR_Y_SCALE);
|
|
|
|
/* do the top 40/48 if in graphics mode */
|
|
for(yy=gr_start;yy<gr_end;yy++) {
|
|
|
|
for(j=0;j<GR_Y_SCALE;j++) {
|
|
|
|
gr_addr=gr_addr_lookup[yy/2];
|
|
gr_addr_hi=yy%2;
|
|
|
|
/* adjust for page */
|
|
if (text_page_1) {
|
|
gr_addr+=0x400;
|
|
}
|
|
|
|
for(xx=0;xx<GR_XSIZE;xx++) {
|
|
|
|
if (gr_addr_hi) {
|
|
temp_col=(ram[gr_addr]&0xf0)>>4;
|
|
}
|
|
else {
|
|
temp_col=ram[gr_addr]&0x0f;
|
|
}
|
|
|
|
for(i=0;i<GR_X_SCALE;i++) {
|
|
*t_pointer=color[temp_col];
|
|
t_pointer++;
|
|
}
|
|
gr_addr++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void draw_text(unsigned int *out_pointer,int text_start, int text_end) {
|
|
|
|
int bit_set,ch,inverse,flash;
|
|
int gr_addr;
|
|
int xx,yy,i,j;
|
|
unsigned int *t_pointer;
|
|
|
|
t_pointer=out_pointer+(text_start*40*TEXT_Y_SCALE*TEXT_X_SCALE);
|
|
|
|
for(yy=text_start;yy<text_end;yy++) {
|
|
for(j=0;j<TEXT_Y_SCALE;j++) {
|
|
for(xx=0;xx<TEXT_XSIZE;xx++) {
|
|
|
|
gr_addr=gr_addr_lookup[yy];
|
|
|
|
/* adjust for page */
|
|
if (text_page_1) {
|
|
gr_addr+=0x400;
|
|
}
|
|
|
|
ch=ram[gr_addr+xx];
|
|
|
|
if (ch&0x80) {
|
|
flash=0;
|
|
inverse=0;
|
|
ch=ch&0x7f;
|
|
}
|
|
else if (ch&0x40) {
|
|
flash=1;
|
|
inverse=0;
|
|
ch=ch&0x3f;
|
|
}
|
|
else {
|
|
inverse=1;
|
|
flash=0;
|
|
ch=ch&0x3f;
|
|
}
|
|
|
|
for(i=0;i<TEXT_X_SCALE;i++) {
|
|
|
|
/* 14 x 16 */
|
|
/* but font is 5x7 */
|
|
|
|
if (j>13) bit_set=0;
|
|
else if (i>11) bit_set=0;
|
|
else bit_set=(a2_font[ch][j/2])&(1<<(5-(i/2)));
|
|
|
|
if (inverse) {
|
|
if (bit_set) *t_pointer=color[0];
|
|
else *t_pointer=color[15];
|
|
}
|
|
else if (flash) {
|
|
if (bit_set) *t_pointer=color[9];
|
|
else *t_pointer=color[0];
|
|
}
|
|
else {
|
|
if (bit_set) *t_pointer=color[15];
|
|
else *t_pointer=color[0];
|
|
}
|
|
|
|
t_pointer++;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void draw_hires(unsigned int *out_pointer,int y_start, int y_end) {
|
|
|
|
int i,j,yy,xx;
|
|
int gr_addr;
|
|
int temp_col;
|
|
unsigned int *t_pointer;
|
|
int last_last_pixel,last_pixel,current_byte,current_pixel,odd=0;
|
|
int old_high=0,current_high=0;
|
|
|
|
t_pointer=out_pointer+(y_start*280*HGR_X_SCALE*HGR_Y_SCALE);
|
|
|
|
/* do the hires graphics */
|
|
for(yy=y_start;yy<y_end;yy++) {
|
|
|
|
for(j=0;j<HGR_Y_SCALE;j++) {
|
|
|
|
gr_addr=gr_addr_lookup[yy/8]+0x1c00;
|
|
gr_addr+=0x400*(yy&0x7);
|
|
|
|
/* adjust for page */
|
|
if (text_page_1) {
|
|
gr_addr+=0x2000;
|
|
}
|
|
last_pixel=0;
|
|
last_last_pixel=0;
|
|
odd=0;
|
|
|
|
for(xx=0;xx<HGR_XSIZE/7;xx++) {
|
|
// printf("HGR ADDR=%x\n",gr_addr);
|
|
current_byte=ram[gr_addr];
|
|
|
|
|
|
// BBBBBBBB OOOOOOOO OO?WW?BB BB?KK?OO
|
|
// 10101010 01010101 01011010 10100101
|
|
// 1 1 010101 1 0 101010
|
|
// d5 aa
|
|
|
|
|
|
for(i=0;i<7;i++) {
|
|
old_high=current_high;
|
|
current_high=!!(current_byte&0x80);
|
|
current_pixel=!!(current_byte&(1<<i));
|
|
|
|
if (!odd) {
|
|
int pattern;
|
|
pattern=last_last_pixel<<2 |
|
|
last_pixel<<1|
|
|
current_pixel;
|
|
|
|
temp_col=(old_high<<2)|
|
|
hcolor_hack[pattern][0];
|
|
|
|
// printf("Temp col=%d\n",temp_col);
|
|
// for(k=0;k<HGR_X_SCALE;k++) {
|
|
|
|
*t_pointer=hcolor[temp_col];
|
|
t_pointer++;
|
|
*t_pointer=hcolor[temp_col];
|
|
t_pointer++;
|
|
|
|
temp_col=(current_high<<2)|
|
|
hcolor_hack[pattern][1];
|
|
|
|
*t_pointer=hcolor[temp_col];
|
|
t_pointer++;
|
|
*t_pointer=hcolor[temp_col];
|
|
t_pointer++;
|
|
}
|
|
odd=!odd;
|
|
last_last_pixel=last_pixel;
|
|
last_pixel=current_pixel;
|
|
}
|
|
|
|
gr_addr++;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
int grsim_update(void) {
|
|
|
|
unsigned int *t_pointer;
|
|
|
|
/* point to SDL output pixels */
|
|
t_pointer=((Uint32 *)sdl_screen->pixels);
|
|
|
|
/* get the proper modes */
|
|
|
|
if (plaid_mode) {
|
|
draw_text(t_pointer,0,6);
|
|
draw_hires(t_pointer,48,112);
|
|
draw_lowres(t_pointer,28,48);
|
|
} else if (text_mode) {
|
|
draw_text(t_pointer,0,TEXT_YSIZE);
|
|
}
|
|
else {
|
|
if (hires_on) {
|
|
draw_hires(t_pointer,0,192);
|
|
}
|
|
else {
|
|
draw_lowres(t_pointer,0,48);
|
|
}
|
|
|
|
if (mixed_graphics) {
|
|
draw_text(t_pointer,20,TEXT_YSIZE);
|
|
}
|
|
}
|
|
|
|
SDL_UpdateRect(sdl_screen, 0, 0, xsize, ysize);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void setnorm(void) {
|
|
|
|
y=0xff;
|
|
ram[INVFLG]=y;
|
|
|
|
}
|
|
|
|
int grsim_init(void) {
|
|
|
|
int mode;
|
|
int x;
|
|
|
|
mode=SDL_SWSURFACE|SDL_HWPALETTE|SDL_HWSURFACE;
|
|
|
|
if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
|
|
fprintf(stderr,
|
|
"Couldn't initialize SDL: %s\n", SDL_GetError());
|
|
return -1;
|
|
}
|
|
|
|
/* Clean up on exit */
|
|
atexit(SDL_Quit);
|
|
|
|
/* assume 32-bit color */
|
|
sdl_screen = SDL_SetVideoMode(xsize, ysize, 32, mode);
|
|
|
|
if ( sdl_screen == NULL ) {
|
|
fprintf(stderr, "ERROR! Couldn't set %dx%d video mode: %s\n",
|
|
xsize,ysize,SDL_GetError());
|
|
return -1;
|
|
}
|
|
|
|
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
|
|
|
|
/* Init screen */
|
|
for(x=0x400;x<0x800;x++) ram[x]=0;
|
|
|
|
/* Set up some zero page values */
|
|
ram[WNDLFT]=0x00;
|
|
ram[WNDWDTH]=0x28;
|
|
ram[WNDTOP]=0x00;
|
|
ram[WNDBTM]=0x18;
|
|
|
|
a=0; y=0; x=0;
|
|
|
|
//FA62 RESET
|
|
|
|
setnorm();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int color_equals(int new_color) {
|
|
|
|
/* Top and Bottom both have color */
|
|
ram[COLOR]=((new_color%16)<<4)|(new_color%16);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static void monitor_plot(void) {
|
|
|
|
unsigned char c;
|
|
|
|
/* Call into Monitor $F800 */
|
|
|
|
c=a&1; /* save LSB in carry */
|
|
a=a>>1; /* lsr A */
|
|
gbascalc(a);
|
|
|
|
if (c) {
|
|
/* If odd, mask is 0xf0 */
|
|
ram[MASK]=0xf0;
|
|
}
|
|
else {
|
|
/* If even, mask is 0x0f */
|
|
ram[MASK]=0x0f;
|
|
}
|
|
|
|
a=ram[y_indirect(GBASL,y)];
|
|
|
|
a=a^ram[COLOR];
|
|
|
|
a=a&ram[MASK];
|
|
|
|
a=a^ram[y_indirect(GBASL,y)];
|
|
|
|
ram[y_indirect(GBASL,y)]=a;
|
|
|
|
}
|
|
|
|
|
|
int basic_plot(unsigned char xcoord, unsigned char ycoord) {
|
|
|
|
if (ycoord>47) {
|
|
printf("Y too big %d\n",ycoord);
|
|
return -1;
|
|
}
|
|
|
|
/* Applesoft Source Code */
|
|
/* F225 GET X,Y Values */
|
|
/* Y-coord in A */
|
|
/* X-coord in Y */
|
|
/* Check that X-coord<40 */
|
|
a=ycoord;
|
|
y=xcoord;
|
|
|
|
if (y>=40) {
|
|
printf("X too big %d\n",y);
|
|
return -1;
|
|
}
|
|
|
|
monitor_plot();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int basic_hlin(int x1, int x2, int at) {
|
|
|
|
int i;
|
|
|
|
for(i=x1;i<=x2;i++) basic_plot(i,at);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void bascalc(void) {
|
|
// FBC1
|
|
|
|
unsigned char s,c;
|
|
|
|
s=a;
|
|
c=a&0x1;
|
|
|
|
a=a>>1;
|
|
a=a&0x3;
|
|
a=a|0x4;
|
|
ram[BASH]=a;
|
|
a=s;
|
|
a=a&0x18;
|
|
if (c!=0) {
|
|
a=a+0x80;
|
|
}
|
|
// BSCLC2
|
|
ram[BASL]=a;
|
|
a=a<<2;
|
|
a=a|ram[BASL];
|
|
ram[BASL]=a;
|
|
|
|
}
|
|
|
|
static void vtabz(void) {
|
|
|
|
bascalc();
|
|
|
|
a+=ram[WNDLFT];
|
|
ram[BASL]=a;
|
|
|
|
}
|
|
|
|
static void rom_vtab(void) {
|
|
/* fb5b */
|
|
a=ram[CV];
|
|
vtabz();
|
|
}
|
|
|
|
static void setwnd(void) {
|
|
|
|
ram[WNDTOP]=a;
|
|
a=0x0;
|
|
ram[WNDLFT]=a;
|
|
a=0x28;
|
|
ram[WNDWDTH]=a;
|
|
a=0x18;
|
|
ram[WNDBTM]=a;
|
|
a=0x17;
|
|
// TABV
|
|
ram[CV]=a;
|
|
rom_vtab();
|
|
}
|
|
|
|
static void vline(void) {
|
|
|
|
unsigned char s;
|
|
|
|
// f828
|
|
vline_loop:
|
|
s=a;
|
|
monitor_plot();
|
|
a=s;
|
|
if (a<ram[V2]) {
|
|
a++;
|
|
goto vline_loop;
|
|
}
|
|
}
|
|
|
|
static void clrtop(void) {
|
|
|
|
// f836
|
|
y=0x27;
|
|
ram[V2]=y;
|
|
y=0x27;
|
|
clrsc3:
|
|
a=0x0;
|
|
ram[COLOR]=a;
|
|
vline();
|
|
y--;
|
|
if (y<=0x80) goto clrsc3;
|
|
}
|
|
|
|
static void setgr(void) {
|
|
|
|
// FB40
|
|
// SETGR
|
|
soft_switch(TXTCLR); // LDA TXTCLR
|
|
soft_switch(MIXSET); // LDA MIXSET
|
|
|
|
clrtop();
|
|
|
|
a=0x14;
|
|
setwnd();
|
|
|
|
}
|
|
|
|
int gr(void) {
|
|
|
|
// F390
|
|
soft_switch(LORES); // LDA SW.LORES
|
|
soft_switch(MIXSET); // LDA SW.MIXSET
|
|
//JMP MON.SETGR
|
|
|
|
setgr();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int bload(char *filename, int address) {
|
|
|
|
FILE *fff;
|
|
int count=0,ch=0;
|
|
|
|
fff=fopen(filename,"r");
|
|
if (fff==NULL) {
|
|
fprintf(stderr,"Could not open %s\n",filename);
|
|
return -1;
|
|
}
|
|
|
|
while(1) {
|
|
|
|
if ((address+count)>RAMSIZE) {
|
|
fprintf(stderr,"ERROR ram too high\n");
|
|
return -1;
|
|
}
|
|
|
|
|
|
ch=fgetc(fff);
|
|
if (ch<0) break;
|
|
|
|
ram[address+count]=ch;
|
|
count++;
|
|
}
|
|
fclose(fff);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int cleolz(void) {
|
|
// FC9E
|
|
|
|
a=0xa0;
|
|
clreol2:
|
|
ram[y_indirect(BASL,y)]=a;
|
|
y++;
|
|
|
|
if (y<ram[WNDWDTH]) goto clreol2;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cleop1(void) {
|
|
|
|
unsigned char s;
|
|
|
|
cleop1_begin:
|
|
s=a;
|
|
vtabz();
|
|
cleolz();
|
|
y=0x00;
|
|
a=s;
|
|
a++;
|
|
if (a<=ram[WNDBTM]) goto cleop1_begin;
|
|
rom_vtab();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int home(void) {
|
|
|
|
/* FC58 */
|
|
a=ram[WNDTOP];
|
|
ram[CV]=a;
|
|
y=0x00;
|
|
ram[CH]=y;
|
|
cleop1();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int grsim_unrle_original(unsigned char *rle_data, int address) {
|
|
|
|
unsigned char s;
|
|
|
|
ram[GBASL]=0; /* input address */
|
|
ram[GBASH]=0; /* we fake this in this environment */
|
|
|
|
x=0; /* Set X and Y registers to 0 */
|
|
y=0;
|
|
|
|
ram[BASL]=address&0xff; /* output address? */
|
|
ram[BASH]=(address>>8)&0xff;
|
|
|
|
ram[CV]=0;
|
|
|
|
/* Read xsize, put in CH */
|
|
ram[CH]=rle_data[y_indirect(GBASL,y)];
|
|
y++;
|
|
|
|
/* Skip ysize, we won't need it */
|
|
y++;
|
|
|
|
while(1) {
|
|
/* Get run length into a */
|
|
a=rle_data[y_indirect(GBASL,y)];
|
|
|
|
/* 0xff is a special value meaning end */
|
|
if (a==0xff) break;
|
|
|
|
/* Store run length into TEMP */
|
|
ram[TEMP]=a;
|
|
|
|
/* 16-bit increment of GBASL:GBASH */
|
|
y++;
|
|
if (y==0) ram[GBASH]++;
|
|
|
|
/* Get the color into A */
|
|
|
|
a=rle_data[y_indirect(GBASL,y)];
|
|
|
|
/* 16-bit increment of GBASL:GBASH */
|
|
y++;
|
|
if (y==0) ram[GBASH]++;
|
|
|
|
/* Push y on stack */
|
|
s=y;
|
|
y=0;
|
|
|
|
while(1) {
|
|
/* store out color */
|
|
ram[y_indirect(BASL,y)]=a;
|
|
|
|
/* 16-bit increment of output pointer */
|
|
ram[BASL]++;
|
|
if (ram[BASL]==0) ram[BASH]++;
|
|
|
|
/* increment size */
|
|
x++;
|
|
|
|
/* if size longer than width, adjust */
|
|
if (x>=ram[CH]) {
|
|
if (ram[BASL]>0xa7) ram[BASH]++;
|
|
ram[BASL]+=0x58;
|
|
ram[CV]+=2;
|
|
if (ram[CV]>14) {
|
|
ram[CV]=0;
|
|
if (ram[BASL]<0xd8) {
|
|
ram[BASL]=ram[BASL]-0xd8;
|
|
ram[BASH]=ram[BASH]-0x4;
|
|
}
|
|
else {
|
|
ram[BASL]=ram[BASL]-0xd8;
|
|
ram[BASH]=ram[BASH]-0x3;
|
|
}
|
|
}
|
|
x=0;
|
|
}
|
|
|
|
/* repeat until use up all of run length */
|
|
ram[TEMP]--;
|
|
if (ram[TEMP]==0) break;
|
|
}
|
|
/* restore y from stack */
|
|
y=s;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int grsim_unrle(unsigned char *rle_data, int address) {
|
|
|
|
unsigned char s;
|
|
|
|
ram[GBASL]=0; /* input address */
|
|
ram[GBASH]=0; /* we fake this in this environment */
|
|
|
|
x=0; /* Set X and Y registers to 0 */
|
|
y=0;
|
|
|
|
ram[BASL]=address&0xff; /* output address? */
|
|
ram[BASH]=(address>>8)&0xff;
|
|
|
|
ram[CV]=0;
|
|
|
|
/* Read xsize, put in CH */
|
|
ram[CH]=rle_data[y_indirect(GBASL,y)];
|
|
y++;
|
|
|
|
/* Skip ysize, we won't need it */
|
|
// y++;
|
|
|
|
while(1) {
|
|
|
|
/* Get byte into A */
|
|
a=rle_data[y_indirect(GBASL,y)];
|
|
|
|
/* 0xa1 is a special value meaning end */
|
|
if (a==0xa1) break;
|
|
|
|
/* Store run length into TEMP */
|
|
if ((a&0xf0)==0xa0) {
|
|
if ((a&0xf)==0) {
|
|
/* 16-bit increment of GBASL:GBASH */
|
|
y++;
|
|
if (y==0) ram[GBASH]++;
|
|
|
|
a=rle_data[y_indirect(GBASL,y)];
|
|
ram[TEMP]=a;
|
|
|
|
}
|
|
else {
|
|
ram[TEMP]=a&0xf;
|
|
}
|
|
|
|
/* 16-bit increment of GBASL:GBASH */
|
|
y++;
|
|
if (y==0) ram[GBASH]++;
|
|
|
|
/* Get the color into A */
|
|
a=rle_data[y_indirect(GBASL,y)];
|
|
|
|
}
|
|
else {
|
|
ram[TEMP]=1;
|
|
}
|
|
|
|
/* 16-bit increment of GBASL:GBASH */
|
|
y++;
|
|
if (y==0) ram[GBASH]++;
|
|
|
|
/* Push y on stack */
|
|
s=y;
|
|
y=0;
|
|
|
|
#if 0
|
|
{
|
|
printf("Run=%d Color=%x\n",ram[TEMP],a);
|
|
}
|
|
#endif
|
|
while(1) {
|
|
/* store out color */
|
|
ram[y_indirect(BASL,y)]=a;
|
|
|
|
/* 16-bit increment of output pointer */
|
|
ram[BASL]++;
|
|
if (ram[BASL]==0) ram[BASH]++;
|
|
|
|
/* increment size */
|
|
x++;
|
|
|
|
/* if size longer than width, adjust */
|
|
if (x>=ram[CH]) {
|
|
if (ram[BASL]>0xa7) ram[BASH]++;
|
|
ram[BASL]+=0x58;
|
|
ram[CV]+=2;
|
|
if (ram[CV]>14) {
|
|
ram[CV]=0;
|
|
if (ram[BASL]<0xd8) {
|
|
ram[BASL]=ram[BASL]-0xd8;
|
|
ram[BASH]=ram[BASH]-0x4;
|
|
}
|
|
else {
|
|
ram[BASL]=ram[BASL]-0xd8;
|
|
ram[BASH]=ram[BASH]-0x3;
|
|
}
|
|
}
|
|
x=0;
|
|
}
|
|
|
|
/* repeat until use up all of run length */
|
|
ram[TEMP]--;
|
|
if (ram[TEMP]==0) break;
|
|
}
|
|
/* restore y from stack */
|
|
y=s;
|
|
|
|
#if 0
|
|
{
|
|
grsim_update();
|
|
int ch;
|
|
ch=repeat_until_keypressed();
|
|
grsim_update();
|
|
if (ch=='q') break;
|
|
}
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int basic_vlin(int y1, int y2, int at) {
|
|
|
|
// f244
|
|
|
|
// LINCOOR
|
|
// GET "A,B AT C"
|
|
// PUT SMALLER OF (A,B) IN FIRST,
|
|
// AND LARGER OF (A,B) IN H2 AND V2.
|
|
// RETURN WITH (X) = C-VALUE.
|
|
|
|
if (y1>y2) { ram[H2]=y1; ram[V2]=y1; ram[FIRST]=y2; }
|
|
else { ram[H2]=y2; ram[V2]=y2; ram[FIRST]=y1; }
|
|
x=at;
|
|
|
|
if (x>40) {
|
|
fprintf(stderr,"Error! AT too large %d!\n",x);
|
|
}
|
|
|
|
//VLIN JSR LINCOOR
|
|
//F244- 8A 2050 TXA X-COORD IN Y-REG
|
|
//F245- A8 2060 TAY
|
|
//F246- C0 28 2070 CPY #40 X-COORD MUST BE < 40
|
|
//F248- B0 BC 2080 BCS GOERR TOO LARGE
|
|
//F24A- A5 F0 2090 LDA FIRST TOP END OF LINE IN A-REG
|
|
//F24C- 4C 28 F8 2100 JMP MON.VLINE LET MONITOR DRAW LINE
|
|
|
|
y=x;
|
|
if (y>=40) {
|
|
fprintf(stderr,"X value to big in vline %d\n",y);
|
|
return -1;
|
|
}
|
|
a=ram[FIRST];
|
|
|
|
vline();
|
|
|
|
// for(i=y1;i<y2;i++) basic_plot(at,i);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int grsim_put_sprite_page(int page, unsigned char *sprite_data, int xpos, int ypos) {
|
|
|
|
unsigned char i;
|
|
unsigned char *ptr;
|
|
short address;
|
|
int cycles=0;
|
|
|
|
ptr=sprite_data;
|
|
x=*ptr;
|
|
ptr++;
|
|
ram[CV]=*ptr;
|
|
ptr++;
|
|
|
|
ypos=ypos&0xfe;
|
|
|
|
cycles+=28;
|
|
|
|
while(1) {
|
|
address=gr_addr_lookup[ypos/2];
|
|
address+=(page)<<8;
|
|
address+=xpos;
|
|
cycles+=36;
|
|
for(i=0;i<x;i++) {
|
|
a=*ptr;
|
|
cycles+=17;
|
|
// all transparent, skip
|
|
if (a==0xaa) {
|
|
}
|
|
// bottom transparent
|
|
else if ((a&0xf0)==0xa0) {
|
|
cycles+=8;
|
|
ram[address]&=0xf0;
|
|
ram[address]|=(a&0xf);
|
|
cycles+=19;
|
|
}
|
|
// top transparent
|
|
else if ((a&0x0f)==0xa) {
|
|
cycles+=8;
|
|
ram[address]&=0x0f;
|
|
ram[address]|=(a&0xf0);
|
|
cycles+=19;
|
|
}
|
|
else {
|
|
cycles+=8;
|
|
ram[address]=a;
|
|
cycles+=19;
|
|
}
|
|
ptr++;
|
|
address++;
|
|
cycles+=13;
|
|
}
|
|
ypos+=2;
|
|
ram[CV]--;
|
|
if (ram[CV]==0) break;
|
|
cycles+=18;
|
|
}
|
|
cycles+=6;
|
|
return cycles;
|
|
}
|
|
|
|
int grsim_put_sprite(unsigned char *sprite_data, int xpos, int ypos) {
|
|
|
|
int cycles;
|
|
|
|
cycles=grsim_put_sprite_page(ram[DRAW_PAGE],sprite_data,xpos,ypos);
|
|
|
|
return cycles;
|
|
}
|
|
|
|
|
|
int gr_copy(short source, short dest) {
|
|
|
|
short dest_addr,source_addr;
|
|
int i,j,l;
|
|
|
|
for(i=0;i<8;i++) {
|
|
source_addr=gr_addr_lookup[i]+(source-0x400);
|
|
dest_addr=gr_addr_lookup[i]+(dest-0x400);
|
|
|
|
if (i<4) l=120;
|
|
else l=80;
|
|
|
|
for(j=0;j<l;j++) {
|
|
ram[dest_addr+j]=ram[source_addr+j];
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int gr_copy_to_current(short source) {
|
|
|
|
short dest_addr,source_addr;
|
|
int i,j,l;
|
|
|
|
for(i=0;i<8;i++) {
|
|
source_addr=gr_addr_lookup[i]+(source-0x400);
|
|
dest_addr=gr_addr_lookup[i]+(ram[DRAW_PAGE]<<8);
|
|
|
|
// if (i<4) l=120; // only copy 40 lines
|
|
// else l=80;
|
|
|
|
l=120; // copy 48 lines
|
|
|
|
for(j=0;j<l;j++) {
|
|
ram[dest_addr+j]=ram[source_addr+j];
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int gr_copy48(short source, short dest) {
|
|
|
|
short dest_addr,source_addr;
|
|
int i,j;
|
|
|
|
for(i=0;i<8;i++) {
|
|
source_addr=gr_addr_lookup[i]+0x400;
|
|
dest_addr=gr_addr_lookup[i];
|
|
|
|
for(j=0;j<120;j++) {
|
|
ram[dest_addr+j]=ram[source_addr+j];
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int text(void) {
|
|
// FB36
|
|
|
|
soft_switch(LOWSCR); // LDA LOWSCR ($c054)
|
|
soft_switch(TXTSET); // LDA TXTSET ($c051);
|
|
a=0;
|
|
|
|
setwnd();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void scroll(void) {
|
|
unsigned char s;
|
|
|
|
// fc70
|
|
|
|
a=ram[WNDTOP];
|
|
s=a;
|
|
vtabz();
|
|
|
|
// SCRL1
|
|
scrl1:
|
|
a=ram[BASL];
|
|
ram[BAS2L]=a;
|
|
a=ram[BASH];
|
|
ram[BAS2H]=a;
|
|
y=ram[WNDWDTH];
|
|
y--;
|
|
a=s;
|
|
a+=1;
|
|
if (a>=ram[WNDBTM]) {
|
|
// SCRL3
|
|
y=0;
|
|
cleolz();
|
|
rom_vtab();
|
|
return;
|
|
}
|
|
s=a;
|
|
vtabz();
|
|
// SCRL2
|
|
scrl2:
|
|
a=ram[y_indirect(BASL,y)];
|
|
ram[y_indirect(BAS2L,y)]=a;
|
|
y--;
|
|
if (y<0x80) goto scrl2;
|
|
goto scrl1;
|
|
}
|
|
|
|
static void lf(void) {
|
|
ram[CV]=ram[CV]+1;
|
|
a=ram[CV];
|
|
if (a<ram[WNDBTM]) {
|
|
vtabz();
|
|
return;
|
|
}
|
|
ram[CV]=ram[CV]-1;
|
|
scroll();
|
|
}
|
|
|
|
static void cr(void) {
|
|
a=0x00;
|
|
ram[CH]=a;
|
|
lf();
|
|
}
|
|
|
|
|
|
|
|
static void bell1(void) {
|
|
}
|
|
|
|
static void up(void) {
|
|
|
|
a=ram[WNDTOP];
|
|
if (a>ram[CV]) return;
|
|
|
|
ram[CV]=ram[CV]-1;
|
|
rom_vtab();
|
|
}
|
|
|
|
static void bs(void) {
|
|
|
|
ram[CH]=ram[CH]-1;
|
|
|
|
/* still positive */
|
|
if (ram[CH]<0x80) return;
|
|
|
|
a=ram[WNDWDTH];
|
|
ram[CH]=a;
|
|
ram[CH]=ram[CH]-1;
|
|
|
|
up();
|
|
}
|
|
|
|
static void storadv(void) {
|
|
|
|
// fbf0
|
|
|
|
y=ram[CH];
|
|
ram[y_indirect(BASL,y)]=a;
|
|
|
|
// advance
|
|
|
|
ram[CH]=ram[CH]+1;
|
|
a=ram[CH];
|
|
if (a>=ram[WNDWDTH]) {
|
|
cr();
|
|
}
|
|
|
|
}
|
|
|
|
static void vidout(void) {
|
|
// fbfd
|
|
|
|
if (a>=0xa0) {
|
|
storadv();
|
|
return;
|
|
}
|
|
|
|
/* Control Characters */
|
|
y=a;
|
|
// if bit 7 is set then we set negative flag
|
|
// BPL storadv
|
|
if (a<0x80) {
|
|
storadv();
|
|
return;
|
|
}
|
|
|
|
/* carriage return */
|
|
if (a==0x8d) {
|
|
cr();
|
|
return;
|
|
}
|
|
|
|
/* linefeed */
|
|
if (a==0x8a) {
|
|
lf();
|
|
return;
|
|
}
|
|
|
|
/* backspace */
|
|
if (a==0x88) {
|
|
bs();
|
|
return;
|
|
}
|
|
|
|
/* any other control code, beep */
|
|
bell1();
|
|
return;
|
|
|
|
}
|
|
|
|
static void vidwait(void) {
|
|
// check if control-S being pressed
|
|
|
|
vidout();
|
|
}
|
|
|
|
static void cout1(void) {
|
|
|
|
unsigned char s;
|
|
|
|
if (a<0xa0) {
|
|
}
|
|
else {
|
|
a=a&ram[INVFLG];
|
|
}
|
|
// coutz
|
|
ram[YSAV1]=y;
|
|
s=a;
|
|
|
|
vidwait();
|
|
|
|
a=s;
|
|
y=ram[YSAV1];
|
|
|
|
}
|
|
|
|
static void cout(void) {
|
|
// FDED
|
|
// jmp (cswl) custom handler
|
|
cout1();
|
|
}
|
|
|
|
static void wait(void) {
|
|
}
|
|
|
|
static void outdo(void) {
|
|
|
|
unsigned char s;
|
|
|
|
/* Print char in the accumulator */
|
|
a=a|0x80; /* raw ascii has high bit on Apple II */
|
|
if (a<0xa0) {
|
|
/* skip if control char? */
|
|
}
|
|
else {
|
|
a=a|ram[FLASH];
|
|
}
|
|
cout();
|
|
a=a&0x7f; // ?
|
|
s=a; // pha
|
|
a=ram[SPEEDZ];
|
|
wait(); // this is BASIC, slow down if speed set
|
|
a=s;
|
|
}
|
|
|
|
static void crdo(void) {
|
|
// DAFB
|
|
a=13; // carriage return
|
|
outdo();
|
|
a=a^0xff; /* negate for some reason? */
|
|
}
|
|
|
|
void basic_htab(int xpos) {
|
|
|
|
unsigned char s;
|
|
|
|
// F7E7
|
|
|
|
|
|
x=xpos; // JSR GETBYT
|
|
x--; // DEX
|
|
a=x; // TXA
|
|
while(a>=40) {
|
|
s=a; // PHA
|
|
crdo();
|
|
a=s; // PLA
|
|
a-=40;
|
|
}
|
|
ram[CH]=a; // STA MON.CH
|
|
|
|
// KRW for the win!
|
|
|
|
}
|
|
|
|
static void tabv(void) {
|
|
|
|
// TABV
|
|
// fb5b
|
|
ram[CV]=a;
|
|
rom_vtab();
|
|
}
|
|
|
|
void basic_vtab(int ypos) {
|
|
// f256
|
|
x=ypos;
|
|
x--; /* base on zero */
|
|
a=x;
|
|
|
|
if (a>23) {
|
|
fprintf(stderr,"Error, vtab %d too big\n",ypos);
|
|
return;
|
|
}
|
|
tabv();
|
|
}
|
|
|
|
void basic_print(char *string) {
|
|
|
|
int i;
|
|
|
|
for(i=0;i<strlen(string);i++) {
|
|
a=string[i];
|
|
outdo();
|
|
}
|
|
|
|
}
|
|
|
|
void basic_inverse(void) {
|
|
// F277
|
|
a=0x3f;
|
|
x=0;
|
|
ram[INVFLG]=a;
|
|
ram[FLASH]=x;
|
|
|
|
return;
|
|
}
|
|
|
|
void basic_normal(void) {
|
|
// F273
|
|
a=0xff;
|
|
x=0;
|
|
ram[INVFLG]=a;
|
|
ram[FLASH]=x;
|
|
|
|
return;
|
|
}
|
|
|
|
static unsigned short hlin_addr;
|
|
static unsigned short hlin_hi;
|
|
|
|
|
|
int hlin_continue(int width) {
|
|
|
|
int i;
|
|
|
|
for(i=0;i<width;i++) {
|
|
if (hlin_hi) {
|
|
ram[hlin_addr]=ram[hlin_addr]&0x0f;
|
|
ram[hlin_addr]|=ram[COLOR]&0xf0;
|
|
}
|
|
else {
|
|
ram[hlin_addr]=ram[hlin_addr]&0xf0;
|
|
ram[hlin_addr]|=ram[COLOR]&0x0f;
|
|
}
|
|
hlin_addr++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int plot(unsigned char xcoord, unsigned char ycoord) {
|
|
|
|
unsigned char c;
|
|
|
|
hlin_addr=gr_addr_lookup[ycoord/2];
|
|
hlin_addr+=(ram[DRAW_PAGE])<<8;
|
|
hlin_addr+=xcoord;
|
|
|
|
hlin_hi=ycoord&1;
|
|
|
|
if (hlin_hi) {
|
|
/* If odd, mask is 0xf0 */
|
|
ram[MASK]=0xf0;
|
|
}
|
|
else {
|
|
/* If even, mask is 0x0f */
|
|
ram[MASK]=0x0f;
|
|
}
|
|
|
|
c=ram[COLOR]&ram[MASK];
|
|
ram[hlin_addr]&=~ram[MASK];
|
|
ram[hlin_addr]|=c;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int hlin(int page, int x1, int x2, int at) {
|
|
|
|
hlin_addr=gr_addr_lookup[at/2];
|
|
hlin_hi=at&1;
|
|
|
|
hlin_addr+=(page)<<8;
|
|
|
|
hlin_addr+=x1;
|
|
hlin_continue(x2-x1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static unsigned short vlin_hi;
|
|
|
|
/* TODO: optimize */
|
|
/* Could make twice as fast if draw neighboring two in one write */
|
|
/* instead of two */
|
|
|
|
int vlin(int y1, int y2, int at) {
|
|
|
|
x=y1;
|
|
ram[V2]=y2;
|
|
y=at;
|
|
|
|
vlin_loop:
|
|
// for(a=y1;a<y2;a++) {
|
|
|
|
ram[TEMPY]=y;
|
|
a=x;
|
|
y=a/2;
|
|
|
|
ram[OUTL]=gr_addr_lookup[y]&0xff;
|
|
ram[OUTH]=(gr_addr_lookup[y]>>8)&0xff;
|
|
|
|
ram[OUTH]+=ram[DRAW_PAGE];
|
|
|
|
vlin_hi=x&1;
|
|
|
|
y=ram[TEMPY]; // y=at;
|
|
|
|
if (vlin_hi) {
|
|
ram[y_indirect(OUTL,y)]=ram[y_indirect(OUTL,y)]&0x0f;
|
|
ram[y_indirect(OUTL,y)]|=ram[COLOR]&0xf0;
|
|
}
|
|
else {
|
|
ram[y_indirect(OUTL,y)]=ram[y_indirect(OUTL,y)]&0xf0;
|
|
ram[y_indirect(OUTL,y)]|=ram[COLOR]&0x0f;
|
|
}
|
|
x++;
|
|
if (x<ram[V2]) goto vlin_loop;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hlin_double_continue(int width) {
|
|
|
|
x=width;
|
|
|
|
hlin_loop:
|
|
y=0;
|
|
ram[y_indirect(GBASL,y)]=ram[COLOR];
|
|
ram[GBASL]++;
|
|
x--;
|
|
if (x!=0) goto hlin_loop;
|
|
|
|
// ram[GBASL]+=width;
|
|
|
|
// }
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hlin_setup(int page, int x1, int x2, int at) {
|
|
|
|
// page, y, V2, A
|
|
a=at;
|
|
y=at/2;
|
|
|
|
ram[GBASL]=(gr_addr_lookup[y])&0xff;
|
|
ram[GBASH]=(gr_addr_lookup[y]>>8);
|
|
|
|
ram[GBASH]+=(page);
|
|
|
|
ram[GBASL]+=x1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int hlin_double(int page, int x1, int x2, int at) {
|
|
|
|
hlin_setup(page,x1,x2,at);
|
|
|
|
hlin_double_continue(x2-x1+1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
int collision(int xx, int yy, int ground_color) {
|
|
|
|
int page=0;
|
|
int beach_color;
|
|
int collide=1;
|
|
|
|
hlin_addr=gr_addr_lookup[yy/2];
|
|
|
|
hlin_addr+=(page)<<8;
|
|
|
|
hlin_addr+=xx;
|
|
|
|
beach_color=COLOR_YELLOW|(COLOR_YELLOW<<4);
|
|
|
|
if ((ram[hlin_addr]==ground_color) &&
|
|
(ram[hlin_addr+1]==ground_color) &&
|
|
(ram[hlin_addr+2]==ground_color)) {
|
|
|
|
printf("NOCOLLIDE %x!\n",ground_color);
|
|
collide=0;
|
|
}
|
|
|
|
if ((ram[hlin_addr]==beach_color) &&
|
|
(ram[hlin_addr+1]==beach_color) &&
|
|
(ram[hlin_addr+2]==beach_color)) {
|
|
|
|
printf("NOCOLLIDE %x!\n",beach_color);
|
|
collide=0;
|
|
}
|
|
|
|
printf("COLLIDE %x %x %x not %x %x\n",
|
|
ram[hlin_addr],ram[hlin_addr+1],ram[hlin_addr+2],
|
|
ground_color,beach_color);
|
|
|
|
return collide;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
|
|
void clear_top_a(void) {
|
|
|
|
int i;
|
|
|
|
ram[COLOR]=a;
|
|
for(i=0;i<40;i+=2) {
|
|
hlin_double(ram[DRAW_PAGE],0,40,i);
|
|
}
|
|
}
|
|
|
|
void clear_top(int page) {
|
|
int i;
|
|
|
|
ram[COLOR]=0x0;
|
|
for(i=0;i<40;i+=2) {
|
|
hlin_double(page,0,40,i);
|
|
}
|
|
}
|
|
|
|
void clear_bottom(int page) {
|
|
int i;
|
|
|
|
/* NORMAL space */
|
|
ram[COLOR]=0xa0;
|
|
for(i=40;i<48;i+=2) {
|
|
hlin_double(page,0,40,i);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
void vtab(int ypos) {
|
|
ram[CV]=ypos-1;
|
|
}
|
|
|
|
void htab(int xpos) {
|
|
ram[CH]=xpos-1;
|
|
}
|
|
|
|
void move_cursor(void) {
|
|
|
|
int address;
|
|
|
|
address=gr_addr_lookup[ram[CV]];
|
|
address+=ram[CH];
|
|
|
|
address+=(ram[DRAW_PAGE]<<8);
|
|
|
|
ram[BASL]=address&0xff;
|
|
ram[BASH]=address>>8;
|
|
|
|
}
|
|
|
|
void print_both_pages(char *string) {
|
|
unsigned char temp;
|
|
|
|
temp=ram[DRAW_PAGE];
|
|
|
|
ram[DRAW_PAGE]=0;
|
|
move_and_print(string);
|
|
|
|
ram[DRAW_PAGE]=4;
|
|
move_and_print(string);
|
|
|
|
ram[DRAW_PAGE]=temp;
|
|
|
|
}
|
|
|
|
void move_and_print(char *string) {
|
|
|
|
int address;
|
|
|
|
address=gr_addr_lookup[ram[CV]];
|
|
address+=ram[CH];
|
|
|
|
address+=(ram[DRAW_PAGE]<<8);
|
|
|
|
ram[BASL]=address&0xff;
|
|
ram[BASH]=address>>8;
|
|
|
|
print(string);
|
|
}
|
|
|
|
|
|
|
|
void print(char *string) {
|
|
|
|
for(y=0;y<strlen(string);y++) {
|
|
a=string[y];
|
|
a=a|0x80;
|
|
ram[y_indirect(BASL,y)]=a;
|
|
}
|
|
ram[BASL]+=strlen(string);
|
|
}
|
|
|
|
void print_inverse(char *string) {
|
|
|
|
for(y=0;y<strlen(string);y++) {
|
|
a=string[y];
|
|
if ((a>='a') && (a<='z')) a&=~0x20; // convert to uppercase
|
|
a=(a&0x3f);
|
|
|
|
ram[y_indirect(BASL,y)]=a;
|
|
}
|
|
ram[BASL]+=strlen(string);
|
|
}
|
|
|
|
void print_flash(char *string) {
|
|
|
|
for(y=0;y<strlen(string);y++) {
|
|
a=string[y];
|
|
a=(a&0x3f)|0x40;
|
|
ram[y_indirect(BASL,y)]=a;
|
|
}
|
|
ram[BASL]+=strlen(string);
|
|
}
|