Previous

199869 Revisions

Next

r20831 Friday 8th February, 2013 at 13:40:47 UTC by Miodrag Milanović
Modernization of drivers part 10 (no whatsnew)

[src/mame/drivers]	kaneko16.c karnov.c kchamp.c kickgoal.c
[src/mame/includes]	kaneko16.h kangaroo.h karnov.h kchamp.h kickgoal.h kingobox.h kncljoe.h ksayakyu.h kyugo.h
[src/mame/video]	kaneko16.c kangaroo.c karnov.c kchamp.c kickgoal.c kingobox.c kncljoe.c ksayakyu.c kyugo.c

trunk/src/mame/includes/karnov.h

r20830	r20831
59	59	DECLARE_VIDEO_START(wndrplnt);
60	60	UINT32 screen_update_karnov(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
61	61	INTERRUPT_GEN_MEMBER(karnov_interrupt);
	62	void karnov_flipscreen_w( int data );
	63	void draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect );
	64	void karnov_i8751_w( int data );
	65	void wndrplnt_i8751_w( int data );
	66	void chelnov_i8751_w( int data );
62	67	};
63	68
64	69	enum {

trunk/src/mame/includes/kingobox.h

r20830	r20831
59	59	UINT32 screen_update_kingofb(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
60	60	UINT32 screen_update_ringking(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
61	61	INTERRUPT_GEN_MEMBER(kingofb_interrupt);
	62	void palette_init_common( const UINT8 *color_prom, void (kingofb_state::*get_rgb_data)(const UINT8 *, int, int *, int *, int *) );
	63	void kingofb_get_rgb_data( const UINT8 *color_prom, int i, int *r_data, int *g_data, int *b_data );
	64	void ringking_get_rgb_data( const UINT8 *color_prom, int i, int *r_data, int *g_data, int *b_data );
	65	void kingofb_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect);
	66	void ringking_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
62	67	};

trunk/src/mame/includes/kangaroo.h

r20830	r20831
31	31	virtual void video_start();
32	32	DECLARE_MACHINE_START(kangaroo_mcu);
33	33	UINT32 screen_update_kangaroo(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
	34	void videoram_write( UINT16 offset, UINT8 data, UINT8 mask );
	35	void blitter_execute(  );
34	36	};

trunk/src/mame/includes/kchamp.h

r20830	r20831
52	52	UINT32 screen_update_kchamp(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
53	53	INTERRUPT_GEN_MEMBER(kc_interrupt);
54	54	INTERRUPT_GEN_MEMBER(sound_int);
	55	void kchamp_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	56	void kchampvs_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
	57	UINT8 *decrypt_code();
55	58	};

trunk/src/mame/includes/kaneko16.h

r20830	r20831
67	67	UINT32 screen_update_common(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
68	68	TIMER_DEVICE_CALLBACK_MEMBER(kaneko16_interrupt);
69	69	TIMER_DEVICE_CALLBACK_MEMBER(shogwarr_interrupt);
	70	void kaneko16_fill_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect);
	71	void kaneko16_common_oki_bank_w(  const char *bankname, const char* tag, int bank, size_t fixedsize, size_t bankedsize );
	72	void kaneko16_unscramble_tiles(const char *region);
	73	void kaneko16_expand_sample_banks(const char *region);
70	74	};
71	75
72	76	class kaneko16_gtmr_state : public kaneko16_state
r20830	r20831
117	121	DECLARE_PALETTE_INIT(berlwall);
118	122	DECLARE_VIDEO_START(berlwall);
119	123	UINT32 screen_update_berlwall(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	124	void kaneko16_render_15bpp_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect);
120	125	};
121	126
122	127	class kaneko16_shogwarr_state : public kaneko16_state

trunk/src/mame/includes/kncljoe.h

r20830	r20831
47	47	virtual void palette_init();
48	48	UINT32 screen_update_kncljoe(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
49	49	INTERRUPT_GEN_MEMBER(sound_nmi);
	50	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
50	51	};

trunk/src/mame/includes/kickgoal.h

r20830	r20831
76	76	DECLARE_VIDEO_START(actionhw);
77	77	UINT32 screen_update_kickgoal(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
78	78	INTERRUPT_GEN_MEMBER(kickgoal_interrupt);
	79	void kickgoal_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect);
	80	void kickgoal_play(okim6295_device *oki, int melody, int data);
79	81	};

trunk/src/mame/includes/kyugo.h

r20830	r20831
60	60	virtual void video_start();
61	61	UINT32 screen_update_kyugo(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
62	62	INTERRUPT_GEN_MEMBER(vblank_irq);
	63	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
63	64	};

trunk/src/mame/includes/ksayakyu.h

r20830	r20831
40	40	virtual void video_start();
41	41	virtual void palette_init();
42	42	UINT32 screen_update_ksayakyu(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	43	void draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect );
43	44	};

trunk/src/mame/video/kchamp.c

r20830	r20831
65	65	3        XXXXXXXX
66	66	*/
67	67
68		static void kchamp_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	68	void kchamp_state::kchamp_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
69	69	{
70		kchamp_state *state = machine.driver_data<kchamp_state>();
71		UINT8 *spriteram = state->m_spriteram;
	70	UINT8 *spriteram = m_spriteram;
72	71	int offs;
73	72
74	73	for (offs = 0; offs < 0x100; offs += 4)
r20830	r20831
82	81	int sx = spriteram[offs + 3] - 8;
83	82	int sy = 247 - spriteram[offs];
84	83
85		if (state->flip_screen())
	84	if (flip_screen())
86	85	{
87	86	sx = 240 - sx;
88	87	sy = 240 - sy;
r20830	r20831
90	89	flipy = !flipy;
91	90	}
92	91
93		drawgfx_transpen(bitmap, cliprect, machine.gfx[bank], code, color, flipx, flipy, sx, sy, 0);
	92	drawgfx_transpen(bitmap, cliprect, machine().gfx[bank], code, color, flipx, flipy, sx, sy, 0);
94	93	}
95	94	}
96	95
97		static void kchampvs_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	96	void kchamp_state::kchampvs_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
98	97	{
99		kchamp_state *state = machine.driver_data<kchamp_state>();
100		UINT8 *spriteram = state->m_spriteram;
	98	UINT8 *spriteram = m_spriteram;
101	99	int offs;
102	100
103	101	for (offs = 0; offs < 0x100; offs += 4)
r20830	r20831
111	109	int sx = spriteram[offs + 3];
112	110	int sy = 240 - spriteram[offs];
113	111
114		if (state->flip_screen())
	112	if (flip_screen())
115	113	{
116	114	sx = 240 - sx;
117	115	sy = 240 - sy;
r20830	r20831
119	117	flipy = !flipy;
120	118	}
121	119
122		drawgfx_transpen(bitmap, cliprect, machine.gfx[bank], code, color, flipx, flipy, sx, sy, 0);
	120	drawgfx_transpen(bitmap, cliprect, machine().gfx[bank], code, color, flipx, flipy, sx, sy, 0);
123	121	}
124	122	}
125	123
r20830	r20831
127	125	UINT32 kchamp_state::screen_update_kchamp(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
128	126	{
129	127	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
130		kchamp_draw_sprites(machine(), bitmap, cliprect);
	128	kchamp_draw_sprites(bitmap, cliprect);
131	129	return 0;
132	130	}
133	131
134	132	UINT32 kchamp_state::screen_update_kchampvs(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
135	133	{
136	134	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
137		kchampvs_draw_sprites(machine(), bitmap, cliprect);
	135	kchampvs_draw_sprites(bitmap, cliprect);
138	136	return 0;
139	137	}

trunk/src/mame/video/kaneko16.c

r20830	r20831
24	24
25	25
26	26
27		static void kaneko16_fill_bitmap(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	27	void kaneko16_state::kaneko16_fill_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect)
28	28	{
29		kaneko16_state *state = machine.driver_data<kaneko16_state>();
30		if (state->m_kaneko_spr)
31		if(state->m_kaneko_spr->get_sprite_type()== 1)
	29	if (m_kaneko_spr)
	30	if(m_kaneko_spr->get_sprite_type()== 1)
32	31	{
33	32	bitmap.fill(0x7f00, cliprect);
34	33	return;
r20830	r20831
67	66
68	67	UINT32 kaneko16_state::screen_update_kaneko16(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
69	68	{
70		kaneko16_fill_bitmap(machine(),bitmap,cliprect);
	69	kaneko16_fill_bitmap(bitmap,cliprect);
71	70
72	71	// if the display is disabled, do nothing?
73	72	if (!m_disp_enable) return 0;
r20830	r20831
168	167	}
169	168
170	169
171		static void kaneko16_render_15bpp_bitmap(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	170	void kaneko16_berlwall_state::kaneko16_render_15bpp_bitmap(bitmap_ind16 &bitmap, const rectangle &cliprect)
172	171	{
173		kaneko16_berlwall_state *state = machine.driver_data<kaneko16_berlwall_state>();
174		if (state->m_bg15_bitmap.valid())
	172	if (m_bg15_bitmap.valid())
175	173	{
176		int select  =   state->m_bg15_select[ 0 ];
177		//      int reg     =   state->m_bg15_reg[ 0 ];
	174	int select  =   m_bg15_select[ 0 ];
	175	//      int reg     =   m_bg15_reg[ 0 ];
178	176	int flip    =   select & 0x20;
179	177	int sx, sy;
180	178
r20830	r20831
183	181	sx      =   (select & 0x1f) * 256;
184	182	sy      =   0;
185	183
186		copybitmap(bitmap, state->m_bg15_bitmap, flip, flip, -sx, -sy, cliprect);
	184	copybitmap(bitmap, m_bg15_bitmap, flip, flip, -sx, -sy, cliprect);
187	185
188	186	//      flag = 0;
189	187	}
r20830	r20831
191	189	UINT32 kaneko16_berlwall_state::screen_update_berlwall(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
192	190	{
193	191	// berlwall uses a 15bpp bitmap as a bg, not a solid fill
194		kaneko16_render_15bpp_bitmap(machine(),bitmap,cliprect);
	192	kaneko16_render_15bpp_bitmap(bitmap,cliprect);
195	193
196	194	// if the display is disabled, do nothing?
197	195	if (!m_disp_enable) return 0;

trunk/src/mame/video/kickgoal.c

r20830	r20831
88	88
89	89
90	90
91		static void kickgoal_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap,const rectangle &cliprect)
	91	void kickgoal_state::kickgoal_draw_sprites(bitmap_ind16 &bitmap,const rectangle &cliprect)
92	92	{
93		kickgoal_state *state = machine.driver_data<kickgoal_state>();
94		UINT16 *spriteram = state->m_spriteram;
95		gfx_element *gfx = machine.gfx[1];
	93	UINT16 *spriteram = m_spriteram;
	94	gfx_element *gfx = machine().gfx[1];
96	95	int offs;
97	96
98		for (offs = 0; offs < state->m_spriteram.bytes() / 2; offs += 4)
	97	for (offs = 0; offs < m_spriteram.bytes() / 2; offs += 4)
99	98	{
100	99	int xpos = spriteram[offs + 3];
101	100	int ypos = spriteram[offs + 0] & 0x00ff;
r20830	r20831
108	107	ypos = 0x110 - ypos;
109	108
110	109	drawgfx_transpen(bitmap,cliprect,gfx,
111		tileno+state->m_sprbase,
	110	tileno+m_sprbase,
112	111	0x30 + color,
113	112	flipx,0,
114	113	xpos-16+4,ypos-32,15);
r20830	r20831
172	171	m_bg2tm->draw(bitmap, cliprect, 0, 0);
173	172	m_bgtm->draw(bitmap, cliprect, 0, 0);
174	173
175		kickgoal_draw_sprites(machine(), bitmap, cliprect);
	174	kickgoal_draw_sprites(bitmap, cliprect);
176	175
177	176	m_fgtm->draw(bitmap, cliprect, 0, 0);
178	177

trunk/src/mame/video/ksayakyu.c

r20830	r20831
78	78	[3]
79	79	*/
80	80
81		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	81	void ksayakyu_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
82	82	{
83		ksayakyu_state *state = machine.driver_data<ksayakyu_state>();
84		const UINT8 *source = state->m_spriteram + state->m_spriteram.bytes() - 4;
85		const UINT8 *finish = state->m_spriteram;
	83	const UINT8 *source = m_spriteram + m_spriteram.bytes() - 4;
	84	const UINT8 *finish = m_spriteram;
86	85
87	86	while (source>=finish) /* is order correct ? */
88	87	{
r20830	r20831
93	92	int flipx = (tile & 0x80) ? 1 : 0;
94	93	int flipy = 0;
95	94
96		gfx_element *gfx = machine.gfx[2];
	95	gfx_element *gfx = machine().gfx[2];
97	96
98		if (state->m_flipscreen)
	97	if (m_flipscreen)
99	98	{
100	99	sx = 240 - sx;
101	100	sy = 240 - sy;
r20830	r20831
128	127	m_tilemap->draw(bitmap, cliprect, 0, 0);
129	128
130	129	m_textmap->draw(bitmap, cliprect, 0, 0);
131		draw_sprites(machine(), bitmap, cliprect);
	130	draw_sprites(bitmap, cliprect);
132	131	return 0;
133	132	}

trunk/src/mame/video/karnov.c

r20830	r20831
66	66	}
67	67	}
68	68
69		void karnov_flipscreen_w( running_machine &machine, int data )
	69	void karnov_state::karnov_flipscreen_w( int data )
70	70	{
71		karnov_state *state = machine.driver_data<karnov_state>();
72		state->m_flipscreen = data;
73		machine.tilemap().set_flip_all(state->m_flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
74		state->flip_screen_set(state->m_flipscreen);
	71	m_flipscreen = data;
	72	machine().tilemap().set_flip_all(m_flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
	73	flip_screen_set(m_flipscreen);
75	74	}
76	75
77		static void draw_background( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	76	void karnov_state::draw_background( bitmap_ind16 &bitmap, const rectangle &cliprect )
78	77	{
79		karnov_state *state = machine.driver_data<karnov_state>();
80	78	int my, mx, offs, color, tile, fx, fy;
81		int scrollx = state->m_scroll[0];
82		int scrolly = state->m_scroll[1];
	79	int scrollx = m_scroll[0];
	80	int scrolly = m_scroll[1];
83	81
84		if (state->m_flipscreen)
	82	if (m_flipscreen)
85	83	fx = fy = 1;
86	84	else
87	85	fx = fy = 0;
r20830	r20831
98	96	my++;
99	97	}
100	98
101		tile = state->m_pf_data[offs];
	99	tile = m_pf_data[offs];
102	100	color = tile >> 12;
103	101	tile = tile & 0x7ff;
104		if (state->m_flipscreen)
105		drawgfx_opaque(*state->m_bitmap_f, state->m_bitmap_f->cliprect(), machine.gfx[1],tile,
	102	if (m_flipscreen)
	103	drawgfx_opaque(*m_bitmap_f, m_bitmap_f->cliprect(), machine().gfx[1],tile,
106	104	color, fx, fy, 496-16*mx,496-16*my);
107	105	else
108		drawgfx_opaque(*state->m_bitmap_f, state->m_bitmap_f->cliprect(), machine.gfx[1],tile,
	106	drawgfx_opaque(*m_bitmap_f, m_bitmap_f->cliprect(), machine().gfx[1],tile,
109	107	color, fx, fy, 16*mx,16*my);
110	108	}
111	109
112		if (!state->m_flipscreen)
	110	if (!m_flipscreen)
113	111	{
114	112	scrolly = -scrolly;
115	113	scrollx = -scrollx;
r20830	r20831
120	118	scrollx = scrollx + 256;
121	119	}
122	120
123		copyscrollbitmap(bitmap, *state->m_bitmap_f, 1, &scrollx, 1, &scrolly, cliprect);
	121	copyscrollbitmap(bitmap, *m_bitmap_f, 1, &scrollx, 1, &scrolly, cliprect);
124	122	}
125	123
126	124	/******************************************************************************/
127	125
128	126	UINT32 karnov_state::screen_update_karnov(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
129	127	{
130		draw_background(machine(), bitmap, cliprect);
	128	draw_background(bitmap, cliprect);
131	129	machine().device<deco_karnovsprites_device>("spritegen")->draw_sprites(machine(), bitmap, cliprect, m_spriteram->buffer(), 0x800, 0);
132	130	m_fix_tilemap->draw(bitmap, cliprect, 0, 0);
133	131	return 0;

trunk/src/mame/video/kingobox.c

r20830	r20831
23	23
24	24	***************************************************************************/
25	25
26		static void palette_init_common( running_machine &machine, const UINT8 *color_prom, void (*get_rgb_data)(const UINT8 *, int, int *, int *, int *) )
	26	void kingofb_state::palette_init_common( const UINT8 *color_prom, void (kingofb_state::*get_rgb_data)(const UINT8 *, int, int *, int *, int *) )
27	27	{
28	28	static const int resistances[4] = { 1500, 750, 360, 180 };
29	29	static const int resistances_fg[1] = { 51 };
r20830	r20831
43	43	4, resistances, bweights, 470, 0);
44	44
45	45	/* allocate the colortable */
46		machine.colortable = colortable_alloc(machine, 0x108);
	46	machine().colortable = colortable_alloc(machine(), 0x108);
47	47
48	48	for (i = 0; i < 0x100; i++)
49	49	{
r20830	r20831
51	51	int bit0, bit1, bit2, bit3;
52	52	int r, g, b;
53	53
54		get_rgb_data(color_prom, i, &r_data, &g_data, &b_data);
	54	(this->*get_rgb_data)(color_prom, i, &r_data, &g_data, &b_data);
55	55
56	56	/* red component */
57	57	bit0 = (r_data >> 0) & 0x01;
r20830	r20831
74	74	bit3 = (b_data >> 3) & 0x01;
75	75	b = combine_4_weights(bweights, bit0, bit1, bit2, bit3);
76	76
77		colortable_palette_set_color(machine.colortable, i, MAKE_RGB(r, g, b));
	77	colortable_palette_set_color(machine().colortable, i, MAKE_RGB(r, g, b));
78	78	}
79	79
80	80	/* the foreground chars directly map to primary colors */
r20830	r20831
91	91	/* blue component */
92	92	b = (((i - 0x100) >> 0) & 0x01) * bweights_fg[0];
93	93
94		colortable_palette_set_color(machine.colortable, i, MAKE_RGB(r, g, b));
	94	colortable_palette_set_color(machine().colortable, i, MAKE_RGB(r, g, b));
95	95	}
96	96
97	97	for (i = 0; i < 0x100; i++)
98		colortable_entry_set_value(machine.colortable, i, i);
	98	colortable_entry_set_value(machine().colortable, i, i);
99	99
100	100	for (i = 0x101; i < 0x110; i += 2)
101	101	{
102	102	UINT16 ctabentry = ((i - 0x101) >> 1) | 0x100;
103		colortable_entry_set_value(machine.colortable, i, ctabentry);
	103	colortable_entry_set_value(machine().colortable, i, ctabentry);
104	104	}
105	105	}
106	106
107	107
108		static void kingofb_get_rgb_data( const UINT8 *color_prom, int i, int *r_data, int *g_data, int *b_data )
	108	void kingofb_state::kingofb_get_rgb_data( const UINT8 *color_prom, int i, int *r_data, int *g_data, int *b_data )
109	109	{
110	110	*r_data = color_prom[i + 0x000] & 0x0f;
111	111	*g_data = color_prom[i + 0x100] & 0x0f;
r20830	r20831
113	113	}
114	114
115	115
116		static void ringking_get_rgb_data( const UINT8 *color_prom, int i, int *r_data, int *g_data, int *b_data )
	116	void kingofb_state::ringking_get_rgb_data( const UINT8 *color_prom, int i, int *r_data, int *g_data, int *b_data )
117	117	{
118	118	*r_data = (color_prom[i + 0x000] >> 4) & 0x0f;
119	119	*g_data = (color_prom[i + 0x000] >> 0) & 0x0f;
r20830	r20831
124	124	PALETTE_INIT_MEMBER(kingofb_state,kingofb)
125	125	{
126	126	const UINT8 *color_prom = machine().root_device().memregion("proms")->base();
127		palette_init_common(machine(), color_prom, kingofb_get_rgb_data);
	127	palette_init_common(color_prom, &kingofb_state::kingofb_get_rgb_data);
128	128	}
129	129
130	130	PALETTE_INIT_MEMBER(kingofb_state,ringking)
131	131	{
132	132	const UINT8 *color_prom = machine().root_device().memregion("proms")->base();
133		palette_init_common(machine(), color_prom, ringking_get_rgb_data);
	133	palette_init_common(color_prom, &kingofb_state::ringking_get_rgb_data);
134	134	}
135	135
136	136	WRITE8_MEMBER(kingofb_state::kingofb_videoram_w)
r20830	r20831
202	202	m_fg_tilemap->set_transparent_pen(0);
203	203	}
204	204
205		static void kingofb_draw_sprites(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect)
	205	void kingofb_state::kingofb_draw_sprites(bitmap_ind16 &bitmap, const rectangle &cliprect)
206	206	{
207		kingofb_state *state = machine.driver_data<kingofb_state>();
208		UINT8 *spriteram = state->m_spriteram;
	207	UINT8 *spriteram = m_spriteram;
209	208	int offs;
210	209
211		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	210	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
212	211	{
213	212	int roffs, bank, code, color, flipx, flipy, sx, sy;
214	213
r20830	r20831
219	218
220	219	bank = (spriteram[roffs + 3] & 0x04) >> 2;
221	220	code = spriteram[roffs + 2] + ((spriteram[roffs + 3] & 0x03) << 8);
222		color = ((spriteram[roffs + 3] & 0x70) >> 4) + 8 * state->m_palette_bank;
	221	color = ((spriteram[roffs + 3] & 0x70) >> 4) + 8 * m_palette_bank;
223	222	flipx = 0;
224	223	flipy = spriteram[roffs + 3] & 0x80;
225	224	sx = spriteram[roffs + 1];
226	225	sy = spriteram[roffs];
227	226
228		if (state->flip_screen())
	227	if (flip_screen())
229	228	{
230	229	sx = 240 - sx;
231	230	sy = 240 - sy;
r20830	r20831
233	232	flipy = !flipy;
234	233	}
235	234
236		drawgfx_transpen(bitmap, cliprect, machine.gfx[2 + bank],
	235	drawgfx_transpen(bitmap, cliprect, machine().gfx[2 + bank],
237	236	code, color,
238	237	flipx, flipy,
239	238	sx, sy, 0);
r20830	r20831
244	243	{
245	244	m_bg_tilemap->set_scrolly(0, -(*m_scroll_y));
246	245	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
247		kingofb_draw_sprites(machine(), bitmap, cliprect);
	246	kingofb_draw_sprites(bitmap, cliprect);
248	247	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
249	248	return 0;
250	249	}
r20830	r20831
267	266	m_fg_tilemap->set_transparent_pen(0);
268	267	}
269	268
270		static void ringking_draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	269	void kingofb_state::ringking_draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
271	270	{
272		kingofb_state *state = machine.driver_data<kingofb_state>();
273		UINT8 *spriteram = state->m_spriteram;
	271	UINT8 *spriteram = m_spriteram;
274	272	int offs;
275	273
276		for (offs = 0; offs < state->m_spriteram.bytes(); offs += 4)
	274	for (offs = 0; offs < m_spriteram.bytes(); offs += 4)
277	275	{
278	276	int bank = (spriteram[offs + 1] & 0x04) >> 2;
279	277	int code = spriteram[offs + 3] + ((spriteram[offs + 1] & 0x03) << 8);
280		int color = ((spriteram[offs + 1] & 0x70) >> 4) + 8 * state->m_palette_bank;
	278	int color = ((spriteram[offs + 1] & 0x70) >> 4) + 8 * m_palette_bank;
281	279	int flipx = 0;
282	280	int flipy = (spriteram[offs + 1] & 0x80) ? 0 : 1;
283	281	int sx = spriteram[offs + 2];
284	282	int sy = spriteram[offs];
285	283
286		if (state->flip_screen())
	284	if (flip_screen())
287	285	{
288	286	sx = 240 - sx;
289	287	sy = 240 - sy;
r20830	r20831
291	289	flipy = !flipy;
292	290	}
293	291
294		drawgfx_transpen(bitmap, cliprect, machine.gfx[2 + bank],
	292	drawgfx_transpen(bitmap, cliprect, machine().gfx[2 + bank],
295	293	code, color,
296	294	flipx, flipy,
297	295	sx, sy, 0);
r20830	r20831
302	300	{
303	301	m_bg_tilemap->set_scrolly(0, -(*m_scroll_y));
304	302	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
305		ringking_draw_sprites(machine(), bitmap, cliprect);
	303	ringking_draw_sprites(bitmap, cliprect);
306	304	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
307	305	return 0;
308	306	}

trunk/src/mame/video/kncljoe.c

r20830	r20831
176	176
177	177	***************************************************************************/
178	178
179		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	179	void kncljoe_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
180	180	{
181		kncljoe_state *state = machine.driver_data<kncljoe_state>();
182		UINT8 *spriteram = state->m_spriteram;
	181	UINT8 *spriteram = m_spriteram;
183	182	rectangle clip = cliprect;
184		gfx_element *gfx = machine.gfx[1 + state->m_sprite_bank];
	183	gfx_element *gfx = machine().gfx[1 + m_sprite_bank];
185	184	int i, j;
186	185	static const int pribase[4]={0x0180, 0x0080, 0x0100, 0x0000};
187		const rectangle &visarea = machine.primary_screen->visible_area();
	186	const rectangle &visarea = machine().primary_screen->visible_area();
188	187
189	188	/* score covers sprites */
190		if (state->m_flipscreen)
	189	if (m_flipscreen)
191	190	{
192	191	if (clip.max_y > visarea.max_y - 64)
193	192	clip.max_y = visarea.max_y - 64;
r20830	r20831
215	214	if (attr & 0x20)
216	215	code += 256;
217	216
218		if (state->m_flipscreen)
	217	if (m_flipscreen)
219	218	{
220	219	flipx = !flipx;
221	220	flipy = !flipy;
r20830	r20831
237	236	UINT32 kncljoe_state::screen_update_kncljoe(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
238	237	{
239	238	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
240		draw_sprites(machine(), bitmap, cliprect);
	239	draw_sprites(bitmap, cliprect);
241	240	return 0;
242	241	}

trunk/src/mame/video/kyugo.c

r20830	r20831
142	142	*
143	143	*************************************/
144	144
145		static void draw_sprites( running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect )
	145	void kyugo_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect )
146	146	{
147		kyugo_state *state = machine.driver_data<kyugo_state>();
148
149	147	/* sprite information is scattered through memory */
150	148	/* and uses a portion of the text layer memory (outside the visible area) */
151		UINT8 *spriteram_area1 = &state->m_spriteram_1[0x28];
152		UINT8 *spriteram_area2 = &state->m_spriteram_2[0x28];
153		UINT8 *spriteram_area3 = &state->m_fgvideoram[0x28];
	149	UINT8 *spriteram_area1 = &m_spriteram_1[0x28];
	150	UINT8 *spriteram_area2 = &m_spriteram_2[0x28];
	151	UINT8 *spriteram_area3 = &m_fgvideoram[0x28];
154	152
155	153	int n;
156	154
r20830	r20831
168	166	if (sy > 0xf0)
169	167	sy -= 256;
170	168
171		if (state->m_flipscreen)
	169	if (m_flipscreen)
172	170	sy = 240 - sy;
173	171
174	172	color = spriteram_area1[offs + 1] & 0x1f;
r20830	r20831
185	183	flipx =  attr & 0x08;
186	184	flipy =  attr & 0x04;
187	185
188		if (state->m_flipscreen)
	186	if (m_flipscreen)
189	187	{
190	188	flipx = !flipx;
191	189	flipy = !flipy;
192	190	}
193	191
194	192
195		drawgfx_transpen( bitmap, cliprect,machine.gfx[2],
	193	drawgfx_transpen( bitmap, cliprect,machine().gfx[2],
196	194	code,
197	195	color,
198	196	flipx,flipy,
199		sx,state->m_flipscreen ? sy - 16*y : sy + 16*y, 0 );
	197	sx,m_flipscreen ? sy - 16*y : sy + 16*y, 0 );
200	198	}
201	199	}
202	200	}
r20830	r20831
212	210	m_bg_tilemap->set_scrolly(0, m_scroll_y);
213	211
214	212	m_bg_tilemap->draw(bitmap, cliprect, 0, 0);
215		draw_sprites(machine(), bitmap, cliprect);
	213	draw_sprites(bitmap, cliprect);
216	214	m_fg_tilemap->draw(bitmap, cliprect, 0, 0);
217	215	return 0;
218	216	}

trunk/src/mame/video/kangaroo.c

r20830	r20831
7	7	#include "emu.h"
8	8	#include "includes/kangaroo.h"
9	9
10		static void blitter_execute(running_machine &machine);
11
12
13	10	/*************************************
14	11	*
15	12	*  Video setup
r20830	r20831
31	28	*
32	29	*************************************/
33	30
34		static void videoram_write( running_machine &machine, UINT16 offset, UINT8 data, UINT8 mask )
	31	void kangaroo_state::videoram_write( UINT16 offset, UINT8 data, UINT8 mask )
35	32	{
36		kangaroo_state *state = machine.driver_data<kangaroo_state>();
37	33	UINT32 expdata, layermask;
38	34
39	35	/* data contains 4 2-bit values packed as DCBADCBA; expand these into 4 8-bit values */
r20830	r20831
55	51	if (mask & 0x01) layermask |= 0x0c0c0c0c;
56	52
57	53	/* update layers */
58		state->m_videoram[offset] = (state->m_videoram[offset] & ~layermask) | (expdata & layermask);
	54	m_videoram[offset] = (m_videoram[offset] & ~layermask) | (expdata & layermask);
59	55	}
60	56
61	57
62	58	WRITE8_MEMBER(kangaroo_state::kangaroo_videoram_w)
63	59	{
64		videoram_write(machine(), offset, data, m_video_control[8]);
	60	videoram_write(offset, data, m_video_control[8]);
65	61	}
66	62
67	63
r20830	r20831
79	75	switch (offset)
80	76	{
81	77	case 5: /* blitter start */
82		blitter_execute(machine());
	78	blitter_execute();
83	79	break;
84	80
85	81	case 8: /* bank select */
r20830	r20831
96	92	*
97	93	*************************************/
98	94
99		static void blitter_execute( running_machine &machine )
	95	void kangaroo_state::blitter_execute(  )
100	96	{
101		kangaroo_state *state = machine.driver_data<kangaroo_state>();
102		UINT32 gfxhalfsize = state->memregion("gfx1")->bytes() / 2;
103		const UINT8 *gfxbase = state->memregion("gfx1")->base();
104		UINT16 src = state->m_video_control[0] + 256 * state->m_video_control[1];
105		UINT16 dst = state->m_video_control[2] + 256 * state->m_video_control[3];
106		UINT8 height = state->m_video_control[5];
107		UINT8 width = state->m_video_control[4];
108		UINT8 mask = state->m_video_control[8];
	97	UINT32 gfxhalfsize = memregion("gfx1")->bytes() / 2;
	98	const UINT8 *gfxbase = memregion("gfx1")->base();
	99	UINT16 src = m_video_control[0] + 256 * m_video_control[1];
	100	UINT16 dst = m_video_control[2] + 256 * m_video_control[3];
	101	UINT8 height = m_video_control[5];
	102	UINT8 width = m_video_control[4];
	103	UINT8 mask = m_video_control[8];
109	104	int x, y;
110	105
111	106	/* during DMA operations, the top 2 bits are ORed together, as well as the bottom 2 bits */
r20830	r20831
119	114	{
120	115	UINT16 effdst = (dst + x) & 0x3fff;
121	116	UINT16 effsrc = src++ & (gfxhalfsize - 1);
122		videoram_write(machine, effdst, gfxbase[0 * gfxhalfsize + effsrc], mask & 0x05);
123		videoram_write(machine, effdst, gfxbase[1 * gfxhalfsize + effsrc], mask & 0x0a);
	117	videoram_write(effdst, gfxbase[0 * gfxhalfsize + effsrc], mask & 0x05);
	118	videoram_write(effdst, gfxbase[1 * gfxhalfsize + effsrc], mask & 0x0a);
124	119	}
125	120	}
126	121

trunk/src/mame/drivers/kickgoal.c

r20830	r20831
116	116	//static int kickgoal_melody;
117	117	//static int kickgoal_snd_bank;
118	118
119		static void kickgoal_play(okim6295_device *oki, int melody, int data)
	119	void ::kickgoal_play(okim6295_device *oki, int melody, int data)
120	120	{
121	121	int status = oki->read(0);
122	122
r20830	r20831
124	124	if (kickgoal_sound == 0) popmessage("Unknown sound command %02x",kickgoal_sound);
125	125
126	126	if (melody) {
127		if (state->m_melody != kickgoal_sound) {
128		state->m_melody      = kickgoal_sound;
129		state->m_melody_loop = kickgoal_sound;
	127	if (m_melody != kickgoal_sound) {
	128	m_melody      = kickgoal_sound;
	129	m_melody_loop = kickgoal_sound;
130	130	if (status & 0x08)
131	131	oki->write(0,0x40);
132		oki->write(0,(0x80 | state->m_melody));
	132	oki->write(0,(0x80 | m_melody));
133	133	oki->write(0,0x81);
134	134	}
135	135	}

trunk/src/mame/drivers/kchamp.c

r20830	r20831
705	705	ROM_END
706	706
707	707
708		static UINT8 *decrypt_code(running_machine &machine)
	708	UINT8 *kchamp_state::decrypt_code()
709	709	{
710		address_space &space = machine.device("maincpu")->memory().space(AS_PROGRAM);
711		UINT8 *decrypted = auto_alloc_array(machine, UINT8, 0x10000);
712		UINT8 *rom = machine.root_device().memregion("maincpu")->base();
	710	address_space &space = machine().device("maincpu")->memory().space(AS_PROGRAM);
	711	UINT8 *decrypted = auto_alloc_array(machine(), UINT8, 0x10000);
	712	UINT8 *rom = machine().root_device().memregion("maincpu")->base();
713	713	int A;
714	714
715	715	space.set_decrypted_region(0x0000, 0xffff, decrypted);
r20830	r20831
724	724	DRIVER_INIT_MEMBER(kchamp_state,kchampvs)
725	725	{
726	726	UINT8 *rom = memregion("maincpu")->base();
727		UINT8 *decrypted = decrypt_code(machine());
	727	UINT8 *decrypted = decrypt_code();
728	728	int A;
729	729
730	730	/*
r20830	r20831
754	754
755	755	DRIVER_INIT_MEMBER(kchamp_state,kchampvs2)
756	756	{
757		decrypt_code(machine());
	757	decrypt_code();
758	758	m_counter = 0;
759	759	m_msm_data = 0;
760	760	m_msm_play_lo_nibble = 1;

trunk/src/mame/drivers/kaneko16.c

r20830	r20831
632	632	Shogun Warriors
633	633	***************************************************************************/
634	634
635		static void kaneko16_common_oki_bank_w( running_machine& machine, const char *bankname, const char* tag, int bank, size_t fixedsize, size_t bankedsize )
	635	void kaneko16_state::kaneko16_common_oki_bank_w(  const char *bankname, const char* tag, int bank, size_t fixedsize, size_t bankedsize )
636	636	{
637	637	UINT32 bankaddr;
638		UINT8* samples = machine.root_device().memregion(tag)->base();
639		size_t length = machine.root_device().memregion(tag)->bytes();
	638	UINT8* samples = machine().root_device().memregion(tag)->base();
	639	size_t length = machine().root_device().memregion(tag)->bytes();
640	640
641	641	bankaddr = fixedsize + (bankedsize * bank);
642	642
643	643	if (bankaddr <= (length-bankedsize))
644	644	{
645		machine.root_device().membank(bankname)->set_base(samples + bankaddr);
	645	machine().root_device().membank(bankname)->set_base(samples + bankaddr);
646	646	}
647	647	}
648	648
r20830	r20831
650	650	{
651	651	if (ACCESSING_BITS_0_7)
652	652	{
653		kaneko16_common_oki_bank_w(machine(), "bank10", "oki1", (data >> 4) & 0xf, 0x30000, 0x10000);
654		kaneko16_common_oki_bank_w(machine(), "bank11", "oki2", (data & 0xf)     , 0x00000, 0x40000);
	653	kaneko16_common_oki_bank_w("bank10", "oki1", (data >> 4) & 0xf, 0x30000, 0x10000);
	654	kaneko16_common_oki_bank_w("bank11", "oki2", (data & 0xf)     , 0x00000, 0x40000);
655	655	}
656	656	}
657	657
r20830	r20831
659	659	{
660	660	if (ACCESSING_BITS_0_7)
661	661	{
662		kaneko16_common_oki_bank_w(machine(), "bank10", "oki1", (data >> 4) & 0xf, 0x30000, 0x10000);
663		kaneko16_common_oki_bank_w(machine(), "bank11", "oki2", (data & 0xf)     , 0x20000, 0x20000);
	662	kaneko16_common_oki_bank_w("bank10", "oki1", (data >> 4) & 0xf, 0x30000, 0x10000);
	663	kaneko16_common_oki_bank_w("bank11", "oki2", (data & 0xf)     , 0x20000, 0x20000);
664	664	}
665	665	}
666	666
r20830	r20831
2155	2155	have the even and odd pixels swapped. So we use this function to untangle
2156	2156	them and have one single gfxlayout for both tiles and sprites.
2157	2157	*/
2158		static void kaneko16_unscramble_tiles(running_machine &machine, const char *region)
	2158	void kaneko16_state::kaneko16_unscramble_tiles(const char *region)
2159	2159	{
2160		UINT8 *RAM  =   machine.root_device().memregion(region)->base();
2161		int size            =   machine.root_device().memregion(region)->bytes();
	2160	UINT8 *RAM  =   machine().root_device().memregion(region)->base();
	2161	int size            =   machine().root_device().memregion(region)->bytes();
2162	2162	int i;
2163	2163
2164	2164	if (RAM == NULL)    return;
r20830	r20831
2169	2169	}
2170	2170	}
2171	2171
2172		static void kaneko16_expand_sample_banks(running_machine &machine, const char *region)
	2172	void kaneko16_state::kaneko16_expand_sample_banks(const char *region)
2173	2173	{
2174	2174	/* The sample data for the first OKI has an address translator/
2175	2175	banking register in it that munges the addresses as follows:
r20830	r20831
2183	2183	int bank;
2184	2184	UINT8 *src0;
2185	2185
2186		if (machine.root_device().memregion(region)->bytes() < 0x40000 * 16)
	2186	if (machine().root_device().memregion(region)->bytes() < 0x40000 * 16)
2187	2187	fatalerror("gtmr SOUND1 region too small\n");
2188	2188
2189	2189	/* bank 0 maps to itself, so we just leave it alone */
2190		src0 = machine.root_device().memregion(region)->base();
	2190	src0 = machine().root_device().memregion(region)->base();
2191	2191	for (bank = 15; bank > 0; bank--)
2192	2192	{
2193	2193	UINT8 *srcn = src0 + 0x10000 * (bank < 3 ? 3 : bank);
r20830	r20831
2200	2200
2201	2201	DRIVER_INIT_MEMBER( kaneko16_state, kaneko16 )
2202	2202	{
2203		kaneko16_unscramble_tiles(machine(), "gfx2");
2204		kaneko16_unscramble_tiles(machine(), "gfx3");
	2203	kaneko16_unscramble_tiles("gfx2");
	2204	kaneko16_unscramble_tiles("gfx3");
2205	2205	}
2206	2206
2207	2207	DRIVER_INIT_MEMBER( kaneko16_berlwall_state, berlwall )
2208	2208	{
2209		kaneko16_unscramble_tiles(machine(), "gfx2");
	2209	kaneko16_unscramble_tiles("gfx2");
2210	2210	}
2211	2211
2212	2212	DRIVER_INIT_MEMBER( kaneko16_state, samplebank )
2213	2213	{
2214		kaneko16_unscramble_tiles(machine(), "gfx2");
2215		kaneko16_unscramble_tiles(machine(), "gfx3");
2216		kaneko16_expand_sample_banks(machine(), "oki1");
	2214	kaneko16_unscramble_tiles("gfx2");
	2215	kaneko16_unscramble_tiles("gfx3");
	2216	kaneko16_expand_sample_banks("oki1");
2217	2217	}
2218	2218
2219	2219
r20830	r20831
3829	3829	DRIVER_INIT_MEMBER( kaneko16_shogwarr_state, shogwarr )
3830	3830	{
3831	3831	// default sample banks
3832		kaneko16_common_oki_bank_w(machine(), "bank10", "oki1", 0, 0x30000, 0x10000);
3833		kaneko16_common_oki_bank_w(machine(), "bank11", "oki2", 0, 0x00000, 0x40000);
	3832	kaneko16_common_oki_bank_w("bank10", "oki1", 0, 0x30000, 0x10000);
	3833	kaneko16_common_oki_bank_w("bank11", "oki2", 0, 0x00000, 0x40000);
3834	3834	DRIVER_INIT_CALL(kaneko16);
3835	3835	}
3836	3836
r20830	r20831
3841	3841	machine().device("maincpu")->memory().space(AS_PROGRAM).install_write_handler(0xe00000, 0xe00001, write16_delegate(FUNC(kaneko16_shogwarr_state::brapboys_oki_bank_w),this));
3842	3842
3843	3843	// default sample banks
3844		kaneko16_common_oki_bank_w(machine(), "bank10", "oki1", 0, 0x30000, 0x10000);
3845		kaneko16_common_oki_bank_w(machine(), "bank11", "oki2", 0, 0x20000, 0x20000);
	3844	kaneko16_common_oki_bank_w("bank10", "oki1", 0, 0x30000, 0x10000);
	3845	kaneko16_common_oki_bank_w("bank11", "oki2", 0, 0x20000, 0x20000);
3846	3846	DRIVER_INIT_CALL(kaneko16);
3847	3847	}
3848	3848

trunk/src/mame/drivers/karnov.c

r20830	r20831
91	91	*************************************/
92	92
93	93	/* Emulation of the protected microcontroller - for coins & general protection */
94		static void karnov_i8751_w( running_machine &machine, int data )
	94	void karnov_state::karnov_i8751_w( int data )
95	95	{
96		karnov_state *state = machine.driver_data<karnov_state>();
97
98	96	/* Pending coin operations may cause protection commands to be queued */
99		if (state->m_i8751_needs_ack)
	97	if (m_i8751_needs_ack)
100	98	{
101		state->m_i8751_command_queue = data;
	99	m_i8751_command_queue = data;
102	100	return;
103	101	}
104	102
105		state->m_i8751_return = 0;
	103	m_i8751_return = 0;
106	104
107		if (data == 0x100 && state->m_microcontroller_id == KARNOV) /* USA version */
108		state->m_i8751_return = 0x56b;
	105	if (data == 0x100 && m_microcontroller_id == KARNOV) /* USA version */
	106	m_i8751_return = 0x56b;
109	107
110		if (data == 0x100 && state->m_microcontroller_id == KARNOVJ)    /* Japan version */
111		state->m_i8751_return = 0x56a;
	108	if (data == 0x100 && m_microcontroller_id == KARNOVJ)    /* Japan version */
	109	m_i8751_return = 0x56a;
112	110
113	111	if ((data & 0xf00) == 0x300)
114		state->m_i8751_return = (data & 0xff) * 0x12; /* Player sprite mapping */
	112	m_i8751_return = (data & 0xff) * 0x12; /* Player sprite mapping */
115	113
116	114	/* I'm not sure the ones marked ^ appear in the right order */
117		if (data == 0x400) state->m_i8751_return = 0x4000; /* Get The Map... */
118		if (data == 0x402) state->m_i8751_return = 0x40a6; /* Ancient Ruins */
119		if (data == 0x403) state->m_i8751_return = 0x4054; /* Forest... */
120		if (data == 0x404) state->m_i8751_return = 0x40de; /* ^Rocky hills */
121		if (data == 0x405) state->m_i8751_return = 0x4182; /* Sea */
122		if (data == 0x406) state->m_i8751_return = 0x41ca; /* Town */
123		if (data == 0x407) state->m_i8751_return = 0x421e; /* Desert */
124		if (data == 0x401) state->m_i8751_return = 0x4138; /* ^Whistling wind */
125		if (data == 0x408) state->m_i8751_return = 0x4276; /* ^Heavy Gates */
	115	if (data == 0x400) m_i8751_return = 0x4000; /* Get The Map... */
	116	if (data == 0x402) m_i8751_return = 0x40a6; /* Ancient Ruins */
	117	if (data == 0x403) m_i8751_return = 0x4054; /* Forest... */
	118	if (data == 0x404) m_i8751_return = 0x40de; /* ^Rocky hills */
	119	if (data == 0x405) m_i8751_return = 0x4182; /* Sea */
	120	if (data == 0x406) m_i8751_return = 0x41ca; /* Town */
	121	if (data == 0x407) m_i8751_return = 0x421e; /* Desert */
	122	if (data == 0x401) m_i8751_return = 0x4138; /* ^Whistling wind */
	123	if (data == 0x408) m_i8751_return = 0x4276; /* ^Heavy Gates */
126	124
127		//  if (!state->m_i8751_return && data != 0x300) logerror("%s - Unknown Write %02x intel\n", machine.describe_context(), data);
	125	//  if (!m_i8751_return && data != 0x300) logerror("%s - Unknown Write %02x intel\n", machine().describe_context(), data);
128	126
129		state->m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
130		state->m_i8751_needs_ack = 1;
	127	m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
	128	m_i8751_needs_ack = 1;
131	129	}
132	130
133		static void wndrplnt_i8751_w( running_machine &machine, int data )
	131	void karnov_state::wndrplnt_i8751_w( int data )
134	132	{
135		karnov_state *state = machine.driver_data<karnov_state>();
136
137	133	/* The last command hasn't been ACK'd (probably a conflict with coin command) */
138		if (state->m_i8751_needs_ack)
	134	if (m_i8751_needs_ack)
139	135	{
140		state->m_i8751_command_queue = data;
	136	m_i8751_command_queue = data;
141	137	return;
142	138	}
143	139
144		state->m_i8751_return=0;
	140	m_i8751_return=0;
145	141
146		if (data == 0x100) state->m_i8751_return = 0x67a;
147		if (data == 0x200) state->m_i8751_return = 0x214;
148		if (data == 0x300) state->m_i8751_return = 0x17; /* Copyright text on title screen */
149		//  if (data == 0x300) state->m_i8751_return = 0x1; /* (USA) Copyright text on title screen */
	142	if (data == 0x100) m_i8751_return = 0x67a;
	143	if (data == 0x200) m_i8751_return = 0x214;
	144	if (data == 0x300) m_i8751_return = 0x17; /* Copyright text on title screen */
	145	//  if (data == 0x300) m_i8751_return = 0x1; /* (USA) Copyright text on title screen */
150	146
151	147	/* The game writes many values in the 0x600 range, but only a specific mask
152	148	matters for the return value */
r20830	r20831
154	150	{
155	151	switch (data & 0x18)
156	152	{
157		case 0x00:  state->m_i8751_return = 0x4d53; break;
158		case 0x08:  state->m_i8751_return = 0x4b54; break;
159		case 0x10:  state->m_i8751_return = 0x5453; break;
160		case 0x18:  state->m_i8751_return = 0x5341; break;
	153	case 0x00:  m_i8751_return = 0x4d53; break;
	154	case 0x08:  m_i8751_return = 0x4b54; break;
	155	case 0x10:  m_i8751_return = 0x5453; break;
	156	case 0x18:  m_i8751_return = 0x5341; break;
161	157	}
162	158	}
163		//  else logerror("%s - Unknown Write %02x intel\n", machine.describe_context(), data);
	159	//  else logerror("%s - Unknown Write %02x intel\n", machine().describe_context(), data);
164	160
165	161	/* These are 68k function call addresses - different address for each power-up */
166		if (data == 0x400) state->m_i8751_return = 0x594;
167		if (data == 0x401) state->m_i8751_return = 0x5ea;
168		if (data == 0x402) state->m_i8751_return = 0x628;
169		if (data == 0x403) state->m_i8751_return = 0x66c;
170		if (data == 0x404) state->m_i8751_return = 0x6a4;
171		if (data == 0x405) state->m_i8751_return = 0x6a4;
172		if (data == 0x406) state->m_i8751_return = 0x6a4;
	162	if (data == 0x400) m_i8751_return = 0x594;
	163	if (data == 0x401) m_i8751_return = 0x5ea;
	164	if (data == 0x402) m_i8751_return = 0x628;
	165	if (data == 0x403) m_i8751_return = 0x66c;
	166	if (data == 0x404) m_i8751_return = 0x6a4;
	167	if (data == 0x405) m_i8751_return = 0x6a4;
	168	if (data == 0x406) m_i8751_return = 0x6a4;
173	169
174	170	/* This is 68k program code which is executed every frame */
175		if (data == 0x50c) state->m_i8751_return = 0x13fc;
176		if (data == 0x50b) state->m_i8751_return = 0x00ff;
177		if (data == 0x50a) state->m_i8751_return = 0x0006;
178		if (data == 0x509) state->m_i8751_return = 0x0000;
179		if (data == 0x508) state->m_i8751_return = 0x4a39;
180		if (data == 0x507) state->m_i8751_return = 0x0006;
181		if (data == 0x506) state->m_i8751_return = 0x0000;
182		if (data == 0x505) state->m_i8751_return = 0x66f8;
183		if (data == 0x504) state->m_i8751_return = 0x4a39;
184		if (data == 0x503) state->m_i8751_return = 0x000c;
185		if (data == 0x502) state->m_i8751_return = 0x0003;
186		if (data == 0x501) state->m_i8751_return = 0x6bf8;
187		if (data == 0x500) state->m_i8751_return = 0x4e75;
	171	if (data == 0x50c) m_i8751_return = 0x13fc;
	172	if (data == 0x50b) m_i8751_return = 0x00ff;
	173	if (data == 0x50a) m_i8751_return = 0x0006;
	174	if (data == 0x509) m_i8751_return = 0x0000;
	175	if (data == 0x508) m_i8751_return = 0x4a39;
	176	if (data == 0x507) m_i8751_return = 0x0006;
	177	if (data == 0x506) m_i8751_return = 0x0000;
	178	if (data == 0x505) m_i8751_return = 0x66f8;
	179	if (data == 0x504) m_i8751_return = 0x4a39;
	180	if (data == 0x503) m_i8751_return = 0x000c;
	181	if (data == 0x502) m_i8751_return = 0x0003;
	182	if (data == 0x501) m_i8751_return = 0x6bf8;
	183	if (data == 0x500) m_i8751_return = 0x4e75;
188	184
189		state->m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
190		state->m_i8751_needs_ack = 1;
	185	m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
	186	m_i8751_needs_ack = 1;
191	187	}
192	188
193		static void chelnov_i8751_w( running_machine &machine, int data )
	189	void karnov_state::chelnov_i8751_w( int data )
194	190	{
195		karnov_state *state = machine.driver_data<karnov_state>();
196
197	191	/* Pending coin operations may cause protection commands to be queued */
198		if (state->m_i8751_needs_ack)
	192	if (m_i8751_needs_ack)
199	193	{
200		state->m_i8751_command_queue = data;
	194	m_i8751_command_queue = data;
201	195	return;
202	196	}
203	197
204		state->m_i8751_return = 0;
	198	m_i8751_return = 0;
205	199
206		if (data == 0x200 && state->m_microcontroller_id == CHELNOV)    /* World version */
207		state->m_i8751_return = 0x7736;
	200	if (data == 0x200 && m_microcontroller_id == CHELNOV)    /* World version */
	201	m_i8751_return = 0x7736;
208	202
209		if (data == 0x200 && state->m_microcontroller_id == CHELNOVU)   /* USA version */
210		state->m_i8751_return = 0x783e;
	203	if (data == 0x200 && m_microcontroller_id == CHELNOVU)   /* USA version */
	204	m_i8751_return = 0x783e;
211	205
212		if (data == 0x200 && state->m_microcontroller_id == CHELNOVJ)   /* Japan version */
213		state->m_i8751_return = 0x7734;
	206	if (data == 0x200 && m_microcontroller_id == CHELNOVJ)   /* Japan version */
	207	m_i8751_return = 0x7734;
214	208
215		if (data == 0x100 && state->m_microcontroller_id == CHELNOV)    /* World version */
216		state->m_i8751_return = 0x71c;
	209	if (data == 0x100 && m_microcontroller_id == CHELNOV)    /* World version */
	210	m_i8751_return = 0x71c;
217	211
218		if (data == 0x100 && state->m_microcontroller_id == CHELNOVU)   /* USA version */
219		state->m_i8751_return = 0x71b;
	212	if (data == 0x100 && m_microcontroller_id == CHELNOVU)   /* USA version */
	213	m_i8751_return = 0x71b;
220	214
221		if (data == 0x100 && state->m_microcontroller_id == CHELNOVJ)   /* Japan version */
222		state->m_i8751_return = 0x71a;
	215	if (data == 0x100 && m_microcontroller_id == CHELNOVJ)   /* Japan version */
	216	m_i8751_return = 0x71a;
223	217
224	218	if (data >= 0x6000 && data < 0x8000)
225		state->m_i8751_return = 1;  /* patched */
	219	m_i8751_return = 1;  /* patched */
226	220
227		if ((data & 0xf000) == 0x1000) state->m_i8751_level = 1;        /* Level 1 */
228		if ((data & 0xf000) == 0x2000) state->m_i8751_level++;      /* Level Increment */
	221	if ((data & 0xf000) == 0x1000) m_i8751_level = 1;        /* Level 1 */
	222	if ((data & 0xf000) == 0x2000) m_i8751_level++;      /* Level Increment */
229	223
230	224	if ((data & 0xf000) == 0x3000)
231	225	{
232	226	/* Sprite table mapping */
233	227	int b = data & 0xff;
234		switch (state->m_i8751_level)
	228	switch (m_i8751_level)
235	229	{
236	230	case 1: /* Level 1, Sprite mapping tables */
237		if (state->m_microcontroller_id == CHELNOVU) /* USA */
	231	if (m_microcontroller_id == CHELNOVU) /* USA */
238	232	{
239		if (b < 2) state->m_i8751_return = 0;
240		else if (b < 6) state->m_i8751_return = 1;
241		else if (b < 0xb) state->m_i8751_return = 2;
242		else if (b < 0xf) state->m_i8751_return = 3;
243		else if (b < 0x13) state->m_i8751_return = 4;
244		else state->m_i8751_return = 5;
	233	if (b < 2) m_i8751_return = 0;
	234	else if (b < 6) m_i8751_return = 1;
	235	else if (b < 0xb) m_i8751_return = 2;
	236	else if (b < 0xf) m_i8751_return = 3;
	237	else if (b < 0x13) m_i8751_return = 4;
	238	else m_i8751_return = 5;
245	239	}
246	240	else    /* Japan, World */
247	241	{
248		if (b < 3) state->m_i8751_return = 0;
249		else if (b < 8) state->m_i8751_return = 1;
250		else if (b < 0xc) state->m_i8751_return = 2;
251		else if (b < 0x10) state->m_i8751_return = 3;
252		else if (b < 0x19) state->m_i8751_return = 4;
253		else if (b < 0x1b) state->m_i8751_return = 5;
254		else if (b < 0x22) state->m_i8751_return = 6;
255		else if (b < 0x28) state->m_i8751_return = 7;
256		else state->m_i8751_return = 8;
	242	if (b < 3) m_i8751_return = 0;
	243	else if (b < 8) m_i8751_return = 1;
	244	else if (b < 0xc) m_i8751_return = 2;
	245	else if (b < 0x10) m_i8751_return = 3;
	246	else if (b < 0x19) m_i8751_return = 4;
	247	else if (b < 0x1b) m_i8751_return = 5;
	248	else if (b < 0x22) m_i8751_return = 6;
	249	else if (b < 0x28) m_i8751_return = 7;
	250	else m_i8751_return = 8;
257	251	}
258	252	break;
259	253	case 2: /* Level 2, Sprite mapping tables, all sets are the same */
260		if (b < 3) state->m_i8751_return = 0;
261		else if (b < 9) state->m_i8751_return = 1;
262		else if (b < 0x11) state->m_i8751_return = 2;
263		else if (b < 0x1b) state->m_i8751_return = 3;
264		else if (b < 0x21) state->m_i8751_return = 4;
265		else if (b < 0x28) state->m_i8751_return = 5;
266		else state->m_i8751_return = 6;
	254	if (b < 3) m_i8751_return = 0;
	255	else if (b < 9) m_i8751_return = 1;
	256	else if (b < 0x11) m_i8751_return = 2;
	257	else if (b < 0x1b) m_i8751_return = 3;
	258	else if (b < 0x21) m_i8751_return = 4;
	259	else if (b < 0x28) m_i8751_return = 5;
	260	else m_i8751_return = 6;
267	261	break;
268	262	case 3: /* Level 3, Sprite mapping tables, all sets are the same */
269		if (b < 5) state->m_i8751_return = 0;
270		else if (b < 9) state->m_i8751_return = 1;
271		else if (b < 0xd) state->m_i8751_return = 2;
272		else if (b < 0x11) state->m_i8751_return = 3;
273		else if (b < 0x1b) state->m_i8751_return = 4;
274		else if (b < 0x1c) state->m_i8751_return = 5;
275		else if (b < 0x22) state->m_i8751_return = 6;
276		else if (b < 0x27) state->m_i8751_return = 7;
277		else state->m_i8751_return = 8;
	263	if (b < 5) m_i8751_return = 0;
	264	else if (b < 9) m_i8751_return = 1;
	265	else if (b < 0xd) m_i8751_return = 2;
	266	else if (b < 0x11) m_i8751_return = 3;
	267	else if (b < 0x1b) m_i8751_return = 4;
	268	else if (b < 0x1c) m_i8751_return = 5;
	269	else if (b < 0x22) m_i8751_return = 6;
	270	else if (b < 0x27) m_i8751_return = 7;
	271	else m_i8751_return = 8;
278	272	break;
279	273	case 4: /* Level 4, Sprite mapping tables, all sets are the same */
280		if (b < 4) state->m_i8751_return = 0;
281		else if (b < 0xc) state->m_i8751_return = 1;
282		else if (b < 0xf) state->m_i8751_return = 2;
283		else if (b < 0x19) state->m_i8751_return = 3;
284		else if (b < 0x1c) state->m_i8751_return = 4;
285		else if (b < 0x22) state->m_i8751_return = 5;
286		else if (b < 0x29) state->m_i8751_return = 6;
287		else state->m_i8751_return = 7;
	274	if (b < 4) m_i8751_return = 0;
	275	else if (b < 0xc) m_i8751_return = 1;
	276	else if (b < 0xf) m_i8751_return = 2;
	277	else if (b < 0x19) m_i8751_return = 3;
	278	else if (b < 0x1c) m_i8751_return = 4;
	279	else if (b < 0x22) m_i8751_return = 5;
	280	else if (b < 0x29) m_i8751_return = 6;
	281	else m_i8751_return = 7;
288	282	break;
289	283	case 5: /* Level 5, Sprite mapping tables, all sets are the same  */
290		if (b < 7) state->m_i8751_return = 0;
291		else if (b < 0xe) state->m_i8751_return = 1;
292		else if (b < 0x14) state->m_i8751_return = 2;
293		else if (b < 0x1a) state->m_i8751_return = 3;
294		else if (b < 0x23) state->m_i8751_return = 4;
295		else if (b < 0x27) state->m_i8751_return = 5;
296		else state->m_i8751_return = 6;
	284	if (b < 7) m_i8751_return = 0;
	285	else if (b < 0xe) m_i8751_return = 1;
	286	else if (b < 0x14) m_i8751_return = 2;
	287	else if (b < 0x1a) m_i8751_return = 3;
	288	else if (b < 0x23) m_i8751_return = 4;
	289	else if (b < 0x27) m_i8751_return = 5;
	290	else m_i8751_return = 6;
297	291	break;
298	292	case 6: /* Level 6, Sprite mapping tables, all sets are the same  */
299		if (b < 3) state->m_i8751_return = 0;
300		else if (b < 0xb) state->m_i8751_return = 1;
301		else if (b < 0x11) state->m_i8751_return = 2;
302		else if (b < 0x17) state->m_i8751_return = 3;
303		else if (b < 0x1d) state->m_i8751_return = 4;
304		else if (b < 0x24) state->m_i8751_return = 5;
305		else state->m_i8751_return = 6;
	293	if (b < 3) m_i8751_return = 0;
	294	else if (b < 0xb) m_i8751_return = 1;
	295	else if (b < 0x11) m_i8751_return = 2;
	296	else if (b < 0x17) m_i8751_return = 3;
	297	else if (b < 0x1d) m_i8751_return = 4;
	298	else if (b < 0x24) m_i8751_return = 5;
	299	else m_i8751_return = 6;
306	300	break;
307	301	case 7: /* Level 7, Sprite mapping tables, all sets are the same  */
308		if (b < 5) state->m_i8751_return = 0;
309		else if (b < 0xb) state->m_i8751_return = 1;
310		else if (b < 0x11) state->m_i8751_return = 2;
311		else if (b < 0x1a) state->m_i8751_return = 3;
312		else if (b < 0x21) state->m_i8751_return = 4;
313		else if (b < 0x27) state->m_i8751_return = 5;
314		else state->m_i8751_return = 6;
	302	if (b < 5) m_i8751_return = 0;
	303	else if (b < 0xb) m_i8751_return = 1;
	304	else if (b < 0x11) m_i8751_return = 2;
	305	else if (b < 0x1a) m_i8751_return = 3;
	306	else if (b < 0x21) m_i8751_return = 4;
	307	else if (b < 0x27) m_i8751_return = 5;
	308	else m_i8751_return = 6;
315	309	break;
316	310	}
317	311	}
318	312
319		//  logerror("%s - Unknown Write %02x intel\n", machine.describe_context(), data);
	313	//  logerror("%s - Unknown Write %02x intel\n", machine().describe_context(), data);
320	314
321		state->m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
322		state->m_i8751_needs_ack = 1;
	315	m_maincpu->set_input_line(6, HOLD_LINE); /* Signal main cpu task is complete */
	316	m_i8751_needs_ack = 1;
323	317	}
324	318
325	319	/*************************************
r20830	r20831
370	364
371	365	case 6: /* SECREQ (Interrupt & Data to i8751) */
372	366	if (m_microcontroller_id == KARNOV || m_microcontroller_id == KARNOVJ)
373		karnov_i8751_w(machine(), data);
	367	karnov_i8751_w(data);
374	368	if (m_microcontroller_id == CHELNOV || m_microcontroller_id == CHELNOVU || m_microcontroller_id == CHELNOVJ)
375		chelnov_i8751_w(machine(), data);
	369	chelnov_i8751_w(data);
376	370	if (m_microcontroller_id == WNDRPLNT)
377		wndrplnt_i8751_w(machine(), data);
	371	wndrplnt_i8751_w(data);
378	372	break;
379	373
380	374	case 8: /* HSHIFT (9 bits) - Top bit indicates video flip */
381	375	COMBINE_DATA(&m_scroll[0]);
382		karnov_flipscreen_w(machine(), data >> 15);
	376	karnov_flipscreen_w(data >> 15);
383	377	break;
384	378
385	379	case 0xa: /* VSHIFT */

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team