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

Subversion Repositories Kolibri OS

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