WebSVN – Kolibri OS – Diff – /programs/emulator/e80/trunk/e80.c


#ifndef AUTOBUILD
// autobuild does not create lang.h, but defines LANG_{RUS,ENG} directly
#include "lang.h"
#endif
 
#include "system/kolibri.h"
#include "system/stdlib.h"
#include "system/string.h"
#include "z80/z80.h"
#include "48.h"
 
#include "system/msgbox.c"
 
///=============================
 
#define TYPE_NO		0
#define TYPE_SNA	1
#define TYPE_Z80	2
 
#define SCREEN_LEN	3*3*256*192*3
 
char WND_CAPTION[] = {"e80 v0.5.1"};
 
extern char KOL_PARAM[256];
extern char KOL_PATH[256];
 
char szBackup[256];
char szScreen[256];
 
int fila[5][5];
int main_tecla, hay_tecla;
int SSCS = 0;
 
int debug=0, scanl=0;
int frame_counter;
int target_cycle;
Z80Regs spectrumZ80;
 
char *screen;
unsigned screen_w, screen_h;
#define  screen_a_w   512
#define  screen_a_h   384
int flash = 0;
unsigned time = 0;
 
///=============================
 
#include "keyboard.c"
 
///=============================
 
int get_ext(char *filename)
{
 
return TYPE_SNA;
}
 
///=============================
 
void memory_print(Z80Regs *regs, char *filename)
{
kol_struct70 file;
 
file.p00 = 2;
file.p04 = 0;
file.p08 = 0;
file.p12 = 64*1024;
file.p16 = (unsigned)(regs->RAM);
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
}
 
 
///=============================
 
void all_print(Z80Regs *regs, char *filename)
{
kol_struct70 file;
 
file.p00 = 2;
file.p04 = 0;
file.p08 = 0;
file.p12 = sizeof (Z80Regs);
file.p16 = (unsigned)regs;
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
}
 
///=============================
 
void screen_print(Z80Regs *regs)
{
 
kol_struct70 file;
 
char palette[]=
	{
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0xB0, 0x00, 0x00, 0xB0, 0x00, 0x00, 
	0x00, 0x00, 0xB0, 0x00, 0x00, 0xB0, 
	0xB0, 0x00, 0xB0, 0xB0, 0x00, 0xB0,
	0x00, 0xB0, 0x00, 0x00, 0xB0, 0x00,
	0xB0, 0xB0, 0x00, 0xB0, 0xB0, 0x00, 
	0x00, 0xB0, 0xB0, 0x00, 0xB0, 0xB0,
	0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0,
 
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
	0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 
	0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 
	0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF,
	0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
	0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 
	0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
	};
 
char *scr;
char *atr;
 
char a, c, s;
int i, j, k, l, m;
unsigned bri;
char *color;
char *addr;
int n = 0;
int z = 0;
int x, y;
 
scr = malloc(6144);
atr = malloc(768);
 
memcpy(scr, regs->RAM + 0x4000 , 6144);
memcpy(atr, regs->RAM + 0x5800 , 768);
 
for (j = 0; j < 3 ; j++)
for (i = 0; i < 8; i++)
for (k = 0; k < 8; k++)
for (l = 0; l < 32; l++)
	{
	c = scr[j*2048 + k*256 + i*32 + l];
	for (m = 0; m < 8; m++)
		{
		s = (c & 128) >> 7;
		a = atr[j*256 + i*32 + l];
 
		if ( (a & 64) == 64 )
			bri = 8;
		else 
			bri = 0;
 
		if ( 0 == s )
			{
			if (!(flash && (128 == (a&128))))
				color = &palette[6*(bri+((a>>3)&7))];
			else
				color = &palette[6*(bri+(a&7))];
 
				addr = screen + 2*screen_a_w*3*z + 2*3*n;
 
				for (y = 0; y < 2; y++)
					memcpy( addr + y*screen_a_w*3, 
						color, 6);
			}
		else
			{
			if (!(flash && (128 == (a&128))))
				color = &palette[6*(bri+(a&7))];
			else
				color = &palette[6*(bri+((a>>3)&7))];
				
				addr = screen + 2*screen_a_w*3*z + 2*3*n;
 
				for (y = 0; y < 2; y++)
					memcpy( addr + y*screen_a_w*3, 
						color, 6);
			}
 
		n++;
		if (256 == n)
			{
			n = 0;
			z++;
			}
 
		c <<= 1;
		}
	}
 
if ( 33 < (kol_time_tick() - time))
{
if (0 == flash)
	flash = 1;
else 
	flash = 0;
time = kol_time_tick();
}
 
free(scr);
free(atr);
 
}
 
///=============================
 
void memory_load_z80(Z80Regs *regs, char *filename)
{
char header[30];
kol_struct70 file;
 
file.p00 = 0;
file.p04 = 0;
file.p08 = 0;
file.p12 = 30;
file.p16 = (unsigned) header;
file.p20 = 0;
file.p21 = filename;
}
 
///=============================
 
void memory_load_sna(Z80Regs *regs, char *filename)
{
char buffer[27];
kol_struct70 file;
 
file.p00 = 0;
file.p04 = 0;
file.p08 = 0;
file.p12 = 27;
file.p16 = (unsigned) buffer;
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
 
regs->I = buffer[ 0];
regs->HLs.B.l = buffer[ 1];
regs->HLs.B.h = buffer[ 2];
regs->DEs.B.l = buffer[ 3];
regs->DEs.B.h = buffer[ 4];
regs->BCs.B.l = buffer[ 5];
regs->BCs.B.h = buffer[ 6];
regs->AFs.B.l = buffer[ 7];
regs->AFs.B.h = buffer[ 8];
regs->HL.B.l  = buffer[ 9];
regs->HL.B.h  = buffer[10];
regs->DE.B.l  = buffer[11];
regs->DE.B.h  = buffer[12];
regs->BC.B.l  = buffer[13];
regs->BC.B.h  = buffer[14];
regs->IY.B.l = buffer[15];
regs->IY.B.h = buffer[16];
regs->IX.B.l = buffer[17];
regs->IX.B.h = buffer[18];
regs->IFF1 = regs->IFF2 = (buffer[19]&0x04) >>2;
regs->R.W  = buffer[20];
regs->AF.B.l = buffer[21];
regs->AF.B.h = buffer[22];
regs->SP.B.l =buffer[23];
regs->SP.B.h =buffer[24];
regs->IM = buffer[25];
regs->BorderColor = buffer[26]; 
 
file.p00 = 0;
file.p04 = 27;
file.p08 = 0;
file.p12 = 0x4000*3;
file.p16 = (unsigned) regs->RAM+16384;
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
 
regs->PC.B.l = Z80MemRead(regs->SP.W, regs);
regs->SP.W++;
regs->PC.B.h = Z80MemRead(regs->SP.W, regs);
regs->SP.W++; 
 
}
 
 
///=============================
 
void memory_save_sna(Z80Regs *regs, char *filename)
{
char buffer[27];
unsigned char sptmpl, sptmph;
kol_struct70 file;
 
buffer[ 0] = regs->I;
buffer[ 1] = regs->HLs.B.l;
buffer[ 2] = regs->HLs.B.h;
buffer[ 3] = regs->DEs.B.l;
buffer[ 4] = regs->DEs.B.h;
buffer[ 5] = regs->BCs.B.l;
buffer[ 6] = regs->BCs.B.h;
buffer[ 7] = regs->AFs.B.l;
buffer[ 8] = regs->AFs.B.h;
buffer[ 9] = regs->HL.B.l;
buffer[10] = regs->HL.B.h;
buffer[11] = regs->DE.B.l;
buffer[12] = regs->DE.B.h;
buffer[13] = regs->BC.B.l;
buffer[14] = regs->BC.B.h;
buffer[15] = regs->IY.B.l;
buffer[16] = regs->IY.B.h;
buffer[17] = regs->IX.B.l;
buffer[18] = regs->IX.B.h;
buffer[19] = regs->IFF1 << 2;
buffer[20] = regs->R.W & 0xFF;
buffer[21] = regs->AF.B.l;
buffer[22] = regs->AF.B.h;
 
sptmpl = Z80MemRead( regs->SP.W-1, regs );
sptmph = Z80MemRead( regs->SP.W-2, regs );
 
Z80MemWrite( --(regs->SP.W), regs->PC.B.h, regs);
Z80MemWrite( --(regs->SP.W), regs->PC.B.l, regs);
 
buffer[23] = regs->SP.B.l;
buffer[24] = regs->SP.B.h;
buffer[25] = regs->IM;
buffer[26] = regs->BorderColor; 
 
file.p00 = 2;
file.p04 = 0;
file.p08 = 0;
file.p12 = 27;
file.p16 = (unsigned) buffer;
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
 
file.p00 = 3;
file.p04 = 27;
file.p08 = 0;
file.p12 = 0x4000*3;
file.p16 = (unsigned) regs->RAM+16384;
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
 
regs->SP.W += 2;
Z80MemWrite( regs->SP.W-1, sptmpl, regs );
Z80MemWrite( regs->SP.W-2, sptmph, regs );
 
}
 
 
///=============================
 
void memory_save_scr(Z80Regs *regs, char *filename)
{
kol_struct70 file;
 
 
file.p00 = 2;
file.p04 = 0x4000;
file.p08 = 0;
file.p12 = 6912;
file.p16 = (unsigned) regs->RAM+16384;
file.p20 = 0;
file.p21 = filename;
 
kol_file_70(&file);
 
}
 
 
///=============================
 
void wnd_draw()
{
kol_paint_start();
kol_wnd_define( (screen_w-540)/2, (screen_h-440)/2, 540, 440, 0x34b0b0b0);
kol_wnd_caption(WND_CAPTION);
screen_print(&spectrumZ80);
kol_paint_image((540 - screen_a_w)/2-5, 
		(440 - screen_a_h-kol_skin_height())/2, 
		screen_a_w, screen_a_h, screen);
kol_paint_end();
}
 
///=============================
 
void kol_main()
{
 
unsigned event;
unsigned key;
 
for (event = strlen(KOL_PATH); event > 0; --event)
	if ( '/' == KOL_PATH[event] )
		{
		KOL_PATH[event+1]=0;
		break;
		}
 
strcpy(szBackup, KOL_PATH);
strcpy(szScreen, KOL_PATH);
strcat(szBackup, "backup.sna");
strcat(szScreen, "screen.scr");
 
kol_screen_get_size(&screen_w, &screen_h);
 
screen = malloc(SCREEN_LEN);
spectrumZ80.RAM = (char*) malloc(64*1024);
memcpy(spectrumZ80.RAM, BIOS48, 16*1024);
 
Z80Reset( &spectrumZ80, 69888 );
Z80FlagTables();
 
fila[1][1] = fila[1][2] = fila[2][2] = fila[3][2] = fila[4][2] =
 fila[4][1] = fila[3][1] = fila[2][1] = 0xFF;
 
debug = 0;
 
if (KOL_PARAM != NULL)
	{
	int type = get_ext(KOL_PARAM);
	
	if (TYPE_SNA == type)
		memory_load_sna(&spectrumZ80, KOL_PARAM);
	}
 
hay_tecla = main_tecla = 0;
//keyboard_process(0);
 
kol_key_mode_set(1);
 
for (;;)
	{
 
//	event = kol_event_check();
	event = kol_event_wait_time(1);
 
	switch (event)
		{
 
		case 1:
			wnd_draw();
			break;
 
		case 2:
			key = (kol_key_get()>>8)&0xff;
			
			switch (key)
				{
				case 60: // F2
					if ( IDOK == MessageBox("Save snapshot?", 
									WND_CAPTION, MB_OKCANCEL) )
						memory_save_sna(&spectrumZ80, 
									szBackup);
					break;
 
				case 61: // F3
					if ( IDOK == MessageBox("Load snapshot?", 
									WND_CAPTION, MB_OKCANCEL) )
						memory_load_sna(&spectrumZ80, 
									szBackup);
					break;
 
				case 62: // F4
					if ( IDOK == MessageBox("Save screenshot?", 
									WND_CAPTION, MB_OKCANCEL) )
						memory_save_scr(&spectrumZ80, 
									szScreen);
					break;
 
				case 88: // F12 Reset
					if ( IDOK == MessageBox("Reset?", 
									WND_CAPTION, MB_OKCANCEL) )
						{
						Z80Reset( &spectrumZ80, 69888 );
						Z80FlagTables();
						fila[1][1] = fila[1][2] = 
						fila[2][2] = fila[3][2] = 
						fila[4][2] = fila[4][1] = 
						fila[3][1] = fila[2][1] = 0xFF;
						}
					break;
 
				default:
					keyboard_process(key);
				};
 
			break;
 
		case 3:
			if ( 1 == (kol_btn_get() & 0xff00)>>8 )
				{
				free(screen);
				free(spectrumZ80.RAM);
				kol_exit();
				}
			break;
 
		default:
			if (0 == debug)
				{
 
				Z80Run( &spectrumZ80, 224*64 ); 
				for( scanl=0; scanl<192; scanl++ )
					Z80Run( &spectrumZ80, 224 ); 
 
				Z80Run( &spectrumZ80, 224*56 ); 
 
				if( target_cycle < 2 || frame_counter == 0 )
					{
					screen_print(&spectrumZ80);
					kol_screen_wait_rr();
					kol_paint_image((540 - screen_a_w)/2-5, 
							(440 - screen_a_h-kol_skin_height())/2, 
							screen_a_w, screen_a_h, screen);
					}
 
				while( target_cycle == 0 ) 
					{
					target_cycle--;
					frame_counter++;
					}
				}
			break;
 
		};
 
	}
 
}
 
///=============================

Rev 1814	Rev 1854
-		1	#ifndef AUTOBUILD
-		2	// autobuild does not create lang.h, but defines LANG_{RUS,ENG} directly
-		3	#include "lang.h"
-		4	#endif
-		5
1	#include "system/kolibri.h"	6	#include "system/kolibri.h"
2	#include "system/stdlib.h"	7	#include "system/stdlib.h"
3	#include "system/string.h"	8	#include "system/string.h"
4	#include "z80/z80.h"	9	#include "z80/z80.h"
5	#include "48.h"	10	#include "48.h"
6		11
7	#include "system/msgbox.c"	12	#include "system/msgbox.c"
8		13
9	///=============================	14	///=============================
10		15
11	#define TYPE_NO 0	16	#define TYPE_NO 0
12	#define TYPE_SNA 1	17	#define TYPE_SNA 1
13	#define TYPE_Z80 2	18	#define TYPE_Z80 2
14		19
15	#define SCREEN_LEN 332561923	20	#define SCREEN_LEN 332561923
16		21
17	char WND_CAPTION[] = {"e80 v0.5.1"};	22	char WND_CAPTION[] = {"e80 v0.5.1"};
18		23
19	extern char KOL_PARAM[256];	24	extern char KOL_PARAM[256];
20	extern char KOL_PATH[256];	25	extern char KOL_PATH[256];
21		26
22	char szBackup[256];	27	char szBackup[256];
23	char szScreen[256];	28	char szScreen[256];
24		29
25	int fila[5][5];	30	int fila[5][5];
26	int main_tecla, hay_tecla;	31	int main_tecla, hay_tecla;
27	int SSCS = 0;	32	int SSCS = 0;
28		33
29	int debug=0, scanl=0;	34	int debug=0, scanl=0;
30	int frame_counter;	35	int frame_counter;
31	int target_cycle;	36	int target_cycle;
32	Z80Regs spectrumZ80;	37	Z80Regs spectrumZ80;
33		38
34	char *screen;	39	char *screen;
35	unsigned screen_w, screen_h;	40	unsigned screen_w, screen_h;
36	#define screen_a_w 512	41	#define screen_a_w 512
37	#define screen_a_h 384	42	#define screen_a_h 384
38	int flash = 0;	43	int flash = 0;
39	unsigned time = 0;	44	unsigned time = 0;
40		45
41	///=============================	46	///=============================
42		47
43	#include "keyboard.c"	48	#include "keyboard.c"
44		49
45	///=============================	50	///=============================
46		51
47	int get_ext(char *filename)	52	int get_ext(char *filename)
48	{	53	{
49		54
50	return TYPE_SNA;	55	return TYPE_SNA;
51	}	56	}
52		57
53	///=============================	58	///=============================
54		59
55	void memory_print(Z80Regs regs, char filename)	60	void memory_print(Z80Regs regs, char filename)
56	{	61	{
57	kol_struct70 file;	62	kol_struct70 file;
58		63
59	file.p00 = 2;	64	file.p00 = 2;
60	file.p04 = 0;	65	file.p04 = 0;
61	file.p08 = 0;	66	file.p08 = 0;
62	file.p12 = 64*1024;	67	file.p12 = 64*1024;
63	file.p16 = (unsigned)(regs->RAM);	68	file.p16 = (unsigned)(regs->RAM);
64	file.p20 = 0;	69	file.p20 = 0;
65	file.p21 = filename;	70	file.p21 = filename;
66		71
67	kol_file_70(&file);	72	kol_file_70(&file);
68	}	73	}
69		74
70		75
71	///=============================	76	///=============================
72		77
73	void all_print(Z80Regs regs, char filename)	78	void all_print(Z80Regs regs, char filename)
74	{	79	{
75	kol_struct70 file;	80	kol_struct70 file;
76		81
77	file.p00 = 2;	82	file.p00 = 2;
78	file.p04 = 0;	83	file.p04 = 0;
79	file.p08 = 0;	84	file.p08 = 0;
80	file.p12 = sizeof (Z80Regs);	85	file.p12 = sizeof (Z80Regs);
81	file.p16 = (unsigned)regs;	86	file.p16 = (unsigned)regs;
82	file.p20 = 0;	87	file.p20 = 0;
83	file.p21 = filename;	88	file.p21 = filename;
84		89
85	kol_file_70(&file);	90	kol_file_70(&file);
86	}	91	}
87		92
88	///=============================	93	///=============================
89		94
90	void screen_print(Z80Regs *regs)	95	void screen_print(Z80Regs *regs)
91	{	96	{
92		97
93	kol_struct70 file;	98	kol_struct70 file;
94		99
95	char palette[]=	100	char palette[]=
96	{	101	{
97	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	102	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
98	0xB0, 0x00, 0x00, 0xB0, 0x00, 0x00,	103	0xB0, 0x00, 0x00, 0xB0, 0x00, 0x00,
99	0x00, 0x00, 0xB0, 0x00, 0x00, 0xB0,	104	0x00, 0x00, 0xB0, 0x00, 0x00, 0xB0,
100	0xB0, 0x00, 0xB0, 0xB0, 0x00, 0xB0,	105	0xB0, 0x00, 0xB0, 0xB0, 0x00, 0xB0,
101	0x00, 0xB0, 0x00, 0x00, 0xB0, 0x00,	106	0x00, 0xB0, 0x00, 0x00, 0xB0, 0x00,
102	0xB0, 0xB0, 0x00, 0xB0, 0xB0, 0x00,	107	0xB0, 0xB0, 0x00, 0xB0, 0xB0, 0x00,
103	0x00, 0xB0, 0xB0, 0x00, 0xB0, 0xB0,	108	0x00, 0xB0, 0xB0, 0x00, 0xB0, 0xB0,
104	0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0,	109	0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0,
105		110
106	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	111	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107	0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,	112	0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
108	0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,	113	0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
109	0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF,	114	0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF,
110	0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,	115	0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
111	0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00,	116	0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00,
112	0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,	117	0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
113	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF	118	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
114	};	119	};
115		120
116	char *scr;	121	char *scr;
117	char *atr;	122	char *atr;
118		123
119	char a, c, s;	124	char a, c, s;
120	int i, j, k, l, m;	125	int i, j, k, l, m;
121	unsigned bri;	126	unsigned bri;
122	char *color;	127	char *color;
123	char *addr;	128	char *addr;
124	int n = 0;	129	int n = 0;
125	int z = 0;	130	int z = 0;
126	int x, y;	131	int x, y;
127		132
128	scr = malloc(6144);	133	scr = malloc(6144);
129	atr = malloc(768);	134	atr = malloc(768);
130		135
131	memcpy(scr, regs->RAM + 0x4000 , 6144);	136	memcpy(scr, regs->RAM + 0x4000 , 6144);
132	memcpy(atr, regs->RAM + 0x5800 , 768);	137	memcpy(atr, regs->RAM + 0x5800 , 768);
133		138
134	for (j = 0; j < 3 ; j++)	139	for (j = 0; j < 3 ; j++)
135	for (i = 0; i < 8; i++)	140	for (i = 0; i < 8; i++)
136	for (k = 0; k < 8; k++)	141	for (k = 0; k < 8; k++)
137	for (l = 0; l < 32; l++)	142	for (l = 0; l < 32; l++)
138	{	143	{
139	c = scr[j2048 + k256 + i*32 + l];	144	c = scr[j2048 + k256 + i*32 + l];
140	for (m = 0; m < 8; m++)	145	for (m = 0; m < 8; m++)
141	{	146	{
142	s = (c & 128) >> 7;	147	s = (c & 128) >> 7;
143	a = atr[j256 + i32 + l];	148	a = atr[j256 + i32 + l];
144		149
145	if ( (a & 64) == 64 )	150	if ( (a & 64) == 64 )
146	bri = 8;	151	bri = 8;
147	else	152	else
148	bri = 0;	153	bri = 0;
149		154
150	if ( 0 == s )	155	if ( 0 == s )
151	{	156	{
152	if (!(flash && (128 == (a&128))))	157	if (!(flash && (128 == (a&128))))
153	color = &palette[6*(bri+((a>>3)&7))];	158	color = &palette[6*(bri+((a>>3)&7))];
154	else	159	else
155	color = &palette[6*(bri+(a&7))];	160	color = &palette[6*(bri+(a&7))];
156		161
157	addr = screen + 2screen_a_w3z + 23*n;	162	addr = screen + 2screen_a_w3z + 23*n;
158		163
159	for (y = 0; y < 2; y++)	164	for (y = 0; y < 2; y++)
160	memcpy( addr + yscreen_a_w3,	165	memcpy( addr + yscreen_a_w3,
161	color, 6);	166	color, 6);
162	}	167	}
163	else	168	else
164	{	169	{
165	if (!(flash && (128 == (a&128))))	170	if (!(flash && (128 == (a&128))))
166	color = &palette[6*(bri+(a&7))];	171	color = &palette[6*(bri+(a&7))];
167	else	172	else
168	color = &palette[6*(bri+((a>>3)&7))];	173	color = &palette[6*(bri+((a>>3)&7))];
169		174
170	addr = screen + 2screen_a_w3z + 23*n;	175	addr = screen + 2screen_a_w3z + 23*n;
171		176
172	for (y = 0; y < 2; y++)	177	for (y = 0; y < 2; y++)
173	memcpy( addr + yscreen_a_w3,	178	memcpy( addr + yscreen_a_w3,
174	color, 6);	179	color, 6);
175	}	180	}
176		181
177	n++;	182	n++;
178	if (256 == n)	183	if (256 == n)
179	{	184	{
180	n = 0;	185	n = 0;
181	z++;	186	z++;
182	}	187	}
183		188
184	c <<= 1;	189	c <<= 1;
185	}	190	}
186	}	191	}
187		192
188	if ( 33 < (kol_time_tick() - time))	193	if ( 33 < (kol_time_tick() - time))
189	{	194	{
190	if (0 == flash)	195	if (0 == flash)
191	flash = 1;	196	flash = 1;
192	else	197	else
193	flash = 0;	198	flash = 0;
194	time = kol_time_tick();	199	time = kol_time_tick();
195	}	200	}
196		201
197	free(scr);	202	free(scr);
198	free(atr);	203	free(atr);
199		204
200	}	205	}
201		206
202	///=============================	207	///=============================
203		208
204	void memory_load_z80(Z80Regs regs, char filename)	209	void memory_load_z80(Z80Regs regs, char filename)
205	{	210	{
206	char header[30];	211	char header[30];
207	kol_struct70 file;	212	kol_struct70 file;
208		213
209	file.p00 = 0;	214	file.p00 = 0;
210	file.p04 = 0;	215	file.p04 = 0;
211	file.p08 = 0;	216	file.p08 = 0;
212	file.p12 = 30;	217	file.p12 = 30;
213	file.p16 = (unsigned) header;	218	file.p16 = (unsigned) header;
214	file.p20 = 0;	219	file.p20 = 0;
215	file.p21 = filename;	220	file.p21 = filename;
216	}	221	}
217		222
218	///=============================	223	///=============================
219		224
220	void memory_load_sna(Z80Regs regs, char filename)	225	void memory_load_sna(Z80Regs regs, char filename)
221	{	226	{
222	char buffer[27];	227	char buffer[27];
223	kol_struct70 file;	228	kol_struct70 file;
224		229
225	file.p00 = 0;	230	file.p00 = 0;
226	file.p04 = 0;	231	file.p04 = 0;
227	file.p08 = 0;	232	file.p08 = 0;
228	file.p12 = 27;	233	file.p12 = 27;
229	file.p16 = (unsigned) buffer;	234	file.p16 = (unsigned) buffer;
230	file.p20 = 0;	235	file.p20 = 0;
231	file.p21 = filename;	236	file.p21 = filename;
232		237
233	kol_file_70(&file);	238	kol_file_70(&file);
234		239
235	regs->I = buffer[ 0];	240	regs->I = buffer[ 0];
236	regs->HLs.B.l = buffer[ 1];	241	regs->HLs.B.l = buffer[ 1];
237	regs->HLs.B.h = buffer[ 2];	242	regs->HLs.B.h = buffer[ 2];
238	regs->DEs.B.l = buffer[ 3];	243	regs->DEs.B.l = buffer[ 3];
239	regs->DEs.B.h = buffer[ 4];	244	regs->DEs.B.h = buffer[ 4];
240	regs->BCs.B.l = buffer[ 5];	245	regs->BCs.B.l = buffer[ 5];
241	regs->BCs.B.h = buffer[ 6];	246	regs->BCs.B.h = buffer[ 6];
242	regs->AFs.B.l = buffer[ 7];	247	regs->AFs.B.l = buffer[ 7];
243	regs->AFs.B.h = buffer[ 8];	248	regs->AFs.B.h = buffer[ 8];
244	regs->HL.B.l = buffer[ 9];	249	regs->HL.B.l = buffer[ 9];
245	regs->HL.B.h = buffer[10];	250	regs->HL.B.h = buffer[10];
246	regs->DE.B.l = buffer[11];	251	regs->DE.B.l = buffer[11];
247	regs->DE.B.h = buffer[12];	252	regs->DE.B.h = buffer[12];
248	regs->BC.B.l = buffer[13];	253	regs->BC.B.l = buffer[13];
249	regs->BC.B.h = buffer[14];	254	regs->BC.B.h = buffer[14];
250	regs->IY.B.l = buffer[15];	255	regs->IY.B.l = buffer[15];
251	regs->IY.B.h = buffer[16];	256	regs->IY.B.h = buffer[16];
252	regs->IX.B.l = buffer[17];	257	regs->IX.B.l = buffer[17];
253	regs->IX.B.h = buffer[18];	258	regs->IX.B.h = buffer[18];
254	regs->IFF1 = regs->IFF2 = (buffer[19]&0x04) >>2;	259	regs->IFF1 = regs->IFF2 = (buffer[19]&0x04) >>2;
255	regs->R.W = buffer[20];	260	regs->R.W = buffer[20];
256	regs->AF.B.l = buffer[21];	261	regs->AF.B.l = buffer[21];
257	regs->AF.B.h = buffer[22];	262	regs->AF.B.h = buffer[22];
258	regs->SP.B.l =buffer[23];	263	regs->SP.B.l =buffer[23];
259	regs->SP.B.h =buffer[24];	264	regs->SP.B.h =buffer[24];
260	regs->IM = buffer[25];	265	regs->IM = buffer[25];
261	regs->BorderColor = buffer[26];	266	regs->BorderColor = buffer[26];
262		267
263	file.p00 = 0;	268	file.p00 = 0;
264	file.p04 = 27;	269	file.p04 = 27;
265	file.p08 = 0;	270	file.p08 = 0;
266	file.p12 = 0x4000*3;	271	file.p12 = 0x4000*3;
267	file.p16 = (unsigned) regs->RAM+16384;	272	file.p16 = (unsigned) regs->RAM+16384;
268	file.p20 = 0;	273	file.p20 = 0;
269	file.p21 = filename;	274	file.p21 = filename;
270		275
271	kol_file_70(&file);	276	kol_file_70(&file);
272		277
273	regs->PC.B.l = Z80MemRead(regs->SP.W, regs);	278	regs->PC.B.l = Z80MemRead(regs->SP.W, regs);
274	regs->SP.W++;	279	regs->SP.W++;
275	regs->PC.B.h = Z80MemRead(regs->SP.W, regs);	280	regs->PC.B.h = Z80MemRead(regs->SP.W, regs);
276	regs->SP.W++;	281	regs->SP.W++;
277		282
278	}	283	}
279		284
280		285
281	///=============================	286	///=============================
282		287
283	void memory_save_sna(Z80Regs regs, char filename)	288	void memory_save_sna(Z80Regs regs, char filename)
284	{	289	{
285	char buffer[27];	290	char buffer[27];
286	unsigned char sptmpl, sptmph;	291	unsigned char sptmpl, sptmph;
287	kol_struct70 file;	292	kol_struct70 file;
288		293
289	buffer[ 0] = regs->I;	294	buffer[ 0] = regs->I;
290	buffer[ 1] = regs->HLs.B.l;	295	buffer[ 1] = regs->HLs.B.l;
291	buffer[ 2] = regs->HLs.B.h;	296	buffer[ 2] = regs->HLs.B.h;
292	buffer[ 3] = regs->DEs.B.l;	297	buffer[ 3] = regs->DEs.B.l;
293	buffer[ 4] = regs->DEs.B.h;	298	buffer[ 4] = regs->DEs.B.h;
294	buffer[ 5] = regs->BCs.B.l;	299	buffer[ 5] = regs->BCs.B.l;
295	buffer[ 6] = regs->BCs.B.h;	300	buffer[ 6] = regs->BCs.B.h;
296	buffer[ 7] = regs->AFs.B.l;	301	buffer[ 7] = regs->AFs.B.l;
297	buffer[ 8] = regs->AFs.B.h;	302	buffer[ 8] = regs->AFs.B.h;
298	buffer[ 9] = regs->HL.B.l;	303	buffer[ 9] = regs->HL.B.l;
299	buffer[10] = regs->HL.B.h;	304	buffer[10] = regs->HL.B.h;
300	buffer[11] = regs->DE.B.l;	305	buffer[11] = regs->DE.B.l;
301	buffer[12] = regs->DE.B.h;	306	buffer[12] = regs->DE.B.h;
302	buffer[13] = regs->BC.B.l;	307	buffer[13] = regs->BC.B.l;
303	buffer[14] = regs->BC.B.h;	308	buffer[14] = regs->BC.B.h;
304	buffer[15] = regs->IY.B.l;	309	buffer[15] = regs->IY.B.l;
305	buffer[16] = regs->IY.B.h;	310	buffer[16] = regs->IY.B.h;
306	buffer[17] = regs->IX.B.l;	311	buffer[17] = regs->IX.B.l;
307	buffer[18] = regs->IX.B.h;	312	buffer[18] = regs->IX.B.h;
308	buffer[19] = regs->IFF1 << 2;	313	buffer[19] = regs->IFF1 << 2;
309	buffer[20] = regs->R.W & 0xFF;	314	buffer[20] = regs->R.W & 0xFF;
310	buffer[21] = regs->AF.B.l;	315	buffer[21] = regs->AF.B.l;
311	buffer[22] = regs->AF.B.h;	316	buffer[22] = regs->AF.B.h;
312		317
313	sptmpl = Z80MemRead( regs->SP.W-1, regs );	318	sptmpl = Z80MemRead( regs->SP.W-1, regs );
314	sptmph = Z80MemRead( regs->SP.W-2, regs );	319	sptmph = Z80MemRead( regs->SP.W-2, regs );
315		320
316	Z80MemWrite( --(regs->SP.W), regs->PC.B.h, regs);	321	Z80MemWrite( --(regs->SP.W), regs->PC.B.h, regs);
317	Z80MemWrite( --(regs->SP.W), regs->PC.B.l, regs);	322	Z80MemWrite( --(regs->SP.W), regs->PC.B.l, regs);
318		323
319	buffer[23] = regs->SP.B.l;	324	buffer[23] = regs->SP.B.l;
320	buffer[24] = regs->SP.B.h;	325	buffer[24] = regs->SP.B.h;
321	buffer[25] = regs->IM;	326	buffer[25] = regs->IM;
322	buffer[26] = regs->BorderColor;	327	buffer[26] = regs->BorderColor;
323		328
324	file.p00 = 2;	329	file.p00 = 2;
325	file.p04 = 0;	330	file.p04 = 0;
326	file.p08 = 0;	331	file.p08 = 0;
327	file.p12 = 27;	332	file.p12 = 27;
328	file.p16 = (unsigned) buffer;	333	file.p16 = (unsigned) buffer;
329	file.p20 = 0;	334	file.p20 = 0;
330	file.p21 = filename;	335	file.p21 = filename;
331		336
332	kol_file_70(&file);	337	kol_file_70(&file);
333		338
334	file.p00 = 3;	339	file.p00 = 3;
335	file.p04 = 27;	340	file.p04 = 27;
336	file.p08 = 0;	341	file.p08 = 0;
337	file.p12 = 0x4000*3;	342	file.p12 = 0x4000*3;
338	file.p16 = (unsigned) regs->RAM+16384;	343	file.p16 = (unsigned) regs->RAM+16384;
339	file.p20 = 0;	344	file.p20 = 0;
340	file.p21 = filename;	345	file.p21 = filename;
341		346
342	kol_file_70(&file);	347	kol_file_70(&file);
343		348
344	regs->SP.W += 2;	349	regs->SP.W += 2;
345	Z80MemWrite( regs->SP.W-1, sptmpl, regs );	350	Z80MemWrite( regs->SP.W-1, sptmpl, regs );
346	Z80MemWrite( regs->SP.W-2, sptmph, regs );	351	Z80MemWrite( regs->SP.W-2, sptmph, regs );
347		352
348	}	353	}
349		354
350		355
351	///=============================	356	///=============================
352		357
353	void memory_save_scr(Z80Regs regs, char filename)	358	void memory_save_scr(Z80Regs regs, char filename)
354	{	359	{
355	kol_struct70 file;	360	kol_struct70 file;
356		361
357		362
358	file.p00 = 2;	363	file.p00 = 2;
359	file.p04 = 0x4000;	364	file.p04 = 0x4000;
360	file.p08 = 0;	365	file.p08 = 0;
361	file.p12 = 6912;	366	file.p12 = 6912;
362	file.p16 = (unsigned) regs->RAM+16384;	367	file.p16 = (unsigned) regs->RAM+16384;
363	file.p20 = 0;	368	file.p20 = 0;
364	file.p21 = filename;	369	file.p21 = filename;
365		370
366	kol_file_70(&file);	371	kol_file_70(&file);
367		372
368	}	373	}
369		374
370		375
371	///=============================	376	///=============================
372		377
373	void wnd_draw()	378	void wnd_draw()
374	{	379	{
375	kol_paint_start();	380	kol_paint_start();
376	kol_wnd_define( (screen_w-540)/2, (screen_h-440)/2, 540, 440, 0x34b0b0b0);	381	kol_wnd_define( (screen_w-540)/2, (screen_h-440)/2, 540, 440, 0x34b0b0b0);
377	kol_wnd_caption(WND_CAPTION);	382	kol_wnd_caption(WND_CAPTION);
378	screen_print(&spectrumZ80);	383	screen_print(&spectrumZ80);
379	kol_paint_image((540 - screen_a_w)/2-5,	384	kol_paint_image((540 - screen_a_w)/2-5,
380	(440 - screen_a_h-kol_skin_height())/2,	385	(440 - screen_a_h-kol_skin_height())/2,
381	screen_a_w, screen_a_h, screen);	386	screen_a_w, screen_a_h, screen);
382	kol_paint_end();	387	kol_paint_end();
383	}	388	}
384		389
385	///=============================	390	///=============================
386		391
387	void kol_main()	392	void kol_main()
388	{	393	{
389		394
390	unsigned event;	395	unsigned event;
391	unsigned key;	396	unsigned key;
392		397
393	for (event = strlen(KOL_PATH); event > 0; --event)	398	for (event = strlen(KOL_PATH); event > 0; --event)
394	if ( '/' == KOL_PATH[event] )	399	if ( '/' == KOL_PATH[event] )
395	{	400	{
396	KOL_PATH[event+1]=0;	401	KOL_PATH[event+1]=0;
397	break;	402	break;
398	}	403	}
399		404
400	strcpy(szBackup, KOL_PATH);	405	strcpy(szBackup, KOL_PATH);
401	strcpy(szScreen, KOL_PATH);	406	strcpy(szScreen, KOL_PATH);
402	strcat(szBackup, "backup.sna");	407	strcat(szBackup, "backup.sna");
403	strcat(szScreen, "screen.scr");	408	strcat(szScreen, "screen.scr");
404		409
405	kol_screen_get_size(&screen_w, &screen_h);	410	kol_screen_get_size(&screen_w, &screen_h);
406		411
407	screen = malloc(SCREEN_LEN);	412	screen = malloc(SCREEN_LEN);
408	spectrumZ80.RAM = (char) malloc(641024);	413	spectrumZ80.RAM = (char) malloc(641024);
409	memcpy(spectrumZ80.RAM, BIOS48, 16*1024);	414	memcpy(spectrumZ80.RAM, BIOS48, 16*1024);
410		415
411	Z80Reset( &spectrumZ80, 69888 );	416	Z80Reset( &spectrumZ80, 69888 );
412	Z80FlagTables();	417	Z80FlagTables();
413		418
414	fila[1][1] = fila[1][2] = fila[2][2] = fila[3][2] = fila[4][2] =	419	fila[1][1] = fila[1][2] = fila[2][2] = fila[3][2] = fila[4][2] =
415	fila[4][1] = fila[3][1] = fila[2][1] = 0xFF;	420	fila[4][1] = fila[3][1] = fila[2][1] = 0xFF;
416		421
417	debug = 0;	422	debug = 0;
418		423
419	if (KOL_PARAM != NULL)	424	if (KOL_PARAM != NULL)
420	{	425	{
421	int type = get_ext(KOL_PARAM);	426	int type = get_ext(KOL_PARAM);
422		427
423	if (TYPE_SNA == type)	428	if (TYPE_SNA == type)
424	memory_load_sna(&spectrumZ80, KOL_PARAM);	429	memory_load_sna(&spectrumZ80, KOL_PARAM);
425	}	430	}
426		431
427	hay_tecla = main_tecla = 0;	432	hay_tecla = main_tecla = 0;
428	//keyboard_process(0);	433	//keyboard_process(0);
429		434
430	kol_key_mode_set(1);	435	kol_key_mode_set(1);
431		436
432	for (;;)	437	for (;;)
433	{	438	{
434		439
435	// event = kol_event_check();	440	// event = kol_event_check();
436	event = kol_event_wait_time(1);	441	event = kol_event_wait_time(1);
437		442
438	switch (event)	443	switch (event)
439	{	444	{
440		445
441	case 1:	446	case 1:
442	wnd_draw();	447	wnd_draw();
443	break;	448	break;
444		449
445	case 2:	450	case 2:
446	key = (kol_key_get()>>8)&0xff;	451	key = (kol_key_get()>>8)&0xff;
447		452
448	switch (key)	453	switch (key)
449	{	454	{
450	case 60: // F2	455	case 60: // F2
451	if ( IDOK == MessageBox("Save snapshot?",	456	if ( IDOK == MessageBox("Save snapshot?",
452	WND_CAPTION, MB_OKCANCEL) )	457	WND_CAPTION, MB_OKCANCEL) )
453	memory_save_sna(&spectrumZ80,	458	memory_save_sna(&spectrumZ80,
454	szBackup);	459	szBackup);
455	break;	460	break;
456		461
457	case 61: // F3	462	case 61: // F3
458	if ( IDOK == MessageBox("Load snapshot?",	463	if ( IDOK == MessageBox("Load snapshot?",
459	WND_CAPTION, MB_OKCANCEL) )	464	WND_CAPTION, MB_OKCANCEL) )
460	memory_load_sna(&spectrumZ80,	465	memory_load_sna(&spectrumZ80,
461	szBackup);	466	szBackup);
462	break;	467	break;
463		468
464	case 62: // F4	469	case 62: // F4
465	if ( IDOK == MessageBox("Save screenshot?",	470	if ( IDOK == MessageBox("Save screenshot?",
466	WND_CAPTION, MB_OKCANCEL) )	471	WND_CAPTION, MB_OKCANCEL) )
467	memory_save_scr(&spectrumZ80,	472	memory_save_scr(&spectrumZ80,
468	szScreen);	473	szScreen);
469	break;	474	break;
470		475
471	case 88: // F12 Reset	476	case 88: // F12 Reset
472	if ( IDOK == MessageBox("Reset?",	477	if ( IDOK == MessageBox("Reset?",
473	WND_CAPTION, MB_OKCANCEL) )	478	WND_CAPTION, MB_OKCANCEL) )
474	{	479	{
475	Z80Reset( &spectrumZ80, 69888 );	480	Z80Reset( &spectrumZ80, 69888 );
476	Z80FlagTables();	481	Z80FlagTables();
477	fila[1][1] = fila[1][2] =	482	fila[1][1] = fila[1][2] =
478	fila[2][2] = fila[3][2] =	483	fila[2][2] = fila[3][2] =
479	fila[4][2] = fila[4][1] =	484	fila[4][2] = fila[4][1] =
480	fila[3][1] = fila[2][1] = 0xFF;	485	fila[3][1] = fila[2][1] = 0xFF;
481	}	486	}
482	break;	487	break;
483		488
484	default:	489	default:
485	keyboard_process(key);	490	keyboard_process(key);
486	};	491	};
487		492
488	break;	493	break;
489		494
490	case 3:	495	case 3:
491	if ( 1 == (kol_btn_get() & 0xff00)>>8 )	496	if ( 1 == (kol_btn_get() & 0xff00)>>8 )
492	{	497	{
493	free(screen);	498	free(screen);
494	free(spectrumZ80.RAM);	499	free(spectrumZ80.RAM);
495	kol_exit();	500	kol_exit();

Subversion Repositories Kolibri OS

(root)/programs/emulator/e80/trunk/e80.c – Rev 1814 → 1854