Previous

199869 Revisions

Next

r17594 Sunday 2nd September, 2012 at 19:46:02 UTC by Aaron Giles

Created new sprite device base class, which manages a bitmap and a sparse bitmap for tracking which areas got updated. This allows sprites to be rendered independently to their own bitmap and then mixed in a final step. Converted the Sega sprite device over to this new model, and moved the mixing steps out of the sprite implementations and into the driver- specific video updates where it belongs. [Aaron Giles] Added some further methods and helpers to the bitmap_t and rectangle classes. [Aaron Giles] Created a sega_16bit_common_base class which handles the common Sega palette RAM mappings and open bus reads. [Aaron Giles]

[src/emu]	emu.mak sprite.c* sprite.h*
[src/lib/util]	bitmap.h
[src/mame/drivers]	segahang.c segaorun.c segas16a.c segas16b.c segas18.c segaxbd.c segaybd.c system16.c
[src/mame/includes]	segahang.h segaorun.h segas16a.h segas16b.h segas18.h segaxbd.h segaybd.h system16.h
[src/mame/machine]	segaic16.c segaic16.h
[src/mame/video]	sega16sp.c sega16sp.h* segahang.c segaic16.c segaic16.h segaorun.c segas16a.c segas16b.c segas18.c segaxbd.c segaybd.c system16.c

trunk/src/mame/machine/segaic16.c

r17593	r17594
67	67	//  MISC HELPERS
68	68	//**************************************************************************
69	69
70		READ16_HANDLER( segaic16_open_bus_r )
	70	//-------------------------------------------------
	71	//  sega_16bit_common_base - constructor
	72	//-------------------------------------------------
	73
	74	sega_16bit_common_base::sega_16bit_common_base(const machine_config &mconfig, device_type type, const char *tag)
	75	: driver_device(mconfig, type, tag),
	76	m_paletteram(*this, "paletteram"),
	77	m_open_bus_recurse(false),
	78	m_palette_entries(0)
71	79	{
72		static UINT8 recurse = 0;
73		UINT16 result;
	80	palette_init();
	81	}
74	82
	83
	84	//-------------------------------------------------
	85	//  open_bus_r - return value from reading an
	86	//   unmapped address
	87	//-------------------------------------------------
	88
	89	READ16_MEMBER( sega_16bit_common_base::open_bus_r )
	90	{
75	91	// Unmapped memory returns the last word on the data bus, which is almost always the opcode
76	92	// of the next instruction due to prefetch; however, since we may be encrypted, we actually
77	93	// need to return the encrypted opcode, not the last decrypted data.
r17593	r17594
81	97	// return the prefetched value.
82	98
83	99	// prevent recursion
84		if (recurse)
	100	if (m_open_bus_recurse)
85	101	return 0xffff;
86	102
87	103	// read original encrypted memory at that address
88		recurse = 1;
89		result = space->read_word(cpu_get_pc(&space->device()));
90		recurse = 0;
	104	m_open_bus_recurse = true;
	105	UINT16 result = space.read_word(cpu_get_pc(&space.device()));
	106	m_open_bus_recurse = false;
91	107	return result;
92	108	}
93	109
94	110
	111	//-------------------------------------------------
	112	//  palette_init - precompute weighted RGB values
	113	//   for each input value 0-31
	114	//-------------------------------------------------
95	115
	116	void sega_16bit_common_base::palette_init()
	117	{
	118	//
	119	//   Color generation details
	120	//
	121	//   Each color is made up of 5 bits, connected through one or more resistors like so:
	122	//
	123	//   Bit 0 = 1 x 3.9K ohm
	124	//   Bit 1 = 1 x 2.0K ohm
	125	//   Bit 2 = 1 x 1.0K ohm
	126	//   Bit 3 = 2 x 1.0K ohm
	127	//   Bit 4 = 4 x 1.0K ohm
	128	//
	129	//   Another data bit is connected by a tristate buffer to the color output through a
	130	//   470 ohm resistor. The buffer allows the resistor to have no effect (tristate),
	131	//   halve brightness (pull-down) or double brightness (pull-up). The data bit source
	132	//   is bit 15 of each color RAM entry.
	133	//
	134
	135	// compute weight table for regular palette entries
	136	static const int resistances_normal[6] = { 3900, 2000, 1000, 1000/2, 1000/4, 0   };
	137	double weights_normal[6];
	138	compute_resistor_weights(0, 255, -1.0,
	139	6, resistances_normal, weights_normal, 0, 0,
	140	0, NULL, NULL, 0, 0,
	141	0, NULL, NULL, 0, 0);
	142
	143	// compute weight table for shadow/hilight palette entries
	144	static const int resistances_sh[6]     = { 3900, 2000, 1000, 1000/2, 1000/4, 470 };
	145	double weights_sh[6];
	146	compute_resistor_weights(0, 255, -1.0,
	147	6, resistances_sh, weights_sh, 0, 0,
	148	0, NULL, NULL, 0, 0,
	149	0, NULL, NULL, 0, 0);
	150
	151	// compute R, G, B for each weight
	152	for (int value = 0; value < 32; value++)
	153	{
	154	int i4 = (value >> 4) & 1;
	155	int i3 = (value >> 3) & 1;
	156	int i2 = (value >> 2) & 1;
	157	int i1 = (value >> 1) & 1;
	158	int i0 = (value >> 0) & 1;
	159	m_palette_normal[value] = combine_6_weights(weights_normal, i0, i1, i2, i3, i4, 0);
	160	m_palette_shadow[value] = combine_6_weights(weights_sh, i0, i1, i2, i3, i4, 0);
	161	m_palette_hilight[value] = combine_6_weights(weights_sh, i0, i1, i2, i3, i4, 1);
	162	}
	163	}
	164
	165
	166	//-------------------------------------------------
	167	//  paletteram_w - handle writes to palette RAM
	168	//-------------------------------------------------
	169
	170	WRITE16_MEMBER( sega_16bit_common_base::paletteram_w )
	171	{
	172	// compute the number of entries
	173	if (m_palette_entries == 0)
	174	m_palette_entries = memshare("paletteram")->bytes() / 2;
	175
	176	// get the new value
	177	UINT16 newval = m_paletteram[offset];
	178	COMBINE_DATA(&newval);
	179	m_paletteram[offset] = newval;
	180
	181	//     byte 0    byte 1
	182	//  sBGR BBBB GGGG RRRR
	183	//  x000 4321 4321 4321
	184	int r = ((newval >> 12) & 0x01) | ((newval << 1) & 0x1e);
	185	int g = ((newval >> 13) & 0x01) | ((newval >> 3) & 0x1e);
	186	int b = ((newval >> 14) & 0x01) | ((newval >> 7) & 0x1e);
	187
	188	// normal colors
	189	palette_set_color_rgb(machine(), offset + 0 * m_palette_entries, m_palette_normal[r],  m_palette_normal[g],  m_palette_normal[b]);
	190	palette_set_color_rgb(machine(), offset + 1 * m_palette_entries, m_palette_shadow[r],  m_palette_shadow[g],  m_palette_shadow[b]);
	191	palette_set_color_rgb(machine(), offset + 2 * m_palette_entries, m_palette_hilight[r], m_palette_hilight[g], m_palette_hilight[b]);
	192	}
	193
	194
	195
96	196	//**************************************************************************
97	197	//  315-5195 MEMORY MAPPER
98	198	//**************************************************************************
r17593	r17594
273	373	logerror("Unknown memory_mapper_r from address %02X\n", offset);
274	374	break;
275	375	}
276		return (space.data_width() == 8) ? 0xff : segaic16_open_bus_r(&space, 0, 0xffff);
	376	return (space.data_width() == 8) ? 0xff : machine().driver_data<sega_16bit_common_base>()->open_bus_r(space, 0, 0xffff);
277	377	}
278	378
279	379

trunk/src/mame/machine/segaic16.h

r17593	r17594
80	80	//**************************************************************************
81	81
82	82
	83	// ======================> sega_16bit_common_base
	84
	85	class sega_16bit_common_base : public driver_device
	86	{
	87	public:
	88	// construction/destruction
	89	sega_16bit_common_base(const machine_config &mconfig, device_type type, const char *tag);
	90
	91	// open bus read helpers
	92	DECLARE_READ16_MEMBER( open_bus_r );
	93
	94	// palette helpers
	95	DECLARE_WRITE16_MEMBER( paletteram_w );
	96
	97	protected:
	98	// internal helpers
	99	void palette_init();
	100
	101	public: // -- stupid system16.c
	102	// memory pointers
	103	required_shared_ptr<UINT16> m_paletteram;
	104	protected:
	105
	106	// internal state
	107	bool      m_open_bus_recurse;         // flag to track recursion through open_bus_r
	108	UINT32      m_palette_entries;         // number of palette entries
	109	UINT8      m_palette_normal[32];      // RGB translations for normal pixels
	110	UINT8      m_palette_shadow[32];      // RGB translations for shadowed pixels
	111	UINT8      m_palette_hilight[32];      // RGB translations for hilighted pixels
	112	};
	113
	114
83	115	// ======================> sega_315_5195_mapper_device
84	116
85	117	class sega_315_5195_mapper_device : public device_t
r17593	r17594
272	304	extern const device_type SEGA_315_5250_COMPARE_TIMER;
273	305
274	306
275
276		/* open bus read helpers */
277		READ16_HANDLER( segaic16_open_bus_r );
278
279
280	307	#endif

trunk/src/mame/video/segaxbd.c

r17593	r17594
45	45
46	46	void segaxbd_state::video_start()
47	47	{
48		// compute palette info
49		segaic16_palette_init(0x2000);
50
51	48	// initialize the tile/text layers
52	49	segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16B, 0x1c00, 0, 2);
53	50
r17593	r17594
70	67	return 0;
71	68	}
72	69
	70	// start the sprites drawing
	71	m_sprites->draw_async(cliprect);
	72
73	73	// reset priorities
74	74	machine().priority_bitmap.fill(0, cliprect);
75	75
r17593	r17594
94	94	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
95	95	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
96	96
97		// draw the sprites
98		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	97	// mix in sprites
	98	bitmap_ind16 &sprites = m_sprites->bitmap();
	99	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	100	for (int y = rect->min_y; y <= rect->max_y; y++)
	101	{
	102	UINT16 *dest = &bitmap.pix(y);
	103	UINT16 *src = &sprites.pix(y);
	104	UINT8 *pri = &machine().priority_bitmap.pix(y);
	105	for (int x = rect->min_x; x <= rect->max_x; x++)
	106	{
	107	// only process written pixels
	108	UINT16 pix = src[x];
	109	if (pix != 0xffff)
	110	{
	111	// compare sprite priority against tilemap priority
	112	int priority = (pix >> 12) & 3;
	113	if ((1 << priority) > pri[x])
	114	{
	115	// if the shadow flag is set, this triggers shadow/hilight for pen 0xa
	116	if ((pix & 0x400f) == 0x400a)
	117	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	118
	119	// otherwise, just add in sprite palette base
	120	else
	121	dest[x] = pix & 0xfff;
	122	}
	123	}
	124	}
	125	}
	126
99	127	return 0;
100	128	}

trunk/src/mame/video/segaybd.c

r17593	r17594
45	45
46	46	void segaybd_state::video_start()
47	47	{
48		// compute palette info
49		segaic16_palette_init(0x2000);
50
51	48	// initialize the rotation layer
52	49	segaic16_rotate_init(machine(), 0, SEGAIC16_ROTATE_YBOARD, 0x000);
53	50	}
r17593	r17594
67	64	return 0;
68	65	}
69	66
70		// draw the yboard sprites
	67	// start the sprites drawing
71	68	rectangle yboard_clip(0, 511, 0, 511);
72		segaic16_sprites_draw(screen, m_tmp_bitmap, yboard_clip, 1);
	69	m_ysprites->bitmap().fill(0xffff);
	70	m_ysprites->draw_async(yboard_clip);
	71	m_bsprites->draw_async(cliprect);
73	72
74	73	// apply rotation
75		segaic16_rotate_draw(machine(), 0, bitmap, cliprect, &m_tmp_bitmap);
	74	segaic16_rotate_draw(machine(), 0, bitmap, cliprect, m_ysprites->bitmap());
76	75
77		// draw the 16B sprites
78		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	76	// mix in 16B sprites
	77	bitmap_ind16 &sprites = m_bsprites->bitmap();
	78	for (const sparse_dirty_rect *rect = m_bsprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	79	for (int y = rect->min_y; y <= rect->max_y; y++)
	80	{
	81	UINT16 *dest = &bitmap.pix(y);
	82	UINT16 *src = &sprites.pix(y);
	83	UINT8 *pri = &machine().priority_bitmap.pix(y);
	84	for (int x = rect->min_x; x <= rect->max_x; x++)
	85	{
	86	// only process written pixels
	87	UINT16 pix = src[x];
	88	if (pix != 0xffff)
	89	{
	90	// compare sprite priority against tilemap priority
	91	int priority = (pix >> 11) & 0x1e;
	92	if (priority < pri[x])
	93	{
	94	// if the color is set to maximum, shadow pixels underneath us
	95	if ((pix & 0xf) == 0xe)
	96	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	97
	98	// otherwise, just add in sprite palette base
	99	else
	100	dest[x] = 2048 + (pix & 0x3ff);
	101	}
	102	}
	103	}
	104	}
	105
79	106	return 0;
80	107	}

trunk/src/mame/video/segaorun.c

r17593	r17594
46	46
47	47	void segaorun_state::video_start()
48	48	{
49		// compute palette info
50		segaic16_palette_init(0x1000);
51
52	49	if (m_shangon_video)
53	50	{
54	51	// initialize the tile/text layers
r17593	r17594
75	72
76	73	UINT32 segaorun_state::screen_update_shangon(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
77	74	{
	75	// start the sprites drawing
	76	m_sprites->draw_async(cliprect);
	77
78	78	// reset priorities
79	79	machine().priority_bitmap.fill(0, cliprect);
80	80
r17593	r17594
98	98	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08);
99	99	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
100	100
101		// draw the sprites
102		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	101	// mix in sprites
	102	bitmap_ind16 &sprites = m_sprites->bitmap();
	103	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	104	for (int y = rect->min_y; y <= rect->max_y; y++)
	105	{
	106	UINT16 *dest = &bitmap.pix(y);
	107	UINT16 *src = &sprites.pix(y);
	108	UINT8 *pri = &machine().priority_bitmap.pix(y);
	109	for (int x = rect->min_x; x <= rect->max_x; x++)
	110	{
	111	// only process written pixels
	112	UINT16 pix = src[x];
	113	if (pix != 0xffff)
	114	{
	115	// compare sprite priority against tilemap priority
	116	int priority = (pix >> 10) & 3;
	117	if ((1 << priority) > pri[x])
	118	{
	119	// if the color is set to maximum, shadow pixels underneath us
	120	if ((pix & 0x03f0) == 0x03f0)
	121	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	122
	123	// otherwise, just add in sprite palette base
	124	else
	125	dest[x] = 1024 + (pix & 0x3ff);
	126	}
	127	}
	128	}
	129	}
	130
103	131	return 0;
104	132	}
105	133
r17593	r17594
113	141	return 0;
114	142	}
115	143
	144	// start the sprites drawing
	145	m_sprites->draw_async(cliprect);
	146
116	147	// reset priorities
117	148	machine().priority_bitmap.fill(0, cliprect);
118	149
r17593	r17594
134	165	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
135	166	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
136	167
137		// draw the sprites
138		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	168	// mix in sprites
	169	bitmap_ind16 &sprites = m_sprites->bitmap();
	170	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	171	for (int y = rect->min_y; y <= rect->max_y; y++)
	172	{
	173	UINT16 *dest = &bitmap.pix(y);
	174	UINT16 *src = &sprites.pix(y);
	175	UINT8 *pri = &machine().priority_bitmap.pix(y);
	176	for (int x = rect->min_x; x <= rect->max_x; x++)
	177	{
	178	// only process written pixels
	179	UINT16 pix = src[x];
	180	if (pix != 0xffff)
	181	{
	182	// compare sprite priority against tilemap priority
	183	int priority = (pix >> 12) & 3;
	184	if ((1 << priority) > pri[x])
	185	{
	186	// if the shadow flag is set, this triggers shadow/hilight for pen 0xa
	187	if ((pix & 0x400f) == 0x400a)
	188	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	189
	190	// otherwise, just add in sprite palette base
	191	else
	192	dest[x] = 2048 + (pix & 0x7ff);
	193	}
	194	}
	195	}
	196	}
	197
139	198	return 0;
140	199	}

trunk/src/mame/video/system16.c

r17593	r17594
39	39	static const UINT8 default_banklist[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
40	40	int i;
41	41	for (i = 0; i < 16; i++)
42		segaic16_sprites_set_bank(machine, 0, i, default_banklist[i]);
	42	state->m_sprites->set_bank(i, default_banklist[i]);
43	43	}
44	44	else
45	45	{
46	46	static const UINT8 alternate_banklist[] = { 0,255,255,255, 255,255,255,3, 255,255,255,2, 255,1,0,255 };
47	47	int i;
48	48	for (i = 0; i < 16; i++)
49		segaic16_sprites_set_bank(machine, 0, i, alternate_banklist[i]);
	49	state->m_sprites->set_bank(i, alternate_banklist[i]);
50	50
51	51	}
52	52
r17593	r17594
431	431	state->m_system18 = 0;
432	432	}
433	433
434		segaic16_palette_init(0x800);
435	434	setup_system16_bootleg_spritebanking(machine);
436
437
438	435	}
439	436
440	437	VIDEO_START( system18old )
r17593	r17594
597	594	state->m_text_tilemap->set_transparent_pen(0);
598	595	state->m_bg_tilemaps[0]->set_transparent_pen(0);
599	596	state->m_bg_tilemaps[1]->set_transparent_pen(0);
600
601		segaic16_palette_init(0x800);
602
603	597	}
604	598
605	599	VIDEO_START( s16a_bootleg_wb3bl )
r17593	r17594
635	629
636	630	bitmap.fill(get_black_pen(screen.machine()), cliprect);
637	631
	632	// start the sprites drawing
	633	state->m_sprites->draw_async(cliprect);
	634
638	635	// I can't bring myself to care about dirty tile marking on something which runs at a bazillion % speed anyway, clean code is better
639	636	state->m_bg_tilemaps[0]->mark_all_dirty();
640	637	state->m_bg_tilemaps[1]->mark_all_dirty();
r17593	r17594
672	669	state->m_text_tilemap->draw(bitmap, cliprect, 0, 0);
673	670	}
674	671
675		/* draw the sprites */
676		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	672	// mix in sprites
	673	bitmap_ind16 &sprites = state->m_sprites->bitmap();
	674	for (const sparse_dirty_rect *rect = state->m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	675	for (int y = rect->min_y; y <= rect->max_y; y++)
	676	{
	677	UINT16 *dest = &bitmap.pix(y);
	678	UINT16 *src = &sprites.pix(y);
	679	//         UINT8 *pri = &screen.machine().priority_bitmap.pix(y);
	680	for (int x = rect->min_x; x <= rect->max_x; x++)
	681	{
	682	// only process written pixels
	683	UINT16 pix = src[x];
	684	if (pix != 0xffff)
	685	{
	686	// compare sprite priority against tilemap priority
	687	//               int priority = (pix >> 12) & 3;
	688	if (1)
	689	{
	690	// if the color is set to maximum, shadow pixels underneath us
	691	if ((pix & 0x03f0) == 0x03f0)
	692	dest[x] += (state->m_paletteram[dest[x]] & 0x8000) ? screen.machine().total_colors()*2 : screen.machine().total_colors();
677	693
	694	// otherwise, just add in sprite palette base
	695	else
	696	dest[x] = 1024 + (pix & 0x3ff);
	697	}
	698	}
	699	}
	700	}
	701
	702
678	703	return 0;
679	704	}
680	705
r17593	r17594
693	718
694	719	bitmap.fill(get_black_pen(screen.machine()), cliprect);
695	720
	721	// start the sprites drawing
	722	state->m_sprites->draw_async(cliprect);
	723
696	724	// I can't bring myself to care about dirty tile marking on something which runs at a bazillion % speed anyway, clean code is better
697	725	state->m_bg_tilemaps[0]->mark_all_dirty();
698	726	state->m_bg_tilemaps[1]->mark_all_dirty();
r17593	r17594
713	741	state->m_text_tilemap->draw(bitmap, cliprect, 0, 0);
714	742	}
715	743
716		/* draw the sprites */
717		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	744	// mix in sprites
	745	bitmap_ind16 &sprites = state->m_sprites->bitmap();
	746	for (const sparse_dirty_rect *rect = state->m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	747	for (int y = rect->min_y; y <= rect->max_y; y++)
	748	{
	749	UINT16 *dest = &bitmap.pix(y);
	750	UINT16 *src = &sprites.pix(y);
	751	//         UINT8 *pri = &screen.machine().priority_bitmap.pix(y);
	752	for (int x = rect->min_x; x <= rect->max_x; x++)
	753	{
	754	// only process written pixels
	755	UINT16 pix = src[x];
	756	if (pix != 0xffff)
	757	{
	758	// compare sprite priority against tilemap priority
	759	//               int priority = (pix >> 12) & 3;
	760	if (1)
	761	{
	762	// if the color is set to maximum, shadow pixels underneath us
	763	if ((pix & 0x03f0) == 0x03f0)
	764	dest[x] += (state->m_paletteram[dest[x]] & 0x8000) ? screen.machine().total_colors()*2 : screen.machine().total_colors();
718	765
	766	// otherwise, just add in sprite palette base
	767	else
	768	dest[x] = 1024 + (pix & 0x3ff);
	769	}
	770	}
	771	}
	772	}
	773
	774
719	775	return 0;
720	776	}
721	777
r17593	r17594
732	788	return 0;
733	789	}
734	790
	791	// start the sprites drawing
	792	state->m_sprites->draw_async(cliprect);
	793
735	794	update_page(screen.machine());
736	795
737	796	screen.machine().priority_bitmap.fill(0, cliprect);
r17593	r17594
762	821
763	822	//draw_sprites(screen.machine(), bitmap, cliprect,0);
764	823
765		/* draw the sprites */
766		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	824
	825	// mix in sprites
	826	bitmap_ind16 &sprites = state->m_sprites->bitmap();
	827	for (const sparse_dirty_rect *rect = state->m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	828	for (int y = rect->min_y; y <= rect->max_y; y++)
	829	{
	830	UINT16 *dest = &bitmap.pix(y);
	831	UINT16 *src = &sprites.pix(y);
	832	//         UINT8 *pri = &screen.machine().priority_bitmap.pix(y);
	833	for (int x = rect->min_x; x <= rect->max_x; x++)
	834	{
	835	// only process written pixels
	836	UINT16 pix = src[x];
	837	if (pix != 0xffff)
	838	{
	839	// compare sprite priority against tilemap priority
	840	//               int priority = (pix >> 12) & 3;
	841	if (1)
	842	{
	843	// if the color is set to maximum, shadow pixels underneath us
	844	if ((pix & 0x03f0) == 0x03f0)
	845	dest[x] += (state->m_paletteram[dest[x]] & 0x8000) ? screen.machine().total_colors()*2 : screen.machine().total_colors();
	846
	847	// otherwise, just add in sprite palette base
	848	else
	849	dest[x] = 1024 + (pix & 0x3ff);
	850	}
	851	}
	852	}
	853	}
	854
767	855	return 0;
768	856	}
769	857
r17593	r17594
778	866	return 0;
779	867	}
780	868
	869	// start the sprites drawing
	870	state->m_sprites->draw_async(cliprect);
	871
781	872	update_page(screen.machine());
782	873
783	874	screen.machine().priority_bitmap.fill(0);
r17593	r17594
796	887	state->m_text_layer->draw(bitmap, cliprect, 1, 0x7);
797	888	state->m_text_layer->draw(bitmap, cliprect, 0, 0xf);
798	889
799		/* draw the sprites */
800		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	890	// mix in sprites
	891	bitmap_ind16 &sprites = state->m_sprites->bitmap();
	892	for (const sparse_dirty_rect *rect = state->m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	893	for (int y = rect->min_y; y <= rect->max_y; y++)
	894	{
	895	UINT16 *dest = &bitmap.pix(y);
	896	UINT16 *src = &sprites.pix(y);
	897	//         UINT8 *pri = &screen.machine().priority_bitmap.pix(y);
	898	for (int x = rect->min_x; x <= rect->max_x; x++)
	899	{
	900	// only process written pixels
	901	UINT16 pix = src[x];
	902	if (pix != 0xffff)
	903	{
	904	// compare sprite priority against tilemap priority
	905	//               int priority = (pix >> 12) & 3;
	906	if (1)
	907	{
	908	// if the color is set to maximum, shadow pixels underneath us
	909	if ((pix & 0x03f0) == 0x03f0)
	910	dest[x] += (state->m_paletteram[dest[x]] & 0x8000) ? screen.machine().total_colors()*2 : screen.machine().total_colors();
801	911
	912	// otherwise, just add in sprite palette base
	913	else
	914	dest[x] = 1024 + (pix & 0x3ff);
	915	}
	916	}
	917	}
	918	}
	919
802	920	return 0;
803	921	}

trunk/src/mame/video/segaic16.c

r17593	r17594
380	380	UINT16 *segaic16_textram_0;
381	381	UINT16 *segaic16_roadram_0;
382	382	UINT16 *segaic16_rotateram_0;
383		UINT16 *segaic16_paletteram;
384	383
385		struct palette_info segaic16_palette;
386	384	struct rotate_info segaic16_rotate[SEGAIC16_MAX_ROTATE];
387	385	struct road_info segaic16_road[SEGAIC16_MAX_ROADS];
388	386
r17593	r17594
418	416
419	417	/*************************************
420	418	*
421		*  Palette computation
422		*
423		*************************************/
424
425		/*
426		Color generation details
427
428		Each color is made up of 5 bits, connected through one or more resistors like so:
429
430		Bit 0 = 1 x 3.9K ohm
431		Bit 1 = 1 x 2.0K ohm
432		Bit 2 = 1 x 1.0K ohm
433		Bit 3 = 2 x 1.0K ohm
434		Bit 4 = 4 x 1.0K ohm
435
436		Another data bit is connected by a tristate buffer to the color output through a
437		470 ohm resistor. The buffer allows the resistor to have no effect (tristate),
438		halve brightness (pull-down) or double brightness (pull-up). The data bit source
439		is bit 15 of each color RAM entry.
440		*/
441
442		void segaic16_palette_init(int entries)
443		{
444		static const int resistances_normal[6] = { 3900, 2000, 1000, 1000/2, 1000/4, 0   };
445		static const int resistances_sh[6]     = { 3900, 2000, 1000, 1000/2, 1000/4, 470 };
446		double weights[2][6];
447		int i;
448		struct palette_info *info = &segaic16_palette;
449
450		/* compute the number of palette entries */
451		info->entries = entries;
452
453		/* compute weight table for regular palette entries */
454		compute_resistor_weights(0, 255, -1.0,
455		6, resistances_normal, weights[0], 0, 0,
456		0, NULL, NULL, 0, 0,
457		0, NULL, NULL, 0, 0);
458
459		/* compute weight table for shadow/hilight palette entries */
460		compute_resistor_weights(0, 255, -1.0,
461		6, resistances_sh, weights[1], 0, 0,
462		0, NULL, NULL, 0, 0,
463		0, NULL, NULL, 0, 0);
464
465		/* compute R, G, B for each weight */
466		for (i = 0; i < 32; i++)
467		{
468		int i4 = (i >> 4) & 1;
469		int i3 = (i >> 3) & 1;
470		int i2 = (i >> 2) & 1;
471		int i1 = (i >> 1) & 1;
472		int i0 = (i >> 0) & 1;
473
474		info->normal[i] = combine_6_weights(weights[0], i0, i1, i2, i3, i4, 0);
475		info->shadow[i] = combine_6_weights(weights[1], i0, i1, i2, i3, i4, 0);
476		info->hilight[i] = combine_6_weights(weights[1], i0, i1, i2, i3, i4, 1);
477		}
478		}
479
480
481
482		/*************************************
483		*
484		*  Palette accessors
485		*
486		*************************************/
487
488		WRITE16_HANDLER( segaic16_paletteram_w )
489		{
490		UINT16 newval;
491		int r, g, b;
492		struct palette_info *info = &segaic16_palette;
493
494		/* get the new value */
495		newval = segaic16_paletteram[offset];
496		COMBINE_DATA(&newval);
497		segaic16_paletteram[offset] = newval;
498
499		/*     byte 0    byte 1 */
500		/*  sBGR BBBB GGGG RRRR */
501		/*  x000 4321 4321 4321 */
502		r = ((newval >> 12) & 0x01) | ((newval << 1) & 0x1e);
503		g = ((newval >> 13) & 0x01) | ((newval >> 3) & 0x1e);
504		b = ((newval >> 14) & 0x01) | ((newval >> 7) & 0x1e);
505
506		/* normal colors */
507		palette_set_color_rgb(space->machine(), offset + 0 * info->entries, info->normal[r],  info->normal[g],  info->normal[b]);
508		palette_set_color_rgb(space->machine(), offset + 1 * info->entries, info->shadow[r],  info->shadow[g],  info->shadow[b]);
509		palette_set_color_rgb(space->machine(), offset + 2 * info->entries, info->hilight[r], info->hilight[g], info->hilight[b]);
510		}
511
512
513
514		/*************************************
515		*
516	419	*  Draw a split tilemap in up to
517	420	*  four pieces
518	421	*
r17593	r17594
2029	1932	*
2030	1933	*************************************/
2031	1934
2032		void segaic16_rotate_draw(running_machine &machine, int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind16 *srcbitmap)
	1935	void segaic16_rotate_draw(running_machine &machine, int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind16 &srcbitmap)
2033	1936	{
2034	1937	struct rotate_info *info = &segaic16_rotate[which];
2035	1938	INT32 currx = (info->buffer[0x3f0] << 16) | info->buffer[0x3f1];
r17593	r17594
2048	1951	for (y = cliprect.min_y; y <= cliprect.max_y; y++)
2049	1952	{
2050	1953	UINT16 *dest = &bitmap.pix16(y);
2051		UINT16 *src = &srcbitmap->pix16(0);
	1954	UINT16 *src = &srcbitmap.pix16(0);
2052	1955	UINT8 *pri = &machine.priority_bitmap.pix8(y);
2053	1956	INT32 tx = currx;
2054	1957	INT32 ty = curry;
r17593	r17594
2059	1962	/* fetch the pixel from the source bitmap */
2060	1963	int sx = (tx >> 14) & 0x1ff;
2061	1964	int sy = (ty >> 14) & 0x1ff;
2062		int pix = src[sy * srcbitmap->rowpixels() + sx];
	1965	int pix = src[sy * srcbitmap.rowpixels() + sx];
2063	1966
2064	1967	/* non-zero pixels get written; everything else is the scanline color */
2065	1968	if (pix != 0xffff)
r17593	r17594
2113	2016
2114	2017	return 0xffff;
2115	2018	}
2116
2117
2118		DEFINE_LEGACY_DEVICE(SEGA16SP, sega16sp);

trunk/src/mame/video/segaic16.h

r17593	r17594
10	10	extern UINT8 segaic16_display_enable;
11	11	extern UINT16 *segaic16_tileram_0;
12	12	extern UINT16 *segaic16_textram_0;
13		extern UINT16 *segaic16_spriteram_0;
14		extern UINT16 *segaic16_spriteram_1;
15	13	extern UINT16 *segaic16_roadram_0;
16	14	extern UINT16 *segaic16_rotateram_0;
17		extern UINT16 *segaic16_paletteram;
18	15
19	16	/* misc functions */
20	17	void segaic16_set_display_enable(running_machine &machine, int enable);
21	18
22		/* palette handling */
23		void segaic16_palette_init(int entries);
24		WRITE16_HANDLER( segaic16_paletteram_w );
25
26	19	/* tilemap systems */
27	20	#define SEGAIC16_MAX_TILEMAPS      1
28	21
r17593	r17594
46	39	WRITE16_HANDLER( segaic16_tileram_0_w );
47	40	WRITE16_HANDLER( segaic16_textram_0_w );
48	41
49		/* sprite systems */
50		#define SEGAIC16_MAX_SPRITES      2
51
52		#define SEGAIC16_SPRITES_OUTRUN      4
53		#define SEGAIC16_SPRITES_XBOARD      5
54
55		void segaic16_sprites_draw(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int which);
56		void segaic16_sprites_set_bank(running_machine &machine, int which, int banknum, int offset);
57		void segaic16_sprites_set_flip(running_machine &machine, int which, int flip);
58		void segaic16_sprites_set_shadow(running_machine &machine, int which, int shadow);
59		WRITE16_HANDLER( segaic16_sprites_draw_0_w );
60		WRITE16_HANDLER( segaic16_sprites_draw_1_w );
61
62	42	/* road systems */
63	43	#define SEGAIC16_MAX_ROADS         1
64	44
r17593	r17594
81	61	#define SEGAIC16_ROTATE_YBOARD      0
82	62
83	63	void segaic16_rotate_init(running_machine &machine, int which, int type, int colorbase);
84		void segaic16_rotate_draw(running_machine &machine, int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind16 *srcbitmap);
	64	void segaic16_rotate_draw(running_machine &machine, int which, bitmap_ind16 &bitmap, const rectangle &cliprect, bitmap_ind16 &srcbitmap);
85	65	READ16_HANDLER( segaic16_rotate_control_0_r );
86	66
87	67	/*************************************
r17593	r17594
139	119	UINT8 *         gfx;                     /* expanded road graphics */
140	120	};
141	121
142		struct palette_info
143		{
144		INT32         entries;                  /* number of entries (not counting shadows) */
145		UINT8         normal[32];                  /* RGB translations for normal pixels */
146		UINT8         shadow[32];                  /* RGB translations for shadowed pixels */
147		UINT8         hilight[32];               /* RGB translations for hilighted pixels */
148		};
149
150	122	struct rotate_info
151	123	{
152	124	UINT8         index;                     /* index of this structure */
r17593	r17594
157	129	UINT16 *      buffer;                     /* buffered data */
158	130	};
159	131
160		/* interface */
161		typedef struct _sega16sp_interface sega16sp_interface;
162		struct _sega16sp_interface
163		{
164		UINT8         which;                     /* which sprite RAM */
165		UINT16         colorbase;                  /* base color index */
166		INT32         ramsize;                  /* size of sprite RAM */
167		INT32         xoffs;                     /* X scroll offset */
168		void         (*draw)(running_machine &machine, device_t* device, bitmap_ind16 &bitmap, const rectangle &cliprect);
169		int            buffer;                     /* should ram be buffered? */
170		};
171	132
172
173
174
175		/* state */
176		typedef struct _sega16sp_state sega16sp_state;
177		struct _sega16sp_state
178		{
179		UINT8         which;                     /* which sprite RAM */
180		UINT8         flip;                     /* screen flip? */
181		UINT8         shadow;                     /* shadow or hilight? */
182		UINT8         bank[16];                  /* banking redirection */
183		UINT16         colorbase;                  /* base color index */
184		INT32         ramsize;                  /* size of sprite RAM */
185		INT32         xoffs;                     /* X scroll offset */
186		void         (*draw)(running_machine &machine, device_t* device, bitmap_ind16 &bitmap, const rectangle &cliprect);
187		UINT16 *      spriteram;                  /* pointer to spriteram pointer */
188		UINT16 *      buffer;                     /* buffered spriteram for those that use it */
189
190		};
191
192	133	/***************************************************************************
193	134	FUNCTION PROTOTYPES
194	135	***************************************************************************/
195	136
196		DECLARE_LEGACY_DEVICE(SEGA16SP, sega16sp);
197
198		void segaic16_sprites_hangon_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
199		void segaic16_sprites_sharrier_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
200		void segaic16_sprites_16a_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
201		void segaic16_sprites_16b_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
202		void segaic16_sprites_yboard_16b_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
203		void segaic16_sprites_yboard_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
204		void segaic16_sprites_outrun_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
205		void segaic16_sprites_xboard_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
206		void segaic16_sprites_16a_bootleg_wb3bl_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
207		void segaic16_sprites_16a_bootleg_passhtb_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
208		void segaic16_sprites_16a_bootleg_shinobld_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect);
209
210		/* the various sprite configs */
211		static const sega16sp_interface hangon_sega16sp_intf =
212		{
213		0,      // which spriteram
214		1024,  // colorbase
215		0x800, // ramsize
216		0,     // xoffs
217		segaic16_sprites_hangon_draw, // draw function
218		0, // use buffer
219		};
220
221		static const sega16sp_interface sharrier_sega16sp_intf =
222		{
223		0,      // which spriteram
224		1024,  // colorbase
225		0x1000, // ramsize
226		0,     // xoffs
227		segaic16_sprites_sharrier_draw, // draw function
228		0, // use buffer
229		};
230
231		static const sega16sp_interface yboard_16b_sega16sp_intf =
232		{
233		0,      // which spriteram
234		2048,  // colorbase
235		0x800, // ramsize
236		0,     // xoffs
237		segaic16_sprites_yboard_16b_draw, // draw function
238		0, // use buffer
239		};
240
241		static const sega16sp_interface yboard_sega16sp_intf =
242		{
243		1,      // which spriteram
244		4096,  // colorbase
245		0x10000, // ramsize
246		0,     // xoffs
247		segaic16_sprites_yboard_draw, // draw function
248		0, // use buffer
249		};
250
251		static const sega16sp_interface s16a_sega16sp_intf =
252		{
253		0,      // which spriteram
254		1024,  // colorbase
255		0x800, // ramsize
256		0,     // xoffs
257		segaic16_sprites_16a_draw, // draw function
258		0, // use buffer
259		};
260
261		static const sega16sp_interface s16b_sega16sp_intf =
262		{
263		0,      // which spriteram
264		1024,  // colorbase
265		0x800, // ramsize
266		0,     // xoffs
267		segaic16_sprites_16b_draw, // draw function
268		0, // use buffer
269		};
270
271		static const sega16sp_interface outrun_sega16sp_intf =
272		{
273		0,      // which spriteram
274		2048,  // colorbase
275		0x1000, // ramsize
276		0,     // xoffs
277		segaic16_sprites_outrun_draw, // draw function
278		1, // use buffer
279		};
280
281
282		static const sega16sp_interface xboard_sega16sp_intf =
283		{
284		0,      // which spriteram
285		0,  // colorbase
286		0x1000, // ramsize
287		0,     // xoffs
288		segaic16_sprites_xboard_draw, // draw function
289		1, // use buffer
290		};
291
292
293
294		#define MCFG_SEGA16SP_ADD(_tag, _interface) \
295		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
296		MCFG_DEVICE_CONFIG(_interface)
297
298		#define MCFG_SEGA16SP_ADD_HANGON(_tag) \
299		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
300		MCFG_DEVICE_CONFIG(hangon_sega16sp_intf)
301
302		#define MCFG_SEGA16SP_ADD_SHARRIER(_tag) \
303		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
304		MCFG_DEVICE_CONFIG(sharrier_sega16sp_intf)
305
306		#define MCFG_SEGA16SP_ADD_YBOARD(_tag) \
307		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
308		MCFG_DEVICE_CONFIG(yboard_sega16sp_intf)
309
310		#define MCFG_SEGA16SP_ADD_YBOARD_16B(_tag) \
311		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
312		MCFG_DEVICE_CONFIG(yboard_16b_sega16sp_intf)
313
314		#define MCFG_SEGA16SP_ADD_16A(_tag) \
315		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
316		MCFG_DEVICE_CONFIG(s16a_sega16sp_intf)
317
318		#define MCFG_SEGA16SP_ADD_16B(_tag) \
319		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
320		MCFG_DEVICE_CONFIG(s16b_sega16sp_intf)
321
322		#define MCFG_SEGA16SP_ADD_OUTRUN(_tag) \
323		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
324		MCFG_DEVICE_CONFIG(outrun_sega16sp_intf)
325
326		#define MCFG_SEGA16SP_ADD_XBOARD(_tag) \
327		MCFG_DEVICE_ADD(_tag, SEGA16SP, 0) \
328		MCFG_DEVICE_CONFIG(xboard_sega16sp_intf)
329
330
331		extern struct palette_info segaic16_palette;
332	137	extern struct rotate_info segaic16_rotate[SEGAIC16_MAX_ROTATE];
333	138	extern struct road_info segaic16_road[SEGAIC16_MAX_ROADS];
334	139

trunk/src/mame/video/sega16sp.c

r17593	r17594
	1	/***************************************************************************
	2
	3	Sega 16-bit sprite hardware
	4
	5	****************************************************************************
	6
	7	Copyright Aaron Giles
	8	All rights reserved.
	9
	10	Redistribution and use in source and binary forms, with or without
	11	modification, are permitted provided that the following conditions are
	12	met:
	13
	14	* Redistributions of source code must retain the above copyright
	15	notice, this list of conditions and the following disclaimer.
	16	* Redistributions in binary form must reproduce the above copyright
	17	notice, this list of conditions and the following disclaimer in
	18	the documentation and/or other materials provided with the
	19	distribution.
	20	* Neither the name 'MAME' nor the names of its contributors may be
	21	used to endorse or promote products derived from this software
	22	without specific prior written permission.
	23
	24	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	25	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	26	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	27	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	28	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	29	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	30	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	32	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	33	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	POSSIBILITY OF SUCH DAMAGE.
	35
	36	***************************************************************************/
	37
1	38	#include "emu.h"
	39	#include "sega16sp.h"
2	40	#include "segaic16.h"
3	41
4	42
5		UINT16 *segaic16_spriteram_0;
6		UINT16 *segaic16_spriteram_1;
7	43
	44	//****************************************************************************
	45	//  CONSTANTS
	46	//****************************************************************************
8	47
	48	// device type definition
	49	const device_type SEGA_HANGON_SPRITES = &device_creator<sega_hangon_sprite_device>;
	50	const device_type SEGA_SHARRIER_SPRITES = &device_creator<sega_sharrier_sprite_device>;
	51	const device_type SEGA_OUTRUN_SPRITES = &device_creator<sega_outrun_sprite_device>;
	52	const device_type SEGA_SYS16A_SPRITES = &device_creator<sega_sys16a_sprite_device>;
	53	const device_type BOOTLEG_SYS16A_SPRITES = &device_creator<bootleg_sys16a_sprite_device>;
	54	const device_type SEGA_SYS16B_SPRITES = &device_creator<sega_sys16b_sprite_device>;
	55	const device_type SEGA_XBOARD_SPRITES = &device_creator<sega_xboard_sprite_device>;
	56	const device_type SEGA_YBOARD_SPRITES = &device_creator<sega_yboard_sprite_device>;
9	57
10	58
11		/*****************************************************************************
12		INLINE FUNCTIONS
13		*****************************************************************************/
14	59
15		INLINE sega16sp_state *get_safe_token( device_t *device )
	60	//****************************************************************************
	61	//  DEVICE INTERFACE
	62	//****************************************************************************
	63
	64	//-------------------------------------------------
	65	//  sega_16bit_sprite_device -- core constructor
	66	//-------------------------------------------------
	67
	68	sega_16bit_sprite_device::sega_16bit_sprite_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner)
	69	: sprite16_device_ind16(mconfig, type, name, tag, owner),
	70	m_flip(false)
16	71	{
17		assert(device != NULL);
18		assert(device->type() == SEGA16SP);
	72	// default to 1:1 bank mapping
	73	for (int bank = 0; bank < ARRAY_LENGTH(m_bank); bank++)
	74	m_bank[bank] = bank;
	75	}
19	76
20		return (sega16sp_state *)downcast<legacy_device_base *>(device)->token();
	77
	78	//-------------------------------------------------
	79	//  device_start -- device startup
	80	//-------------------------------------------------
	81
	82	void sega_16bit_sprite_device::device_start()
	83	{
	84	// let the parent do its work
	85	sprite16_device_ind16::device_start();
	86
	87	// save states
	88	save_item(NAME(m_flip));
	89	save_item(NAME(m_bank));
21	90	}
22	91
23		INLINE const sega16sp_interface *get_interface( device_t *device )
	92
	93	//-------------------------------------------------
	94	//  draw_write -- trigger a buffer flip
	95	//-------------------------------------------------
	96
	97	WRITE16_MEMBER( sega_16bit_sprite_device::draw_write )
24	98	{
25		assert(device != NULL);
26		assert((device->type() == SEGA16SP));
27		return (const sega16sp_interface *) device->static_config();
	99	UINT32 *src = reinterpret_cast<UINT32 *>(spriteram());
	100	UINT32 *dst = reinterpret_cast<UINT32 *>(buffer());
	101
	102	// swap the halves of the sprite RAM
	103	for (int i = 0; i < spriteram_bytes()/4; i++)
	104	{
	105	UINT32 temp = *src;
	106	*src++ = *dst;
	107	*dst++ = temp;
	108	}
	109
	110	// hack for thunderblade
	111	*spriteram() = 0xffff;
	112
	113	// we will render the sprites when the video update happens
28	114	}
29	115
30		/*******************************************************************************************
31		*
32		*  Hang On-style sprites
33		*
34		*      Offs  Bits               Usage
35		*       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
36		*       +0   -------- tttttttt  Top scanline of sprite - 1
37		*       +2   bbbb---- --------  Sprite bank
38		*       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
39		*       +4   pppppppp pppppppp  Signed 16-bit pitch value between scanlines
40		*       +6   -ooooooo oooooooo  Offset within selected sprite bank
41		*       +6   f------- --------  Horizontal flip: read the data backwards if set
42		*       +8   --cccccc --------  Sprite color palette
43		*       +8   -------- zzzzzz--  Zoom factor
44		*       +8   -------- ------pp  Sprite priority
45		*       +E   dddddddd dddddddd  Scratch space for current address
46		*
47		*  Special notes:
48		*
49		*      There is an interaction between the horizonal flip bit and the offset.
50		*      The offset is maintained as a 16-bit value, even though only the lower
51		*      15 bits are used for the address. The top bit is used to control flipping.
52		*      This means that if the low 15 bits overflow during rendering, the sprite
53		*      data will be read backwards after the overflow. This is important to
54		*      emulate correctly as many games make use of this feature to render sprites
55		*      at the beginning of a bank.
56		*
57		*******************************************************************************************/
58	116
59		#define hangon_draw_pixel()                                       \
60		/* only draw if onscreen, not 0 or 15 */                        \
61		if (pix != 0 && pix != 15)                                    \
62		{                                                      \
63		/* are we high enough priority to be visible? */               \
64		if (sprpri > pri[x])                                    \
65		{                                                   \
66		/* shadow/hilight mode? */                              \
67		if (color == sega16sp->colorbase + (0x3f << 4))                  \
68		dest[x] += sega16sp->shadow ? segaic16_palette.entries*2 : segaic16_palette.entries;   \
69		\
70		/* regular draw */                                    \
71		else                                             \
72		dest[x] = pix | color;                              \
73		}                                                   \
74		\
75		/* always mark priority so no one else draws here */            \
76		pri[x] = 0xff;                                          \
77		}                                                      \
78	117
79		void segaic16_sprites_hangon_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	118	//****************************************************************************
	119	//  HANG ON-STYLE SPRITES
	120	//****************************************************************************
	121
	122	//-------------------------------------------------
	123	//  sega_hangon_sprite_device -- constructor
	124	//-------------------------------------------------
	125
	126	sega_hangon_sprite_device::sega_hangon_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	127	: sega_16bit_sprite_device(mconfig, SEGA_HANGON_SPRITES, "Sega Hang On Sprites", tag, owner)
80	128	{
81		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x10000;
82		const UINT16 *spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
83		const UINT8 *zoom = (const UINT8 *)machine.root_device().memregion("proms")->base();
84		sega16sp_state *sega16sp = get_safe_token(device);
85		UINT16* data = sega16sp->spriteram;
	129	set_origin(189, -1);
	130	}
86	131
87		/* first scan forward to find the end of the list */
88		for (data = sega16sp->spriteram; data < sega16sp->spriteram + sega16sp->ramsize/2; data += 8)
89		if ((data[0] >> 8) > 0xf0)
90		break;
91	132
92		/* now scan backwards and render the sprites in order */
93		for (data -= 8; data >= sega16sp->spriteram; data -= 8)
	133	//-------------------------------------------------
	134	//  draw -- render the sprites within the cliprect
	135	//-------------------------------------------------
	136
	137	void sega_hangon_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
	138	{
	139	//
	140	//   Hang On-style sprites
	141	//
	142	//       Offs  Bits               Usage
	143	//        +0   bbbbbbbb --------  Bottom scanline of sprite - 1
	144	//        +0   -------- tttttttt  Top scanline of sprite - 1
	145	//        +2   bbbb---- --------  Sprite bank
	146	//        +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
	147	//        +4   pppppppp pppppppp  Signed 16-bit pitch value between scanlines
	148	//        +6   -ooooooo oooooooo  Offset within selected sprite bank
	149	//        +6   f------- --------  Horizontal flip: read the data backwards if set
	150	//        +8   --cccccc --------  Sprite color palette
	151	//        +8   -------- zzzzzz--  Zoom factor
	152	//        +8   -------- ------pp  Sprite priority
	153	//        +E   dddddddd dddddddd  Scratch space for current address
	154	//
	155	//    Final bitmap format:
	156	//
	157	//             ----pp-- --------  Sprite priority
	158	//             ------cc cccc----  Sprite color palette
	159	//             -------- ----llll  4-bit pixel data
	160	//
	161	//   Special notes:
	162	//
	163	//       There is an interaction between the horizonal flip bit and the offset.
	164	//       The offset is maintained as a 16-bit value, even though only the lower
	165	//       15 bits are used for the address. The top bit is used to control flipping.
	166	//       This means that if the low 15 bits overflow during rendering, the sprite
	167	//       data will be read backwards after the overflow. This is important to
	168	//       emulate correctly as many games make use of this feature to render sprites
	169	//       at the beginning of a bank.
	170	//
	171
	172	// render the sprites in order
	173	const UINT16 *spritebase = reinterpret_cast<const UINT16 *>(region()->base());
	174	UINT8 numbanks = region()->bytes() / 0x10000;
	175	const UINT8 *zoom = memregion("zoom")->base();
	176	UINT16 *ramend = spriteram() + spriteram_elements();
	177	for (UINT16 *data = spriteram(); data < ramend; data += 8)
94	178	{
95		int bottom  = (data[0] >> 8) + 1;
96		int top     = (data[0] & 0xff) + 1;
97		int bank    = sega16sp->bank[(data[1] >> 12) & 0xf];
98		int xpos    = (data[1] & 0x1ff) - 0xbd;
99		int pitch   = (INT16)data[2];
	179	// fetch the bottom; stop when we get something out of range
	180	int bottom  = data[0] >> 8;
	181	if (bottom > 0xf0)
	182	break;
	183
	184	// extract remaining parameters
	185	int top     = data[0] & 0xff;
	186	int bank    = m_bank[(data[1] >> 12) & 0xf];
	187	int xpos    = data[1] & 0x1ff;
	188	int pitch   = INT16(data[2]);
100	189	UINT16 addr = data[3];
101		int color  = sega16sp->colorbase + (((data[4] >> 8) & 0x3f) << 4);
	190	int colpri  = (((data[4] >> 8) & 0x3f) << 4) | (((data[4] >> 0) & 0x3) << 10);
102	191	int vzoom   = (data[4] >> 2) & 0x3f;
103	192	int hzoom   = vzoom << 1;
104		int sprpri  = 1 << ((data[4] >> 0) & 0x3);
105		int x, y, pix, zaddr, zmask;
106		const UINT16 *spritedata;
107	193
108		/* initialize the end address to the start address */
	194	// initialize the end address to the start address
109	195	data[7] = addr;
110	196
111		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
112		if ((top >= bottom) || bank == 255)
	197	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
	198	if (top >= bottom || bank == 255)
113	199	continue;
114	200
115		/* clamp to within the memory region size */
	201	// clamp to within the memory region size
116	202	if (numbanks)
117	203	bank %= numbanks;
118		spritedata = spritebase + 0x8000 * bank;
	204	const UINT16 *spritedata = spritebase + 0x8000 * bank;
119	205
120		/* determine the starting zoom address and mask */
121		zaddr = (vzoom & 0x38) << 5;
122		zmask = 1 << (vzoom & 7);
	206	// determine the starting zoom address and mask
	207	int zaddr = (vzoom & 0x38) << 5;
	208	int zmask = 1 << (vzoom & 7);
123	209
124		/* loop from top to bottom */
125		for (y = top; y < bottom; y++)
	210	// loop from top to bottom
	211	int minx = xpos;
	212	int maxx = xpos;
	213	int miny = -1;
	214	int maxy = -1;
	215	for (int y = top; y < bottom; y++)
126	216	{
127		/* advance a row */
	217	// advance a row
128	218	addr += pitch;
129	219
130		/* if the zoom bit says so, add pitch a second time */
	220	// if the zoom bit says so, add pitch a second time
131	221	if (zoom[zaddr++] & zmask)
132	222	addr += pitch;
133	223
134		/* skip drawing if not within the cliprect */
	224	// skip drawing if not within the cliprect
135	225	if (y >= cliprect.min_y && y <= cliprect.max_y)
136	226	{
137		UINT16 *dest = &bitmap.pix16(y);
138		UINT8 *pri = &machine.priority_bitmap.pix8(y);
	227	UINT16 *dest = &bitmap.pix(y);
139	228	int xacc = 0x00;
	229	int x;
140	230
141		/* note that the System 16A sprites have a design flaw that allows the address */
142		/* to carry into the flip flag, which is the topmost bit -- it is very important */
143		/* to emulate this as the games compensate for it */
	231	// note that the System 16A sprites have a design flaw that allows the address
	232	// to carry into the flip flag, which is the topmost bit -- it is very important
	233	// to emulate this as the games compensate for it
144	234
145		/* non-flipped case */
	235	// non-flipped case
146	236	if (!(addr & 0x8000))
147	237	{
148		/* start at the word before because we preincrement below */
	238	// start at the word before because we preincrement below
149	239	data[7] = addr - 1;
150	240	for (x = xpos; x <= cliprect.max_x; )
151	241	{
152	242	UINT16 pixels = spritedata[++data[7] & 0x7fff];
153	243
154		/* draw four pixels */
155		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
156		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
157		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
158		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
	244	// draw four pixels
	245	int pix;
	246	pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	247	pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	248	pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	249	pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
159	250
160		/* stop if the last pixel in the group was 0xf */
	251	// stop if the last pixel in the group was 0xf
161	252	if (pix == 15)
162	253	break;
163	254	}
164	255	}
165	256
166		/* flipped case */
	257	// flipped case
167	258	else
168	259	{
169		/* start at the word after because we predecrement below */
	260	// start at the word after because we predecrement below
170	261	data[7] = addr + 1;
171	262	for (x = xpos; x <= cliprect.max_x; )
172	263	{
173	264	UINT16 pixels = spritedata[--data[7] & 0x7fff];
174	265
175		/* draw four pixels */
176		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
177		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
178		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
179		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) hangon_draw_pixel(); x++; }
	266	// draw four pixels
	267	int pix;
	268	pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	269	pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	270	pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	271	pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
180	272
181		/* stop if the last pixel in the group was 0xf */
	273	// stop if the last pixel in the group was 0xf
182	274	if (pix == 15)
183	275	break;
184	276	}
185	277	}
	278
	279	// update bounds
	280	if (x > maxx) maxx = x;
	281	if (miny == -1) miny = y;
	282	maxy = y;
186	283	}
187	284	}
	285
	286	// mark dirty
	287	if (miny != -1)
	288	mark_dirty(minx, maxx, miny, maxy);
188	289	}
189	290	}
190	291
191	292
192	293
193		/*******************************************************************************************
194		*
195		*  Space Harrier-style sprites
196		*
197		*      Offs  Bits               Usage
198		*       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
199		*       +0   -------- tttttttt  Top scanline of sprite - 1
200		*       +2   bbbb---- --------  Sprite bank
201		*       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
202		*       +4   s------- --------  Sprite shadow enable (0=enable, 1=disable)
203		*       +4   -p------ --------  Sprite priority
204		*       +4   --cccccc --------  Sprite color palette
205		*       +4   -------- -ppppppp  Signed 7-bit pitch value between scanlines
206		*       +6   f------- --------  Horizontal flip: read the data backwards if set
207		*       +6   -ooooooo oooooooo  Offset within selected sprite bank
208		*       +8   --zzzzzz --------  Horizontal zoom factor
209		*       +8   -------- --zzzzzz  Vertical zoom factor
210		*       +E   dddddddd dddddddd  Scratch space for current address
211		*
212		*  Special notes:
213		*
214		*      There is an interaction between the horizonal flip bit and the offset.
215		*      The offset is maintained as a 16-bit value, even though only the lower
216		*      15 bits are used for the address. The top bit is used to control flipping.
217		*      This means that if the low 15 bits overflow during rendering, the sprite
218		*      data will be read backwards after the overflow. This is important to
219		*      emulate correctly as many games make use of this feature to render sprites
220		*      at the beginning of a bank.
221		*
222		*******************************************************************************************/
	294	//****************************************************************************
	295	//  SPACE HARRIER-STYLE SPRITES
	296	//****************************************************************************
223	297
224		#define sharrier_draw_pixel()                                    \
225		/* only draw if onscreen, not 0 or 15 */                        \
226		if (pix != 0 && pix != 15)                                    \
227		{                                                      \
228		/* are we high enough priority to be visible? */               \
229		if (sprpri > pri[x])                                    \
230		{                                                   \
231		/* shadow/hilight mode? */                              \
232		if (shadow && pix == 0xa)                              \
233		dest[x] += (segaic16_paletteram[dest[x]] & 0x8000) ? segaic16_palette.entries*2 : segaic16_palette.entries;   \
234		\
235		/* regular draw */                                    \
236		else                                             \
237		dest[x] = pix | color;                              \
238		}                                                   \
239		\
240		/* always mark priority so no one else draws here */            \
241		pri[x] = 0xff;                                          \
242		}                                                      \
	298	//-------------------------------------------------
	299	//  sega_sharrier_sprite_device -- constructor
	300	//-------------------------------------------------
243	301
244		void segaic16_sprites_sharrier_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	302	sega_sharrier_sprite_device::sega_sharrier_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	303	: sega_16bit_sprite_device(mconfig, SEGA_SHARRIER_SPRITES, "Sega Space Harrier Sprites", tag, owner)
245	304	{
246		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x20000;
247		const UINT32 *spritebase = (const UINT32 *)machine.root_device().memregion("gfx2")->base();
248		const UINT8 *zoom = (const UINT8 *)machine.root_device().memregion("proms")->base();
249		sega16sp_state *sega16sp = get_safe_token(device);
250		UINT16* data = sega16sp->spriteram;
	305	set_origin(189, -1);
	306	}
251	307
252		/* first scan forward to find the end of the list */
253		for (data = sega16sp->spriteram; data < sega16sp->spriteram + sega16sp->ramsize/2; data += 8)
254		if ((data[0] >> 8) > 0xf0)
255		break;
256	308
257		/* now scan backwards and render the sprites in order */
258		for (data -= 8; data >= sega16sp->spriteram; data -= 8)
	309	//-------------------------------------------------
	310	//  draw -- render the sprites within the cliprect
	311	//-------------------------------------------------
	312
	313	void sega_sharrier_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
	314	{
	315	//
	316	//   Space Harrier-style sprites
	317	//
	318	//      Offs  Bits               Usage
	319	//       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
	320	//       +0   -------- tttttttt  Top scanline of sprite - 1
	321	//       +2   bbbb---- --------  Sprite bank
	322	//       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
	323	//       +4   s------- --------  Sprite shadow disable (0=enable, 1=disable)
	324	//       +4   -p------ --------  Sprite priority
	325	//       +4   --cccccc --------  Sprite color palette
	326	//       +4   -------- -ppppppp  Signed 7-bit pitch value between scanlines
	327	//       +6   f------- --------  Horizontal flip: read the data backwards if set
	328	//       +6   -ooooooo oooooooo  Offset within selected sprite bank
	329	//       +8   --zzzzzz --------  Horizontal zoom factor
	330	//       +8   -------- --zzzzzz  Vertical zoom factor
	331	//       +E   dddddddd dddddddd  Scratch space for current address
	332	//
	333	//    Final bitmap format:
	334	//
	335	//             ----s--- --------  Sprite shadow disable
	336	//             -----p-- --------  Sprite priority
	337	//             ------cc cccc----  Sprite color palette
	338	//             -------- ----llll  4-bit pixel data
	339	//
	340	//   Special notes:
	341	//
	342	//      There is an interaction between the horizonal flip bit and the offset.
	343	//      The offset is maintained as a 16-bit value, even though only the lower
	344	//      15 bits are used for the address. The top bit is used to control flipping.
	345	//      This means that if the low 15 bits overflow during rendering, the sprite
	346	//      data will be read backwards after the overflow. This is important to
	347	//      emulate correctly as many games make use of this feature to render sprites
	348	//      at the beginning of a bank.
	349	//
	350
	351	// render the sprites in order
	352	const UINT32 *spritebase = reinterpret_cast<const UINT32 *>(region()->base());
	353	UINT8 numbanks = region()->bytes() / 0x20000;
	354	const UINT8 *zoom = memregion("zoom")->base();
	355	UINT16 *ramend = spriteram() + spriteram_elements();
	356	for (UINT16 *data = spriteram(); data < ramend; data += 8)
259	357	{
260		int bottom  = (data[0] >> 8) + 1;
261		int top     = (data[0] & 0xff) + 1;
262		int bank    = sega16sp->bank[(data[1] >> 12) & 0x7];
263		int xpos    = (data[1] & 0x1ff) - 0xbd;
264		int shadow  = (~data[2] >> 15) & 1;
265		int sprpri  = ((data[2] >> 14) & 1) ? (1<<3) : (1<<1);
266		int color   = sega16sp->colorbase + (((data[2] >> 8) & 0x3f) << 4);
267		int pitch   = (INT16)(data[2] << 9) >> 9;
	358	// fetch the bottom; stop when we get something out of range
	359	int bottom  = data[0] >> 8;
	360	if (bottom > 0xf0)
	361	break;
	362
	363	// extract remaining parameters
	364	int top     = data[0] & 0xff;
	365	int bank    = m_bank[(data[1] >> 12) & 0x7];
	366	int xpos    = data[1] & 0x1ff;
	367	int colpri  = ((data[2] >> 8) & 0xff) << 4;
	368	int pitch   = INT16(data[2] << 9) >> 9;
268	369	UINT16 addr = data[3];
269	370	int hzoom   = ((data[4] >> 8) & 0x3f) << 1;
270	371	int vzoom   = (data[4] >> 0) & 0x3f;
271		int x, y, pix, zaddr, zmask;
272		const UINT32 *spritedata;
273	372
274		/* initialize the end address to the start address */
	373	// initialize the end address to the start address
275	374	data[7] = addr;
276	375
277		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
278		if ((top >= bottom) || bank == 255)
	376	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
	377	if (top >= bottom || bank == 255)
279	378	continue;
280	379
281		/* clamp to within the memory region size */
	380	// clamp to within the memory region size
282	381	if (numbanks)
283	382	bank %= numbanks;
284		spritedata = spritebase + 0x8000 * bank;
	383	const UINT32 *spritedata = spritebase + 0x8000 * bank;
285	384
286		/* determine the starting zoom address and mask */
287		zaddr = (vzoom & 0x38) << 5;
288		zmask = 1 << (vzoom & 7);
	385	// determine the starting zoom address and mask
	386	int zaddr = (vzoom & 0x38) << 5;
	387	int zmask = 1 << (vzoom & 7);
289	388
290		/* loop from top to bottom */
291		for (y = top; y < bottom; y++)
	389	// loop from top to bottom
	390	int minx = xpos;
	391	int maxx = xpos;
	392	int miny = -1;
	393	int maxy = -1;
	394	for (int y = top; y < bottom; y++)
292	395	{
293		/* advance a row */
	396	// advance a row
294	397	addr += pitch;
295	398
296		/* if the zoom bit says so, add pitch a second time */
	399	// if the zoom bit says so, add pitch a second time
297	400	if (zoom[zaddr++] & zmask)
298	401	addr += pitch;
299	402
300		/* skip drawing if not within the cliprect */
	403	// skip drawing if not within the cliprect
301	404	if (y >= cliprect.min_y && y <= cliprect.max_y)
302	405	{
303		UINT16 *dest = &bitmap.pix16(y);
304		UINT8 *pri = &machine.priority_bitmap.pix8(y);
	406	UINT16 *dest = &bitmap.pix(y);
305	407	int xacc = 0x00;
	408	int x;
306	409
307		/* note that the System 16A sprites have a design flaw that allows the address */
308		/* to carry into the flip flag, which is the topmost bit -- it is very important */
309		/* to emulate this as the games compensate for it */
	410	// note that the System 16A sprites have a design flaw that allows the address
	411	// to carry into the flip flag, which is the topmost bit -- it is very important
	412	// to emulate this as the games compensate for it
310	413
311		/* non-flipped case */
	414	// non-flipped case
312	415	if (!(addr & 0x8000))
313	416	{
314		/* start at the word before because we preincrement below */
	417	// start at the word before because we preincrement below
315	418	data[7] = addr - 1;
316	419	for (x = xpos; x <= cliprect.max_x; )
317	420	{
318	421	UINT32 pixels = spritedata[++data[7] & 0x7fff];
319	422
320		/* draw 8 pixels */
321		pix = (pixels >> 28) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
322		pix = (pixels >> 24) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
323		pix = (pixels >> 20) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
324		pix = (pixels >> 16) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
325		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
326		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
327		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
328		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
	423	// draw 8 pixels
	424	int pix;
	425	pix = (pixels >> 28) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	426	pix = (pixels >> 24) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	427	pix = (pixels >> 20) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	428	pix = (pixels >> 16) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	429	pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	430	pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	431	pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	432	pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
329	433
330		/* stop if the last pixel in the group was 0xf */
	434	// stop if the last pixel in the group was 0xf
331	435	if (pix == 15)
332	436	break;
333	437	}
334	438	}
335	439
336		/* flipped case */
	440	// flipped case
337	441	else
338	442	{
339		/* start at the word after because we predecrement below */
	443	// start at the word after because we predecrement below
340	444	data[7] = addr + 1;
341	445	for (x = xpos; x <= cliprect.max_x; )
342	446	{
343	447	UINT32 pixels = spritedata[--data[7] & 0x7fff];
344	448
345		/* draw 8 pixels */
346		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
347		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
348		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
349		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
350		pix = (pixels >> 16) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
351		pix = (pixels >> 20) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
352		pix = (pixels >> 24) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
353		pix = (pixels >> 28) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x) sharrier_draw_pixel(); x++; }
	449	// draw 8 pixels
	450	int pix;
	451	pix = (pixels >>  0) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	452	pix = (pixels >>  4) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	453	pix = (pixels >>  8) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	454	pix = (pixels >> 12) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	455	pix = (pixels >> 16) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	456	pix = (pixels >> 20) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	457	pix = (pixels >> 24) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
	458	pix = (pixels >> 28) & 0xf; xacc = (xacc & 0xff) + hzoom; if (xacc < 0x100) { if (x >= cliprect.min_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x++; }
354	459
355		/* stop if the last pixel in the group was 0xf */
	460	// stop if the last pixel in the group was 0xf
356	461	if (pix == 15)
357	462	break;
358	463	}
359	464	}
	465
	466	// update bounds
	467	if (x > maxx) maxx = x;
	468	if (miny == -1) miny = y;
	469	maxy = y;
360	470	}
361	471	}
	472
	473	// mark dirty
	474	if (miny != -1)
	475	mark_dirty(minx, maxx, miny, maxy);
362	476	}
363	477	}
364	478
365	479
366	480
367		/*******************************************************************************************
368		*
369		*  System 16A-style sprites
370		*
371		*      Offs  Bits               Usage
372		*       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
373		*       +0   -------- tttttttt  Top scanline of sprite - 1
374		*       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
375		*       +4   pppppppp pppppppp  Signed 16-bit pitch value between scanlines
376		*       +6   -ooooooo oooooooo  Offset within selected sprite bank
377		*       +6   f------- --------  Horizontal flip: read the data backwards if set
378		*       +8   --cccccc --------  Sprite color palette
379		*       +8   -------- -bbb----  Sprite bank
380		*       +8   -------- ------pp  Sprite priority
381		*       +E   dddddddd dddddddd  Scratch space for current address
382		*
383		*  Special notes:
384		*
385		*      There is an interaction between the horizonal flip bit and the offset.
386		*      The offset is maintained as a 16-bit value, even though only the lower
387		*      15 bits are used for the address. The top bit is used to control flipping.
388		*      This means that if the low 15 bits overflow during rendering, the sprite
389		*      data will be read backwards after the overflow. This is important to
390		*      emulate correctly as many games make use of this feature to render sprites
391		*      at the beginning of a bank.
392		*
393		*******************************************************************************************/
	481	//****************************************************************************
	482	//  SYSTEM 16A-STYLE SPRITES
	483	//****************************************************************************
394	484
395		#define system16a_draw_pixel()                                    \
396		/* only draw if onscreen, not 0 or 15 */                        \
397		if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) \
398		{                                                      \
399		/* are we high enough priority to be visible? */               \
400		if (sprpri > pri[x])                                    \
401		{                                                   \
402		/* shadow/hilight mode? */                              \
403		if (color == sega16sp->colorbase + (0x3f << 4))                  \
404		dest[x] += (segaic16_paletteram[dest[x]] & 0x8000) ? segaic16_palette.entries*2 : segaic16_palette.entries;   \
405		\
406		/* regular draw */                                    \
407		else                                             \
408		dest[x] = pix | color;                              \
409		}                                                   \
410		\
411		/* always mark priority so no one else draws here */            \
412		pri[x] = 0xff;                                          \
413		}                                                      \
	485	//-------------------------------------------------
	486	//  sega_sys16a_sprite_device -- constructor
	487	//-------------------------------------------------
414	488
415		void segaic16_sprites_16a_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	489	sega_sys16a_sprite_device::sega_sys16a_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	490	: sega_16bit_sprite_device(mconfig, SEGA_SYS16A_SPRITES, "Sega System 16A Sprites", tag, owner)
416	491	{
417		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x10000;
418		const UINT16 *spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
419		sega16sp_state *sega16sp = get_safe_token(device);
420		UINT16* data = sega16sp->spriteram;
	492	set_origin(189, -1);
	493	}
421	494
422		/* first scan forward to find the end of the list */
423		for (data = sega16sp->spriteram; data < sega16sp->spriteram + sega16sp->ramsize/2; data += 8)
424		if ((data[0] >> 8) > 0xf0)
425		break;
426	495
427		/* now scan backwards and render the sprites in order */
428		for (data -= 8; data >= sega16sp->spriteram; data -= 8)
	496	//-------------------------------------------------
	497	//  draw -- render the sprites within the cliprect
	498	//-------------------------------------------------
	499
	500	void sega_sys16a_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
	501	{
	502	//
	503	//   System 16A-style sprites
	504	//
	505	//      Offs  Bits               Usage
	506	//       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
	507	//       +0   -------- tttttttt  Top scanline of sprite - 1
	508	//       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
	509	//       +4   pppppppp pppppppp  Signed 16-bit pitch value between scanlines
	510	//       +6   -ooooooo oooooooo  Offset within selected sprite bank
	511	//       +6   f------- --------  Horizontal flip: read the data backwards if set
	512	//       +8   --cccccc --------  Sprite color palette
	513	//       +8   -------- -bbb----  Sprite bank
	514	//       +8   -------- ------pp  Sprite priority
	515	//       +E   dddddddd dddddddd  Scratch space for current address
	516	//
	517	//    Final bitmap format:
	518	//
	519	//             ----pp-- --------  Sprite priority
	520	//             ------cc cccc----  Sprite color palette
	521	//             -------- ----llll  4-bit pixel data
	522	//
	523	//   Special notes:
	524	//
	525	//      There is an interaction between the horizonal flip bit and the offset.
	526	//      The offset is maintained as a 16-bit value, even though only the lower
	527	//      15 bits are used for the address. The top bit is used to control flipping.
	528	//      This means that if the low 15 bits overflow during rendering, the sprite
	529	//      data will be read backwards after the overflow. This is important to
	530	//      emulate correctly as many games make use of this feature to render sprites
	531	//      at the beginning of a bank.
	532	//
	533
	534	// render the sprites in order
	535	const UINT16 *spritebase = reinterpret_cast<const UINT16 *>(region()->base());
	536	UINT8 numbanks = region()->bytes() / 0x10000;
	537	UINT16 *ramend = spriteram() + spriteram_elements();
	538	for (UINT16 *data = spriteram(); data < ramend; data += 8)
429	539	{
430		int bottom  = (data[0] >> 8) + 1;
431		int top     = (data[0] & 0xff) + 1;
432		int xpos    = (data[1] & 0x1ff) - 0xbd;
433		int pitch   = (INT16)data[2];
	540	// fetch the bottom; stop when we get something out of range
	541	int bottom  = data[0] >> 8;
	542	if (bottom > 0xf0)
	543	break;
	544
	545	// extract remaining parameters
	546	int top     = data[0] & 0xff;
	547	int xpos    = data[1] & 0x1ff;
	548	int pitch   = INT16(data[2]);
434	549	UINT16 addr = data[3];
435		int color   = sega16sp->colorbase + (((data[4] >> 8) & 0x3f) << 4);
436		int bank    = sega16sp->bank[(data[4] >> 4) & 0x7];
437		int sprpri  = 1 << ((data[4] >> 0) & 0x3);
438		const UINT16 *spritedata;
439		int x, y, pix, xdelta = 1;
	550	int colpri  = (((data[4] >> 8) & 0x3f) << 4) | (((data[4] >> 0) & 0x3) << 10);
	551	int bank    = m_bank[(data[4] >> 4) & 0x7];
440	552
441		/* initialize the end address to the start address */
	553	// initialize the end address to the start address
442	554	data[7] = addr;
443	555
444		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
445		if ((top >= bottom) || bank == 255)
	556	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
	557	if (top >= bottom || bank == 255)
446	558	continue;
447	559
448		/* clamp to within the memory region size */
	560	// clamp to within the memory region size
449	561	if (numbanks)
450	562	bank %= numbanks;
451		spritedata = spritebase + 0x8000 * bank;
	563	const UINT16 *spritedata = spritebase + 0x8000 * bank;
452	564
453		/* adjust positions for screen flipping */
454		if (sega16sp->flip)
	565	// adjust positions for screen flipping
	566	int xdelta = 1;
	567	if (m_flip)
455	568	{
456	569	int temp = top;
457	570	top = 224 - bottom;
r17593	r17594
460	573	xdelta = -1;
461	574	}
462	575
463		/* loop from top to bottom */
464		for (y = top; y < bottom; y++)
	576	// loop from top to bottom
	577	int minx = xpos;
	578	int maxx = xpos;
	579	int miny = -1;
	580	int maxy = -1;
	581	for (int y = top; y < bottom; y++)
465	582	{
466		/* advance a row */
	583	// advance a row
467	584	addr += pitch;
468	585
469		/* skip drawing if not within the cliprect */
	586	// skip drawing if not within the cliprect
470	587	if (y >= cliprect.min_y && y <= cliprect.max_y)
471	588	{
472		UINT16 *dest = &bitmap.pix16(y);
473		UINT8 *pri = &machine.priority_bitmap.pix8(y);
	589	UINT16 *dest = &bitmap.pix(y);
	590	int x;
474	591
475		/* note that the System 16A sprites have a design flaw that allows the address */
476		/* to carry into the flip flag, which is the topmost bit -- it is very important */
477		/* to emulate this as the games compensate for it */
	592	// note that the System 16A sprites have a design flaw that allows the address
	593	// to carry into the flip flag, which is the topmost bit -- it is very important
	594	// to emulate this as the games compensate for it
478	595
479		/* non-flipped case */
	596	// non-flipped case
480	597	if (!(addr & 0x8000))
481	598	{
482		/* start at the word before because we preincrement below */
	599	// start at the word before because we preincrement below
483	600	data[7] = addr - 1;
484	601	for (x = xpos; ((xpos - x) & 0x1ff) != 1; )
485	602	{
486	603	UINT16 pixels = spritedata[++data[7] & 0x7fff];
487	604
488		/* draw four pixels */
489		pix = (pixels >> 12) & 0xf; system16a_draw_pixel(); x += xdelta;
490		pix = (pixels >>  8) & 0xf; system16a_draw_pixel(); x += xdelta;
491		pix = (pixels >>  4) & 0xf; system16a_draw_pixel(); x += xdelta;
492		pix = (pixels >>  0) & 0xf; system16a_draw_pixel(); x += xdelta;
	605	// draw four pixels
	606	int pix;
	607	pix = (pixels >> 12) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	608	pix = (pixels >>  8) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	609	pix = (pixels >>  4) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	610	pix = (pixels >>  0) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
493	611
494		/* stop if the last pixel in the group was 0xf */
	612	// stop if the last pixel in the group was 0xf
495	613	if (pix == 15)
496	614	break;
497	615	}
498	616	}
499	617
500		/* flipped case */
	618	// flipped case
501	619	else
502	620	{
503		/* start at the word after because we predecrement below */
	621	// start at the word after because we predecrement below
504	622	data[7] = addr + 1;
505	623	for (x = xpos; ((xpos - x) & 0x1ff) != 1; )
506	624	{
507	625	UINT16 pixels = spritedata[--data[7] & 0x7fff];
508	626
509		/* draw four pixels */
510		pix = (pixels >>  0) & 0xf; system16a_draw_pixel(); x += xdelta;
511		pix = (pixels >>  4) & 0xf; system16a_draw_pixel(); x += xdelta;
512		pix = (pixels >>  8) & 0xf; system16a_draw_pixel(); x += xdelta;
513		pix = (pixels >> 12) & 0xf; system16a_draw_pixel(); x += xdelta;
	627	// draw four pixels
	628	int pix;
	629	pix = (pixels >>  0) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	630	pix = (pixels >>  4) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	631	pix = (pixels >>  8) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	632	pix = (pixels >> 12) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
514	633
515		/* stop if the last pixel in the group was 0xf */
	634	// stop if the last pixel in the group was 0xf
516	635	if (pix == 15)
517	636	break;
518	637	}
519	638	}
	639
	640	// update bounds
	641	if (x > maxx) maxx = x;
	642	if (x < minx) minx = x;
	643	if (miny == -1) miny = y;
	644	maxy = y;
520	645	}
521	646	}
	647
	648	// mark dirty
	649	if (miny != -1)
	650	mark_dirty(minx, maxx, miny, maxy);
522	651	}
523	652	}
524	653
525	654
	655	//****************************************************************************
	656	//  BOOTLEG SYSTEM 16A-STYLE SPRITES
	657	//****************************************************************************
526	658
527		/*******************************************************************************************
528		*
529		*  System 16B-style sprites
530		*
531		*      Offs  Bits               Usage
532		*       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
533		*       +0   -------- tttttttt  Top scanline of sprite - 1
534		*       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
535		*       +4   e------- --------  Signify end of sprite list
536		*       +4   -h------ --------  Hide this sprite
537		*       +4   -------f --------  Horizontal flip: read the data backwards if set
538		*       +4   -------- pppppppp  Signed 8-bit pitch value between scanlines
539		*       +6   oooooooo oooooooo  Offset within selected sprite bank
540		*       +8   ----bbbb --------  Sprite bank
541		*       +8   -------- pp------  Sprite priority, relative to tilemaps
542		*       +8   -------- --cccccc  Sprite color palette
543		*       +A   ------vv vvv-----  Vertical zoom factor (0 = full size, 0x10 = half size)
544		*       +A   -------- ---hhhhh  Horizontal zoom factor (0 = full size, 0x10 = half size)
545		*       +E   dddddddd dddddddd  Scratch space for current address
546		*
547		*  Note that the zooming described below is 100% accurate to the real board.
548		*
549		*******************************************************************************************/
	659	//-------------------------------------------------
	660	//  bootleg_sys16a_sprite_device -- constructor
	661	//-------------------------------------------------
550	662
551		#define system16b_draw_pixel()                                    \
552		/* only draw if onscreen, not 0 or 15 */                        \
553		if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) \
554		{                                                      \
555		/* are we high enough priority to be visible? */               \
556		if (sprpri > pri[x])                                    \
557		{                                                   \
558		/* shadow/hilight mode? */                              \
559		if (color == sega16sp->colorbase + (0x3f << 4))                  \
560		{                                                \
561		/* we have to check this for System 18 so that we don't */  \
562		/* attempt to shadow VDP pixels */                     \
563		if (dest[x] < segaic16_palette.entries)                        \
564		dest[x] += (segaic16_paletteram[dest[x]] & 0x8000) ? segaic16_palette.entries*2 : segaic16_palette.entries; \
565		}                                                \
566		\
567		/* regular draw */                                    \
568		else                                             \
569		dest[x] = pix | color;                              \
570		}                                                   \
571		\
572		/* always mark priority so no one else draws here */            \
573		pri[x] = 0xff;                                          \
574		}                                                      \
	663	bootleg_sys16a_sprite_device::bootleg_sys16a_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	664	: sega_16bit_sprite_device(mconfig, BOOTLEG_SYS16A_SPRITES, "Bootleg System 16A Sprites", tag, owner)
	665	{
	666	m_addrmap[0] = 0;
	667	m_addrmap[1] = 1;
	668	m_addrmap[2] = 2;
	669	m_addrmap[3] = 3;
	670	m_addrmap[4] = 4;
	671	m_addrmap[5] = 5;
	672	m_addrmap[6] = 6;
	673	m_addrmap[7] = 7;
	674	set_origin(189, -1);
	675	}
575	676
576		void segaic16_sprites_16b_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	677
	678	//-------------------------------------------------
	679	//  static_set_remap -- configure sprite address
	680	//   remapping
	681	//-------------------------------------------------
	682
	683	void bootleg_sys16a_sprite_device::static_set_remap(device_t &device, UINT8 offs0, UINT8 offs1, UINT8 offs2, UINT8 offs3, UINT8 offs4, UINT8 offs5, UINT8 offs6, UINT8 offs7)
577	684	{
578		UINT8 numbanks;
579		const UINT16 *spritebase;
580		sega16sp_state *sega16sp = get_safe_token(device);
581		UINT16* data = sega16sp->spriteram;
	685	bootleg_sys16a_sprite_device &target = downcast<bootleg_sys16a_sprite_device &>(device);
	686	target.m_addrmap[0] = offs0;
	687	target.m_addrmap[1] = offs1;
	688	target.m_addrmap[2] = offs2;
	689	target.m_addrmap[3] = offs3;
	690	target.m_addrmap[4] = offs4;
	691	target.m_addrmap[5] = offs5;
	692	target.m_addrmap[6] = offs6;
	693	target.m_addrmap[7] = offs7;
	694	}
582	695
583		spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
584		if (!spritebase)
585		return;
586	696
587		numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x20000;
	697	//-------------------------------------------------
	698	//  draw -- render the sprites within the cliprect
	699	//-------------------------------------------------
588	700
589		/* first scan forward to find the end of the list */
590		for (data = sega16sp->spriteram; data < sega16sp->spriteram + sega16sp->ramsize/2; data += 8)
591		if (data[2] & 0x8000)
592		break;
	701	void bootleg_sys16a_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
	702	{
	703	//
	704	//   Bootleg System 16A-style sprites
	705	//
	706	//   These are identical to regular System 16A sprites (see above), with two exceptions:
	707	//
	708	//      1. Addresses within each sprite entry are generally shuffled relative
	709	//         to the original, and
	710	//
	711	//      2. The pitch increment happens at the end, not at the beginning of
	712	//         the loop.
	713	//
593	714
594		/* now scan backwards and render the sprites in order */
595		for (data -= 8; data >= sega16sp->spriteram; data -= 8)
	715	// render the sprites in order
	716	const UINT16 *spritebase = reinterpret_cast<const UINT16 *>(region()->base());
	717	UINT8 numbanks = region()->bytes() / 0x10000;
	718	UINT16 *ramend = spriteram() + spriteram_elements();
	719	for (UINT16 *data = spriteram(); data < ramend; data += 8)
596	720	{
597		int bottom  = data[0] >> 8;
598		int top     = data[0] & 0xff;
599		int xpos    = (data[1] & 0x1ff);
600		int hide    = data[2] & 0x4000;
601		int flip    = data[2] & 0x100;
602		int pitch   = (INT8)(data[2] & 0xff);
603		UINT16 addr = data[3];
604		int bank    = sega16sp->bank[(data[4] >> 8) & 0xf];
605		int sprpri  = 1 << ((data[4] >> 6) & 0x3);
606		int color   = sega16sp->colorbase + ((data[4] & 0x3f) << 4);
607		int vzoom   = (data[5] >> 5) & 0x1f;
608		int hzoom   = data[5] & 0x1f;
609		const UINT16 *spritedata;
610		int x, y, pix, xdelta = 1;
	721	// fetch the bottom; stop when we get something out of range
	722	int bottom  = data[m_addrmap[0]] >> 8;
	723	if (bottom > 0xf0)
	724	break;
611	725
612		/* some bootlegs have offset sprites */
613		xpos += sega16sp->xoffs;
614		xpos &= 0x1ff;
	726	// extract remaining parameters
	727	int top     = data[m_addrmap[0]] & 0xff;
	728	int xpos    = data[m_addrmap[1]] & 0x1ff;
	729	int pitch   = INT16(data[m_addrmap[2]]);
	730	UINT16 addr = data[m_addrmap[3]];
	731	int colpri  = (((data[m_addrmap[4]] >> 8) & 0x3f) << 4) | (((data[m_addrmap[4]] >> 0) & 0x3) << 10);
	732	int bank    = m_bank[(data[m_addrmap[4]] >> 4) & 0x7];
615	733
616		/* originals all have this offset */
617		xpos -= 0xb8;
	734	// initialize the end address to the start address
	735	UINT16 &data7 = data[m_addrmap[7]];
	736	data7 = addr;
618	737
619		/* initialize the end address to the start address */
620		data[7] = addr;
621
622		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
623		if (hide || (top >= bottom) || bank == 255)
	738	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
	739	if (top >= bottom || bank == 255)
624	740	continue;
625	741
626		/* clamp to within the memory region size */
	742	// clamp to within the memory region size
627	743	if (numbanks)
628	744	bank %= numbanks;
629		spritedata = spritebase + 0x10000 * bank;
	745	const UINT16 *spritedata = spritebase + 0x8000 * bank;
630	746
631		/* reset the yzoom counter */
632		data[5] &= 0x03ff;
633
634		/* adjust positions for screen flipping */
635		if (sega16sp->flip)
	747	// adjust positions for screen flipping
	748	int xdelta = 1;
	749	if (m_flip)
636	750	{
637	751	int temp = top;
638	752	top = 224 - bottom;
r17593	r17594
641	755	xdelta = -1;
642	756	}
643	757
644		/* loop from top to bottom */
645		for (y = top; y < bottom; y++)
	758	// loop from top to bottom
	759	int minx = xpos;
	760	int maxx = xpos;
	761	int miny = -1;
	762	int maxy = -1;
	763	for (int y = top; y < bottom; y++)
646	764	{
647		/* advance a row */
648		addr += pitch;
649
650		/* accumulate zoom factors; if we carry into the high bit, skip an extra row */
651		data[5] += vzoom << 10;
652		if (data[5] & 0x8000)
653		{
654		addr += pitch;
655		data[5] &= ~0x8000;
656		}
657
658		/* skip drawing if not within the cliprect */
	765	// skip drawing if not within the cliprect
659	766	if (y >= cliprect.min_y && y <= cliprect.max_y)
660	767	{
661		UINT16 *dest = &bitmap.pix16(y);
662		UINT8 *pri = &machine.priority_bitmap.pix8(y);
663		int xacc;
	768	UINT16 *dest = &bitmap.pix(y);
	769	int x;
664	770
665		/* compute the initial X zoom accumulator; this is verified on the real PCB */
666		xacc = 4 * hzoom;
	771	// note that the System 16A sprites have a design flaw that allows the address
	772	// to carry into the flip flag, which is the topmost bit -- it is very important
	773	// to emulate this as the games compensate for it
667	774
668		/* non-flipped case */
669		if (!flip)
	775	// non-flipped case
	776	if (!(addr & 0x8000))
670	777	{
671		/* start at the word before because we preincrement below */
672		data[7] = addr - 1;
	778	// start at the word before because we preincrement below
	779	data7 = addr - 1;
673	780	for (x = xpos; ((xpos - x) & 0x1ff) != 1; )
674	781	{
675		UINT16 pixels = spritedata[++data[7]];
	782	UINT16 pixels = spritedata[++data7 & 0x7fff];
676	783
677		/* draw four pixels */
678		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
679		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
680		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
681		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
	784	// draw four pixels
	785	int pix;
	786	pix = (pixels >> 12) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	787	pix = (pixels >>  8) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	788	pix = (pixels >>  4) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	789	pix = (pixels >>  0) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
682	790
683		/* stop if the last pixel in the group was 0xf */
	791	// stop if the last pixel in the group was 0xf
684	792	if (pix == 15)
685	793	break;
686	794	}
687	795	}
688	796
689		/* flipped case */
	797	// flipped case
690	798	else
691	799	{
692		/* start at the word after because we predecrement below */
693		data[7] = addr + 1;
	800	// start at the word after because we predecrement below
	801	data7 = addr + 1;
694	802	for (x = xpos; ((xpos - x) & 0x1ff) != 1; )
695	803	{
696		UINT16 pixels = spritedata[--data[7]];
	804	UINT16 pixels = spritedata[--data7 & 0x7fff];
697	805
698		/* draw four pixels */
699		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
700		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
701		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
702		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { system16b_draw_pixel(); x += xdelta; }
	806	// draw four pixels
	807	int pix;
	808	pix = (pixels >>  0) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	809	pix = (pixels >>  4) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	810	pix = (pixels >>  8) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
	811	pix = (pixels >> 12) & 0xf; if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta;
703	812
704		/* stop if the last pixel in the group was 0xf */
	813	// stop if the last pixel in the group was 0xf
705	814	if (pix == 15)
706	815	break;
707	816	}
708	817	}
	818
	819	// update bounds
	820	if (x > maxx) maxx = x;
	821	if (x < minx) minx = x;
	822	if (miny == -1) miny = y;
	823	maxy = y;
709	824	}
	825
	826	// advance a row - must be done at the end on the bootlegs!
	827	addr += pitch;
710	828	}
	829
	830	// mark dirty
	831	if (miny != -1)
	832	mark_dirty(minx, maxx, miny, maxy);
711	833	}
712	834	}
713	835
714	836
715		/*******************************************************************************************
716		*
717		*  The Y-board variant has different mixing properties. The sprite implementation itself
718		*  is identical, however.
719		*
720		*******************************************************************************************/
721	837
722		#define yboard_16b_draw_pixel()                                  \
723		/* only draw if onscreen, not 0 or 15 */                        \
724		if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) \
725		{                                                      \
726		/* are we high enough priority to be visible? */               \
727		if ((sprpri & 0x1f) < (pri[x] & 0x1f))                        \
728		{                                                   \
729		/* shadow/hilight mode? */                              \
730		if (pix == 14)                                       \
731		dest[x] += (segaic16_paletteram[dest[x]] & 0x8000) ? segaic16_palette.entries*2 : segaic16_palette.entries;   \
732		\
733		/* regular draw */                                    \
734		else                                             \
735		dest[x] = pix | color;                              \
736		}                                                   \
737		\
738		/* always mark priority so no one else draws here */            \
739		pri[x] = 0;                                             \
740		}                                                      \
	838	//****************************************************************************
	839	//  SYSTEM 16B-STYLE SPRITES
	840	//****************************************************************************
741	841
742		void segaic16_sprites_yboard_16b_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	842	//-------------------------------------------------
	843	//  sega_sys16b_sprite_device -- constructor
	844	//-------------------------------------------------
	845
	846	sega_sys16b_sprite_device::sega_sys16b_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	847	: sega_16bit_sprite_device(mconfig, SEGA_SYS16B_SPRITES, "Sega System 16B Sprites", tag, owner)
743	848	{
744		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x20000;
745		const UINT16 *spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
746		sega16sp_state *sega16sp = get_safe_token(device);
747		UINT16* data = sega16sp->spriteram;
	849	set_origin(184, 0x00);
	850	}
	851
748	852
749		/* first scan forward to find the end of the list */
750		for (data = sega16sp->spriteram; data < sega16sp->spriteram + sega16sp->ramsize/2; data += 8)
	853	//-------------------------------------------------
	854	//  draw -- render the sprites within the cliprect
	855	//-------------------------------------------------
	856
	857	void sega_sys16b_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
	858	{
	859	//
	860	//   System 16B-style sprites
	861	//
	862	//      Offs  Bits               Usage
	863	//       +0   bbbbbbbb --------  Bottom scanline of sprite - 1
	864	//       +0   -------- tttttttt  Top scanline of sprite - 1
	865	//       +2   -------x xxxxxxxx  X position of sprite (position $BD is screen position 0)
	866	//       +2   ---iiii- --------  Sprite/sprite priority for Y-board
	867	//       +4   e------- --------  Signify end of sprite list
	868	//       +4   -h------ --------  Hide this sprite
	869	//       +4   -------f --------  Horizontal flip: read the data backwards if set
	870	//       +4   -------- pppppppp  Signed 8-bit pitch value between scanlines
	871	//       +6   oooooooo oooooooo  Offset within selected sprite bank
	872	//       +8   ----bbbb --------  Sprite bank
	873	//       +8   -------- pp------  Sprite priority, relative to tilemaps
	874	//       +8   -------- --cccccc  Sprite color palette
	875	//       +A   ------vv vvv-----  Vertical zoom factor (0 = full size, 0x10 = half size)
	876	//       +A   -------- ---hhhhh  Horizontal zoom factor (0 = full size, 0x10 = half size)
	877	//       +E   dddddddd dddddddd  Scratch space for current address
	878	//
	879	//    Final bitmap format:
	880	//
	881	//             iiii---- --------  Sprite/sprite priority for Y-board
	882	//             ----pp-- --------  Sprite priority
	883	//             ------cc cccc----  Sprite color palette
	884	//             -------- ----llll  4-bit pixel data
	885	//
	886	//   Note that the zooming described below is 100% accurate to the real board.
	887	//
	888
	889	// render the sprites in order
	890	const UINT16 *spritebase = reinterpret_cast<const UINT16 *>(region()->base());
	891	UINT8 numbanks = region()->bytes() / 0x20000;
	892	UINT16 *ramend = spriteram() + spriteram_elements();
	893	for (UINT16 *data = spriteram(); data < ramend; data += 8)
	894	{
	895	// stop when we hit the end of sprite list
751	896	if (data[2] & 0x8000)
752	897	break;
753	898
754		/* now scan backwards and render the sprites in order */
755		for (data -= 8; data >= sega16sp->spriteram; data -= 8)
756		{
	899	// extract parameters
757	900	int bottom  = data[0] >> 8;
758	901	int top     = data[0] & 0xff;
759		int xpos    = (data[1] & 0x1ff) - 0xb8;
760		int sprpri  = (data[1] >> 8) & 0x1e;   // 0x00 = high, 0x7f = low -- 0x71 = ship in gforce, 0x31 = strike fighter logo
	902	int xpos    = data[1] & 0x1ff;
761	903	int hide    = data[2] & 0x4000;
762	904	int flip    = data[2] & 0x100;
763		int pitch   = (INT8)(data[2] & 0xff);
	905	int pitch   = INT8(data[2] & 0xff);
764	906	UINT16 addr = data[3];
765		int bank    = sega16sp->bank[(data[4] >> 8) & 0xf];
766		int color   = sega16sp->colorbase + ((data[4] & 0x7f) << 4);
	907	int bank    = m_bank[(data[4] >> 8) & 0xf];
	908	int colpri  = ((data[4] & 0xff) << 4) | (((data[1] >> 9) & 0xf) << 12);
767	909	int vzoom   = (data[5] >> 5) & 0x1f;
768	910	int hzoom   = data[5] & 0x1f;
769	911	const UINT16 *spritedata;
770		int x, y, pix, xdelta = 1;
771	912
772		/* initialize the end address to the start address */
	913	xpos &= 0x1ff;
	914
	915	// initialize the end address to the start address
773	916	data[7] = addr;
774	917
775		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
776		if (hide || (top >= bottom) || bank == 255)
	918	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
	919	if (hide || top >= bottom || bank == 255)
777	920	continue;
778	921
779		/* clamp to within the memory region size */
	922	// clamp to within the memory region size
780	923	if (numbanks)
781	924	bank %= numbanks;
782	925	spritedata = spritebase + 0x10000 * bank;
783	926
784		/* reset the yzoom counter */
	927	// reset the yzoom counter
785	928	data[5] &= 0x03ff;
786	929
787		/* adjust positions for screen flipping */
788		if (sega16sp->flip)
	930	// adjust positions for screen flipping
	931	int xdelta = 1;
	932	if (m_flip)
789	933	{
790	934	int temp = top;
791	935	top = 224 - bottom;
r17593	r17594
794	938	xdelta = -1;
795	939	}
796	940
797		/* loop from top to bottom */
798		for (y = top; y < bottom; y++)
	941	// loop from top to bottom
	942	int minx = xpos;
	943	int maxx = xpos;
	944	int miny = -1;
	945	int maxy = -1;
	946	for (int y = top; y < bottom; y++)
799	947	{
800		/* advance a row */
	948	// advance a row
801	949	addr += pitch;
802	950
803		/* accumulate zoom factors; if we carry into the high bit, skip an extra row */
	951	// accumulate zoom factors; if we carry into the high bit, skip an extra row
804	952	data[5] += vzoom << 10;
805	953	if (data[5] & 0x8000)
806	954	{
r17593	r17594
808	956	data[5] &= ~0x8000;
809	957	}
810	958
811		/* skip drawing if not within the cliprect */
	959	// skip drawing if not within the cliprect
812	960	if (y >= cliprect.min_y && y <= cliprect.max_y)
813	961	{
814		UINT16 *dest = &bitmap.pix16(y);
815		UINT8 *pri = &machine.priority_bitmap.pix8(y);
816		int xacc;
	962	UINT16 *dest = &bitmap.pix(y);
	963	int x;
817	964
818		/* compute the initial X zoom accumulator; this is verified on the real PCB */
819		xacc = 4 * hzoom;
	965	// compute the initial X zoom accumulator; this is verified on the real PCB
	966	int xacc = 4 * hzoom;
820	967
821		/* non-flipped case */
	968	// non-flipped case
822	969	if (!flip)
823	970	{
824		/* start at the word before because we preincrement below */
	971	// start at the word before because we preincrement below
825	972	data[7] = addr - 1;
826	973	for (x = xpos; ((xpos - x) & 0x1ff) != 1; )
827	974	{
828	975	UINT16 pixels = spritedata[++data[7]];
829	976
830		/* draw four pixels */
831		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
832		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
833		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
834		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
	977	// draw four pixels
	978	int pix;
	979	pix = (pixels >> 12) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
	980	pix = (pixels >>  8) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
	981	pix = (pixels >>  4) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
	982	pix = (pixels >>  0) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
835	983
836		/* stop if the last pixel in the group was 0xf */
	984	// stop if the last pixel in the group was 0xf
837	985	if (pix == 15)
838	986	break;
839	987	}
840	988	}
841	989
842		/* flipped case */
	990	// flipped case
843	991	else
844	992	{
845		/* start at the word after because we predecrement below */
	993	// start at the word after because we predecrement below
846	994	data[7] = addr + 1;
847	995	for (x = xpos; ((xpos - x) & 0x1ff) != 1; )
848	996	{
849	997	UINT16 pixels = spritedata[--data[7]];
850	998
851		/* draw four pixels */
852		pix = (pixels >>  0) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
853		pix = (pixels >>  4) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
854		pix = (pixels >>  8) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
855		pix = (pixels >> 12) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { yboard_16b_draw_pixel(); x += xdelta; }
	999	// draw four pixels
	1000	int pix;
	1001	pix = (pixels >>  0) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
	1002	pix = (pixels >>  4) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
	1003	pix = (pixels >>  8) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
	1004	pix = (pixels >> 12) & 0xf; xacc = (xacc & 0x3f) + hzoom; if (xacc < 0x40) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; }
856	1005
857		/* stop if the last pixel in the group was 0xf */
	1006	// stop if the last pixel in the group was 0xf
858	1007	if (pix == 15)
859	1008	break;
860	1009	}
861	1010	}
	1011
	1012	// update bounds
	1013	if (x > maxx) maxx = x;
	1014	if (x < minx) minx = x;
	1015	if (miny == -1) miny = y;
	1016	maxy = y;
862	1017	}
863	1018	}
	1019
	1020	// mark dirty
	1021	if (miny != -1)
	1022	mark_dirty(minx, maxx, miny, maxy);
864	1023	}
865	1024	}
866	1025
867	1026
868	1027
869		/*******************************************************************************************
870		*
871		*  Out Run/X-Board-style sprites
872		*
873		*      Offs  Bits               Usage
874		*       +0   e------- --------  Signify end of sprite list
875		*       +0   -h-h---- --------  Hide this sprite if either bit is set
876		*       +0   ----bbb- --------  Sprite bank
877		*       +0   -------t tttttttt  Top scanline of sprite + 256
878		*       +2   oooooooo oooooooo  Offset within selected sprite bank
879		*       +4   ppppppp- --------  Signed 7-bit pitch value between scanlines
880		*       +4   -------x xxxxxxxx  X position of sprite (position $BE is screen position 0)
881		*       +6   -s------ --------  Enable shadows
882		*       +6   --pp---- --------  Sprite priority, relative to tilemaps
883		*       +6   ------vv vvvvvvvv  Vertical zoom factor (0x200 = full size, 0x100 = half size, 0x300 = 2x size)
884		*       +8   y------- --------  Render from top-to-bottom (1) or bottom-to-top (0) on screen
885		*       +8   -f------ --------  Horizontal flip: read the data backwards if set
886		*       +8   --x----- --------  Render from left-to-right (1) or right-to-left (0) on screen
887		*       +8   ------hh hhhhhhhh  Horizontal zoom factor (0x200 = full size, 0x100 = half size, 0x300 = 2x size)
888		*       +E   dddddddd dddddddd  Scratch space for current address
889		*
890		*    Out Run only:
891		*       +A   hhhhhhhh --------  Height in scanlines - 1
892		*       +A   -------- -ccccccc  Sprite color palette
893		*
894		*    X-Board only:
895		*       +A   ----hhhh hhhhhhhh  Height in scanlines - 1
896		*       +C   -------- cccccccc  Sprite color palette
897		*
898		*******************************************************************************************/
	1028	//****************************************************************************
	1029	//  OUT RUN/X-BOARD-STYLE SPRITES
	1030	//****************************************************************************
899	1031
900		#define outrun_draw_pixel()                                     \
901		/* only draw if onscreen, not 0 or 15 */                        \
902		if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) \
903		{                                                      \
904		/* are we high enough priority to be visible? */               \
905		if (sprpri > pri[x])                                    \
906		{                                                   \
907		/* shadow/hilight mode? */                              \
908		if (shadow && pix == 0xa)                              \
909		dest[x] += (segaic16_paletteram[dest[x]] & 0x8000) ? segaic16_palette.entries*2 : segaic16_palette.entries;   \
910		\
911		/* regular draw */                                    \
912		else                                             \
913		dest[x] = pix | color;                              \
914		}                                                   \
915		\
916		/* always mark priority so no one else draws here */            \
917		pri[x] = 0xff;                                          \
918		}                                                      \
	1032	//-------------------------------------------------
	1033	//  sega_outrun_sprite_device -- constructor
	1034	//-------------------------------------------------
919	1035
920		static void segaic16_sprites_xboard_outrun_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect, int type)
	1036	sega_outrun_sprite_device::sega_outrun_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	1037	: sega_16bit_sprite_device(mconfig, SEGA_OUTRUN_SPRITES, "Sega Out Run Sprites", tag, owner),
	1038	m_is_xboard(false)
921	1039	{
922		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x40000;
923		const UINT32 *spritebase = (const UINT32 *)machine.root_device().memregion("gfx2")->base();
924		sega16sp_state *sega16sp = get_safe_token(device);
925		UINT16* data = sega16sp->spriteram;
	1040	set_origin(190, 0x00);
	1041	}
926	1042
927		/* first scan forward to find the end of the list */
928		for (data = sega16sp->buffer; data < sega16sp->buffer + sega16sp->ramsize/2; data += 8)
	1043	sega_outrun_sprite_device::sega_outrun_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, bool xboard_variant)
	1044	: sega_16bit_sprite_device(mconfig, SEGA_XBOARD_SPRITES, "Sega X-Board Sprites", tag, owner),
	1045	m_is_xboard(true)
	1046	{
	1047	set_origin(190, 0x00);
	1048	}
	1049
	1050
	1051	//-------------------------------------------------
	1052	//  sega_xboard_sprite_device -- constructor
	1053	//-------------------------------------------------
	1054
	1055	sega_xboard_sprite_device::sega_xboard_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	1056	: sega_outrun_sprite_device(mconfig, tag, owner, clock, true)
	1057	{
	1058	}
	1059
	1060
	1061	//-------------------------------------------------
	1062	//  draw -- render the sprites within the cliprect
	1063	//-------------------------------------------------
	1064
	1065	void sega_outrun_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
	1066	{
	1067	//
	1068	//   Out Run/X-Board-style sprites
	1069	//
	1070	//      Offs  Bits               Usage
	1071	//       +0   e------- --------  Signify end of sprite list
	1072	//       +0   -h-h---- --------  Hide this sprite if either bit is set
	1073	//       +0   ----bbb- --------  Sprite bank
	1074	//       +0   -------t tttttttt  Top scanline of sprite + 256
	1075	//       +2   oooooooo oooooooo  Offset within selected sprite bank
	1076	//       +4   ppppppp- --------  Signed 7-bit pitch value between scanlines
	1077	//       +4   -------x xxxxxxxx  X position of sprite (position $BE is screen position 0)
	1078	//       +6   -s------ --------  Enable shadows
	1079	//       +6   --pp---- --------  Sprite priority, relative to tilemaps
	1080	//       +6   ------vv vvvvvvvv  Vertical zoom factor (0x200 = full size, 0x100 = half size, 0x300 = 2x size)
	1081	//       +8   y------- --------  Render from top-to-bottom (1) or bottom-to-top (0) on screen
	1082	//       +8   -f------ --------  Horizontal flip: read the data backwards if set
	1083	//       +8   --x----- --------  Render from left-to-right (1) or right-to-left (0) on screen
	1084	//       +8   ------hh hhhhhhhh  Horizontal zoom factor (0x200 = full size, 0x100 = half size, 0x300 = 2x size)
	1085	//       +E   dddddddd dddddddd  Scratch space for current address
	1086	//
	1087	//   Out Run only:
	1088	//       +A   hhhhhhhh --------  Height in scanlines - 1
	1089	//       +A   -------- -ccccccc  Sprite color palette
	1090	//
	1091	//  X-Board only:
	1092	//       +A   ----hhhh hhhhhhhh  Height in scanlines - 1
	1093	//       +C   -------- cccccccc  Sprite color palette
	1094	//
	1095	//    Final bitmap format:
	1096	//
	1097	//             -s------ --------  Shadow control
	1098	//             --pp---- --------  Sprite priority
	1099	//             ----cccc cccc----  Sprite color palette
	1100	//             -------- ----llll  4-bit pixel data
	1101	//
	1102
	1103	// render the sprites in order
	1104	const UINT32 *spritebase = reinterpret_cast<const UINT32 *>(region()->base());
	1105	UINT8 numbanks = region()->bytes() / 0x40000;
	1106	UINT16 *ramend = buffer() + spriteram_elements();
	1107	for (UINT16 *data = buffer(); data < ramend; data += 8)
	1108	{
	1109	// stop when we hit the end of sprite list
929	1110	if (data[0] & 0x8000)
930	1111	break;
931	1112
932		/* now scan backwards and render the sprites in order */
933		for (data -= 8; data >= sega16sp->buffer; data -= 8)
934		{
	1113	// extract parameters
935	1114	int hide    = (data[0] & 0x5000);
936	1115	int bank    = (data[0] >> 9) & 7;
937	1116	int top     = (data[0] & 0x1ff) - 0x100;
938	1117	UINT16 addr = data[1];
939		int pitch   = (INT16)((data[2] >> 1) | ((data[4] & 0x1000) << 3)) >> 8;
	1118	int pitch   = INT16((data[2] >> 1) | ((data[4] & 0x1000) << 3)) >> 8;
940	1119	int xpos    = data[2] & 0x1ff;
941		int shadow  = (data[3] >> 14) & 1;
942		int sprpri  = 1 << ((data[3] >> 12) & 3);
943	1120	int vzoom   = data[3] & 0x7ff;
944	1121	int ydelta  = (data[4] & 0x8000) ? 1 : -1;
945	1122	int flip    = (~data[4] >> 14) & 1;
946	1123	int xdelta  = (data[4] & 0x2000) ? 1 : -1;
947	1124	int hzoom   = data[4] & 0x7ff;
948		int height  = ((type == SEGAIC16_SPRITES_OUTRUN) ? (data[5] >> 8) : (data[5] & 0xfff)) + 1;
949		int color   = sega16sp->colorbase + (((type == SEGAIC16_SPRITES_OUTRUN) ? (data[5] & 0x7f) : (data[6] & 0xff)) << 4);
950		int x, y, ytarget, yacc = 0, pix;
951		const UINT32 *spritedata;
	1125	int height  = (m_is_xboard ? (data[5] & 0xfff) : (data[5] >> 8)) + 1;
	1126	int colpri  = ((m_is_xboard ? (data[6] & 0xff) : (data[5] & 0x7f)) << 4) | (((data[3] >> 12) & 7) << 12);
952	1127
953		/* adjust X coordinate */
954		/* note: the threshhold below is a guess. If it is too high, rachero will draw garbage */
955		/* If it is too low, smgp won't draw the bottom part of the road */
	1128	// adjust X coordinate
	1129	// note: the threshhold below is a guess. If it is too high, rachero will draw garbage
	1130	// If it is too low, smgp won't draw the bottom part of the road
956	1131	if (xpos < 0x80 && xdelta < 0)
957	1132	xpos += 0x200;
958		xpos -= 0xbe;
959	1133
960		/* initialize the end address to the start address */
	1134	// initialize the end address to the start address
961	1135	data[7] = addr;
962	1136
963		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
	1137	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
964	1138	if (hide || height == 0)
965	1139	continue;
966	1140
967		/* clamp to within the memory region size */
	1141	// clamp to within the memory region size
968	1142	if (numbanks)
969	1143	bank %= numbanks;
970		spritedata = spritebase + 0x10000 * bank;
	1144	const UINT32 *spritedata = spritebase + 0x10000 * bank;
971	1145
972		/* clamp to a maximum of 8x (not 100% confirmed) */
	1146	// clamp to a maximum of 8x (not 100% confirmed)
973	1147	if (vzoom < 0x40) vzoom = 0x40;
974	1148	if (hzoom < 0x40) hzoom = 0x40;
975	1149
976		/* loop from top to bottom */
977		ytarget = top + ydelta * height;
978		for (y = top; y != ytarget; y += ydelta)
	1150	// loop from top to bottom
	1151	int minx = xpos;
	1152	int maxx = xpos;
	1153	int miny = -1;
	1154	int maxy = -1;
	1155	int yacc = 0;
	1156	int ytarget = top + ydelta * height;
	1157	for (int y = top; y != ytarget; y += ydelta)
979	1158	{
980		/* skip drawing if not within the cliprect */
	1159	// skip drawing if not within the cliprect
981	1160	if (y >= cliprect.min_y && y <= cliprect.max_y)
982	1161	{
983		UINT16 *dest = &bitmap.pix16(y);
984		UINT8 *pri = &machine.priority_bitmap.pix8(y);
	1162	UINT16 *dest = &bitmap.pix(y);
985	1163	int xacc = 0;
	1164	int x;
986	1165
987		/* non-flipped case */
	1166	// non-flipped case
988	1167	if (!flip)
989	1168	{
990		/* start at the word before because we preincrement below */
	1169	// start at the word before because we preincrement below
991	1170	data[7] = addr - 1;
992	1171	for (x = xpos; (xdelta > 0 && x <= cliprect.max_x) || (xdelta < 0 && x >= cliprect.min_x); )
993	1172	{
994	1173	UINT32 pixels = spritedata[++data[7]];
995	1174
996		/* draw four pixels */
997		pix = (pixels >> 28) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
998		pix = (pixels >> 24) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
999		pix = (pixels >> 20) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1000		pix = (pixels >> 16) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1001		pix = (pixels >> 12) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1002		pix = (pixels >>  8) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1003		pix = (pixels >>  4) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1004		pix = (pixels >>  0) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1175	// draw four pixels
	1176	int pix;
	1177	pix = (pixels >> 28) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1178	pix = (pixels >> 24) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1179	pix = (pixels >> 20) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1180	pix = (pixels >> 16) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1181	pix = (pixels >> 12) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1182	pix = (pixels >>  8) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1183	pix = (pixels >>  4) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1184	pix = (pixels >>  0) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
1005	1185
1006		/* stop if the second-to-last pixel in the group was 0xf */
	1186	// stop if the second-to-last pixel in the group was 0xf
1007	1187	if ((pixels & 0x000000f0) == 0x000000f0)
1008	1188	break;
1009	1189	}
1010	1190	}
1011	1191
1012		/* flipped case */
	1192	// flipped case
1013	1193	else
1014	1194	{
1015		/* start at the word after because we predecrement below */
	1195	// start at the word after because we predecrement below
1016	1196	data[7] = addr + 1;
1017	1197	for (x = xpos; (xdelta > 0 && x <= cliprect.max_x) || (xdelta < 0 && x >= cliprect.min_x); )
1018	1198	{
1019	1199	UINT32 pixels = spritedata[--data[7]];
1020	1200
1021		/* draw four pixels */
1022		pix = (pixels >>  0) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1023		pix = (pixels >>  4) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1024		pix = (pixels >>  8) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1025		pix = (pixels >> 12) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1026		pix = (pixels >> 16) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1027		pix = (pixels >> 20) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1028		pix = (pixels >> 24) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
1029		pix = (pixels >> 28) & 0xf; while (xacc < 0x200) { outrun_draw_pixel(); x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1201	// draw four pixels
	1202	int pix;
	1203	pix = (pixels >>  0) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1204	pix = (pixels >>  4) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1205	pix = (pixels >>  8) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1206	pix = (pixels >> 12) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1207	pix = (pixels >> 16) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1208	pix = (pixels >> 20) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1209	pix = (pixels >> 24) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
	1210	pix = (pixels >> 28) & 0xf; while (xacc < 0x200) { if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) dest[x] = colpri | pix; x += xdelta; xacc += hzoom; } xacc -= 0x200;
1030	1211
1031		/* stop if the second-to-last pixel in the group was 0xf */
	1212	// stop if the second-to-last pixel in the group was 0xf
1032	1213	if ((pixels & 0x0f000000) == 0x0f000000)
1033	1214	break;
1034	1215	}
1035	1216	}
	1217
	1218	// update bounds
	1219	if (x > maxx) maxx = x;
	1220	if (x < minx) minx = x;
	1221	if (miny == -1) miny = y;
	1222	maxy = y;
1036	1223	}
1037	1224
1038		/* accumulate zoom factors; if we carry into the high bit, skip an extra row */
	1225	// accumulate zoom factors; if we carry into the high bit, skip an extra row
1039	1226	yacc += vzoom;
1040	1227	addr += pitch * (yacc >> 9);
1041	1228	yacc &= 0x1ff;
1042	1229	}
	1230
	1231	// mark dirty
	1232	if (miny != -1)
	1233	mark_dirty(minx, maxx, miny, maxy);
1043	1234	}
1044	1235	}
1045	1236
1046		void segaic16_sprites_outrun_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
1047		{
1048		segaic16_sprites_xboard_outrun_draw(machine, device, bitmap, cliprect, SEGAIC16_SPRITES_OUTRUN);
1049		}
1050	1237
1051		void segaic16_sprites_xboard_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1238
	1239	//****************************************************************************
	1240	//  Y BOARD-STYLE SPRITES
	1241	//****************************************************************************
	1242
	1243	//-------------------------------------------------
	1244	//  sega_yboard_sprite_device -- constructor
	1245	//-------------------------------------------------
	1246
	1247	sega_yboard_sprite_device::sega_yboard_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	1248	: sega_16bit_sprite_device(mconfig, SEGA_YBOARD_SPRITES, "Sega Y-Board Sprites", tag, owner)
1052	1249	{
1053		segaic16_sprites_xboard_outrun_draw(machine, device, bitmap, cliprect, SEGAIC16_SPRITES_XBOARD);
	1250	set_origin(0x600, 0x600);
1054	1251	}
1055	1252
1056	1253
1057		/*******************************************************************************************
1058		*
1059		*  Y-Board-style sprites
1060		*
1061		*      Offs  Bits               Usage
1062		*       +0   e------- --------  Signify end of sprite list
1063		*       +0   -----iii iiiiiiii  Address of indirection table (/16)
1064		*       +2   bbbb---- --------  Upper 4 bits of bank index
1065		*       +2   ----xxxx xxxxxxxx  X position of sprite (position $600 is screen position 0)
1066		*       +4   bbbb---- --------  Lower 4 bits of bank index
1067		*       +4   ----yyyy yyyyyyyy  Y position of sprite (position $600 is screen position 0)
1068		*       +6   oooooooo oooooooo  Offset within selected sprite bank
1069		*       +8   hhhhhhhh hhhhhhhh  Height of sprite
1070		*       +A   -y------ --------  Render from top-to-bottom (1) or bottom-to-top (0) on screen
1071		*       +A   --f----- --------  Horizontal flip: read the data backwards if set
1072		*       +A   ---x---- --------  Render from left-to-right (1) or right-to-left (0) on screen
1073		*       +A   -----zzz zzzzzzzz  Zoom factor
1074		*       +C   -ccc---- --------  Sprite color
1075		*       +C   ----rrrr --------  Sprite priority
1076		*       +C   -------- pppppppp  Signed 8-bit pitch value between scanlines
1077		*       +E   ----nnnn nnnnnnnn  Index of next sprite
1078		*
1079		*  In addition to these parameters, the sprite area is clipped using scanline extents
1080		*  stored for every pair of scanlines in the rotation RAM. It's a bit of a cheat for us
1081		*  to poke our nose into the rotation structure, but there are no known cases of Y-board
1082		*  sprites without rotation RAM.
1083		*
1084		*******************************************************************************************/
	1254	//-------------------------------------------------
	1255	//  draw -- render the sprites within the cliprect
	1256	//-------------------------------------------------
1085	1257
1086		#define yboard_draw_pixel()                                     \
1087		/* only draw if onscreen */                                    \
1088		if (x >= minx && x <= maxx && ind < 0x1fe)                        \
1089		dest[x] = ind | colorpri;                                 \
1090
1091		void segaic16_sprites_yboard_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
	1258	void sega_yboard_sprite_device::draw(bitmap_ind16 &bitmap, const rectangle &cliprect)
1092	1259	{
1093		UINT8 numbanks = machine.root_device().memregion("gfx1")->bytes() / 0x80000;
1094		const UINT64 *spritebase = (const UINT64 *)machine.root_device().memregion("gfx1")->base();
	1260	//
	1261	//   Y-Board-style sprites
	1262	//
	1263	//      Offs  Bits               Usage
	1264	//       +0   e------- --------  Signify end of sprite list
	1265	//       +0   -----iii iiiiiiii  Address of indirection table (/16)
	1266	//       +2   bbbb---- --------  Upper 4 bits of bank index
	1267	//       +2   ----xxxx xxxxxxxx  X position of sprite (position $600 is screen position 0)
	1268	//       +4   bbbb---- --------  Lower 4 bits of bank index
	1269	//       +4   ----yyyy yyyyyyyy  Y position of sprite (position $600 is screen position 0)
	1270	//       +6   oooooooo oooooooo  Offset within selected sprite bank
	1271	//       +8   hhhhhhhh hhhhhhhh  Height of sprite
	1272	//       +A   -y------ --------  Render from top-to-bottom (1) or bottom-to-top (0) on screen
	1273	//       +A   --f----- --------  Horizontal flip: read the data backwards if set
	1274	//       +A   ---x---- --------  Render from left-to-right (1) or right-to-left (0) on screen
	1275	//       +A   -----zzz zzzzzzzz  Zoom factor
	1276	//       +C   -ccc---- --------  Sprite color
	1277	//       +C   ----rrrr --------  Sprite priority
	1278	//       +C   -------- pppppppp  Signed 8-bit pitch value between scanlines
	1279	//       +E   ----nnnn nnnnnnnn  Index of next sprite
	1280	//
	1281	//    Final bitmap format:
	1282	//
	1283	//             ccc----- --------  Sprite color
	1284	//             ---rrrr- --------  Sprite priority
	1285	//             -------i iiiiiiii  Indirected color data
	1286	//
	1287	//   In addition to these parameters, the sprite area is clipped using scanline extents
	1288	//   stored for every pair of scanlines in the rotation RAM. It's a bit of a cheat for us
	1289	//   to poke our nose into the rotation structure, but there are no known cases of Y-board
	1290	//   sprites without rotation RAM.
	1291	//
	1292
	1293	// clear out any scanlines we might be using
1095	1294	const UINT16 *rotatebase = segaic16_rotate[0].buffer ? segaic16_rotate[0].buffer : segaic16_rotate[0].rotateram;
1096		UINT8 visited[0x1000];
1097		sega16sp_state *sega16sp = get_safe_token(device);
1098		int next = 0;
1099		int y;
1100		UINT16* data = sega16sp->spriteram;
	1295	rotatebase -= yorigin();
	1296	for (int y = cliprect.min_y; y <= cliprect.max_y; y++)
	1297	if (!(rotatebase[y & ~1] & 0xc000))
	1298	memset(&bitmap.pix(y, cliprect.min_x), 0xff, cliprect.width() * sizeof(UINT16));
1101	1299
1102		/* reset the visited list */
	1300	// reset the visited list
	1301	UINT8 visited[0x1000];
1103	1302	memset(visited, 0, sizeof(visited));
1104	1303
1105		/* clear out any scanlines we might be using */
1106		for (y = cliprect.min_y; y <= cliprect.max_y; y++)
1107		if (!(rotatebase[y & ~1] & 0xc000))
1108		memset(&bitmap.pix16(y, cliprect.min_x), 0xff, cliprect.width() * sizeof(UINT16));
1109
1110		/* now scan backwards and render the sprites in order */
1111		for (data = sega16sp->spriteram; !(data[0] & 0x8000) && !visited[next]; data = sega16sp->spriteram + next * 8)
	1304	// render the sprites in order
	1305	const UINT64 *spritebase = reinterpret_cast<const UINT64 *>(region()->base());
	1306	UINT8 numbanks = region()->bytes() / 0x80000;
	1307	int next = 0;
	1308	for (UINT16 *data = spriteram(); !(data[0] & 0x8000) && !visited[next]; data = spriteram() + next * 8)
1112	1309	{
1113	1310	int hide    = (data[0] & 0x5000);
1114		UINT16 *indirect = sega16sp->spriteram + ((data[0] & 0x7ff) << 4);
	1311	const UINT16 *indirect = spriteram() + ((data[0] & 0x7ff) << 4);
1115	1312	int bank    = ((data[1] >> 8) & 0x10) | ((data[2] >> 12) & 0x0f);
1116		int xpos    = (data[1] & 0xfff) - 0x600;
1117		int top     = (data[2] & 0xfff) - 0x600;
	1313	int xpos    = data[1] & 0xfff;
	1314	int top     = data[2] & 0xfff;
1118	1315	UINT16 addr = data[3];
1119	1316	int height  = data[4];
1120	1317	int ydelta  = (data[5] & 0x4000) ? 1 : -1;
1121	1318	int flip    = (~data[5] >> 13) & 1;
1122	1319	int xdelta  = (data[5] & 0x1000) ? 1 : -1;
1123	1320	int zoom    = data[5] & 0x7ff;
1124		int colorpri= (data[6] << 1) & 0xfe00;
1125		int pitch   = (INT8)data[6];
1126		int x, y, ytarget, yacc = 0, pix, ind;
1127		const UINT64 *spritedata;
1128		UINT16 offs;
	1321	int colpri  = (data[6] << 1) & 0xfe00;
	1322	int pitch   = INT8(data[6]);
1129	1323
1130		/* note that we've visited this entry and get the offset of the next one */
	1324	// note that we've visited this entry and get the offset of the next one
1131	1325	visited[next] = 1;
1132	1326	next = data[7] & 0xfff;
1133	1327
1134		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */
	1328	// if hidden, or top greater than/equal to bottom, or invalid bank, punt
1135	1329	if (hide || height == 0)
1136	1330	continue;
1137	1331
1138		/* clamp to within the memory region size */
	1332	// clamp to within the memory region size
1139	1333	if (numbanks)
1140	1334	bank %= numbanks;
1141		spritedata = spritebase + 0x10000 * bank;
	1335	const UINT64 *spritedata = spritebase + 0x10000 * bank;
1142	1336
1143		/* clamp to a maximum of 8x (not 100% confirmed) */
	1337	// clamp to a maximum of 8x (not 100% confirmed)
1144	1338	if (zoom == 0) zoom = 1;
1145	1339
1146		/* loop from top to bottom */
1147		ytarget = top + ydelta * height;
1148		for (y = top; y != ytarget; y += ydelta)
	1340	// loop from top to bottom
	1341	int dminx = xpos;
	1342	int dmaxx = xpos;
	1343	int dminy = -1;
	1344	int dmaxy = -1;
	1345	int ytarget = top + ydelta * height;
	1346	int yacc = 0;
	1347	for (int y = top; y != ytarget; y += ydelta)
1149	1348	{
1150		/* skip drawing if not within the cliprect */
	1349	// skip drawing if not within the cliprect
1151	1350	if (y >= cliprect.min_y && y <= cliprect.max_y)
1152	1351	{
1153		UINT16 *dest = &bitmap.pix16(y);
	1352	UINT16 *dest = &bitmap.pix(y);
1154	1353	int minx = rotatebase[y & ~1];
1155	1354	int maxx = rotatebase[y |  1];
1156	1355	int xacc = 0;
1157	1356
1158		/* bit 0x8000 from rotate RAM means that Y is above the top of the screen */
	1357	// bit 0x8000 from rotate RAM means that Y is above the top of the screen
1159	1358	if ((minx & 0x8000) && ydelta < 0)
1160	1359	break;
1161	1360
1162		/* bit 0x4000 from rotate RAM means that Y is below the bottom of the screen */
	1361	// bit 0x4000 from rotate RAM means that Y is below the bottom of the screen
1163	1362	if ((minx & 0x4000) && ydelta > 0)
1164	1363	break;
1165	1364
1166		/* if either bit is set, skip the rest for this scanline */
	1365	// if either bit is set, skip the rest for this scanline
1167	1366	if (!(minx & 0xc000))
1168	1367	{
1169		/* clamp min/max to the cliprect */
1170		minx -= 0x600;
1171		maxx -= 0x600;
	1368	// clamp min/max to the cliprect
1172	1369	if (minx < cliprect.min_x)
1173	1370	minx = cliprect.min_x;
1174	1371	if (maxx > cliprect.max_x)
1175	1372	maxx = cliprect.max_x;
1176	1373
1177		/* non-flipped case */
	1374	// non-flipped case
	1375	int x;
1178	1376	if (!flip)
1179	1377	{
1180		/* start at the word before because we preincrement below */
1181		offs = addr - 1;
	1378	// start at the word before because we preincrement below
	1379	UINT16 offs = addr - 1;
1182	1380	for (x = xpos; (xdelta > 0 && x <= maxx) || (xdelta < 0 && x >= minx); )
1183	1381	{
1184	1382	UINT64 pixels = spritedata[++offs];
1185	1383
1186		/* draw four pixels */
1187		pix = (pixels >> 60) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1188		pix = (pixels >> 56) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1189		pix = (pixels >> 52) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1190		pix = (pixels >> 48) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1191		pix = (pixels >> 44) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1192		pix = (pixels >> 40) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1193		pix = (pixels >> 36) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1194		pix = (pixels >> 32) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1195		pix = (pixels >> 28) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1196		pix = (pixels >> 24) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1197		pix = (pixels >> 20) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1198		pix = (pixels >> 16) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1199		pix = (pixels >> 12) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1200		pix = (pixels >>  8) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1201		pix = (pixels >>  4) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1202		pix = (pixels >>  0) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
	1384	// draw 16 pixels
	1385	int pix, ind;
	1386	pix = (pixels >> 60) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1387	pix = (pixels >> 56) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1388	pix = (pixels >> 52) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1389	pix = (pixels >> 48) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1390	pix = (pixels >> 44) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1391	pix = (pixels >> 40) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1392	pix = (pixels >> 36) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1393	pix = (pixels >> 32) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1394	pix = (pixels >> 28) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1395	pix = (pixels >> 24) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1396	pix = (pixels >> 20) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1397	pix = (pixels >> 16) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1398	pix = (pixels >> 12) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1399	pix = (pixels >>  8) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1400	pix = (pixels >>  4) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1401	pix = (pixels >>  0) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
1203	1402
1204		/* stop if the second-to-last pixel in the group was 0xf */
	1403	// stop if the last pixel in the group was 0xf
1205	1404	if (pix == 0x0f)
1206	1405	break;
1207	1406	}
1208	1407	}
1209	1408
1210		/* flipped case */
	1409	// flipped case
1211	1410	else
1212	1411	{
1213		/* start at the word after because we predecrement below */
1214		offs = addr + 1;
	1412	// start at the word after because we predecrement below
	1413	UINT16 offs = addr + 1;
1215	1414	for (x = xpos; (xdelta > 0 && x <= maxx) || (xdelta < 0 && x >= minx); )
1216	1415	{
1217	1416	UINT64 pixels = spritedata[--offs];
1218	1417
1219		/* draw four pixels */
1220		pix = (pixels >>  0) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1221		pix = (pixels >>  4) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1222		pix = (pixels >>  8) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1223		pix = (pixels >> 12) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1224		pix = (pixels >> 16) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1225		pix = (pixels >> 20) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1226		pix = (pixels >> 24) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1227		pix = (pixels >> 28) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1228		pix = (pixels >> 32) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1229		pix = (pixels >> 36) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1230		pix = (pixels >> 40) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1231		pix = (pixels >> 44) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1232		pix = (pixels >> 48) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1233		pix = (pixels >> 52) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1234		pix = (pixels >> 56) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
1235		pix = (pixels >> 60) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { yboard_draw_pixel(); x += xdelta; xacc += zoom; } xacc -= 0x200;
	1418	// draw 16 pixels
	1419	int pix, ind;
	1420	pix = (pixels >>  0) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1421	pix = (pixels >>  4) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1422	pix = (pixels >>  8) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1423	pix = (pixels >> 12) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1424	pix = (pixels >> 16) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1425	pix = (pixels >> 20) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1426	pix = (pixels >> 24) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1427	pix = (pixels >> 28) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1428	pix = (pixels >> 32) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1429	pix = (pixels >> 36) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1430	pix = (pixels >> 40) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1431	pix = (pixels >> 44) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1432	pix = (pixels >> 48) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1433	pix = (pixels >> 52) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1434	pix = (pixels >> 56) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
	1435	pix = (pixels >> 60) & 0xf; ind = indirect[pix]; while (xacc < 0x200) { if (x >= minx && x <= maxx && ind < 0x1fe) dest[x] = colpri | ind; x += xdelta; xacc += zoom; } xacc -= 0x200;
1236	1436
1237		/* stop if the second-to-last pixel in the group was 0xf */
	1437	// stop if the last pixel in the group was 0xf
1238	1438	if (pix == 0x0f)
1239	1439	break;
1240	1440	}
1241	1441	}
	1442
	1443	// update bounds
	1444	if (x > dmaxx) dmaxx = x;
	1445	if (x < dminx) dminx = x;
	1446	if (dminy == -1) dminy = y;
	1447	dmaxy = y;
1242	1448	}
1243	1449	}
1244	1450
1245		/* accumulate zoom factors; if we carry into the high bit, skip an extra row */
	1451	// accumulate zoom factors; if we carry into the high bit, skip an extra row
1246	1452	yacc += zoom;
1247	1453	addr += pitch * (yacc >> 9);
1248	1454	yacc &= 0x1ff;
1249	1455	}
	1456
	1457	// mark dirty
	1458	if (dminy != -1)
	1459	mark_dirty(dminx, dmaxx, dminy, dmaxy);
1250	1460	}
1251	1461	}
1252
1253		/* bootlegs */
1254
1255		/*
1256
1257		the system16a bootleg sprite hardware differs in subtle ways on a per game basis
1258		with each game having the words swapped around.
1259
1260		there are also some subtle, but important changes when compared to the original
1261		system16a sprites, mainly the increment of the address not happening until
1262		the end of the loop
1263
1264		*/
1265
1266		/* ignores the sprite priority until we understand priority better on the bootlegs */
1267		#define system16a_bootleg_draw_pixel()                                    \
1268		/* only draw if onscreen, not 0 or 15 */                        \
1269		if (x >= cliprect.min_x && x <= cliprect.max_x && pix != 0 && pix != 15) \
1270		{                                                      \
1271		/* are we high enough priority to be visible? */               \
1272		if (sprpri || 1)                                    \
1273		{                                                   \
1274		/* shadow/hilight mode? */                              \
1275		if (color == sega16sp->colorbase + (0x3f << 4))                  \
1276		dest[x] += (segaic16_paletteram[dest[x]] & 0x8000) ? segaic16_palette.entries*2 : segaic16_palette.entries;   \
1277		\
1278		/* regular draw */                                    \
1279		else                                             \
1280		dest[x] = pix | color;                              \
1281		}                                                   \
1282		\
1283		/* always mark priority so no one else draws here */            \
1284		pri[x] = 0xff;                                          \
1285		}                                                      \
1286
1287
1288		/* make this an actual function */
1289		#define system16a_bootleg_draw_core()                                       \
1290		{                                                               \
1291		const UINT16 *spritedata;                                          \
1292		int x, y, pix, xdelta = 1;                                          \
1293		\
1294		xpos += sega16sp->xoffs;                                             \
1295		xpos &= 0x1ff;                                                   \
1296		\
1297		xpos -= 0xbd;                                                   \
1298		\
1299		/* initialize the end address to the start address */                     \
1300		data[7] = addr;                                                \
1301		\
1302		/* if hidden, or top greater than/equal to bottom, or invalid bank, punt */      \
1303		if ((top >= bottom) || bank == 255)                                    \
1304		continue;                                                   \
1305		\
1306		/* clamp to within the memory region size */                           \
1307		if (numbanks)                                                   \
1308		bank %= numbanks;                                             \
1309		spritedata = spritebase + 0x8000 * bank;                              \
1310		\
1311		/* adjust positions for screen flipping */                              \
1312		if (sega16sp->flip)                                                   \
1313		{                                                            \
1314		int temp = top;                                                \
1315		top = 224 - bottom;                                             \
1316		bottom = 224 - temp;                                          \
1317		xpos = 320 - xpos;                                             \
1318		xdelta = -1;                                                \
1319		}                                                            \
1320		\
1321		/* loop from top to bottom */                                       \
1322		for (y = top; y < bottom; y++)                                       \
1323		{                                                            \
1324		\
1325		/* skip drawing if not within the cliprect */                        \
1326		if (y >= cliprect.min_y && y <= cliprect.max_y)                     \
1327		{                                                         \
1328		UINT16 *dest = &bitmap.pix16(y);                        \
1329		UINT8 *pri = &machine.priority_bitmap.pix8(y);                  \
1330		\
1331		/* note that the System 16A sprites have a design flaw that allows the address */      \
1332		/* to carry into the flip flag, which is the topmost bit -- it is very important */      \
1333		/* to emulate this as the games compensate for it */                           \
1334		\
1335		/* non-flipped case */                                                   \
1336		if (!(addr & 0x8000))                                                   \
1337		{                                                                  \
1338		/* start at the word before because we preincrement below */                  \
1339		data[7] = addr - 1;                                                \
1340		for (x = xpos; ((xpos - x) & 0x1ff) != 1; )                                 \
1341		{                                                               \
1342		UINT16 pixels = spritedata[++data[7] & 0x7fff];                           \
1343		\
1344		/* draw four pixels */                                             \
1345		pix = (pixels >> 12) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1346		pix = (pixels >>  8) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1347		pix = (pixels >>  4) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1348		pix = (pixels >>  0) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1349		\
1350		/* stop if the last pixel in the group was 0xf */                        \
1351		if (pix == 15)                                                   \
1352		break;                                                      \
1353		}                                                               \
1354		}                                                                  \
1355		\
1356		/* flipped case */                                                      \
1357		else                                                               \
1358		{                                                                  \
1359		/* start at the word after because we predecrement below */                     \
1360		data[7] = addr + 1;                                                   \
1361		for (x = xpos; ((xpos - x) & 0x1ff) != 1; )                                 \
1362		{                                                               \
1363		UINT16 pixels = spritedata[--data[7] & 0x7fff];                           \
1364		\
1365		/* draw four pixels */                                             \
1366		pix = (pixels >>  0) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1367		pix = (pixels >>  4) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1368		pix = (pixels >>  8) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1369		pix = (pixels >> 12) & 0xf; system16a_bootleg_draw_pixel(); x += xdelta;      \
1370		\
1371		/* stop if the last pixel in the group was 0xf */                        \
1372		if (pix == 15)                                                   \
1373		break;                                                      \
1374		}                                                               \
1375		}                                                                  \
1376		}                                                                     \
1377		\
1378		/* advance a row - must be done at the end on the bootlegs! */                        \
1379		addr += pitch;                                                            \
1380		}                                                                        \
1381		}                                                                           \
1382
1383
1384
1385		void segaic16_sprites_16a_bootleg_wb3bl_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
1386		{
1387		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x10000;
1388		const UINT16 *spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
1389		sega16sp_state *sega16sp = get_safe_token(device);
1390		UINT16* data = sega16sp->spriteram;
1391
1392		for (data = sega16sp->spriteram; data < sega16sp->spriteram+ sega16sp->ramsize/2; data += 8)
1393		{
1394		int bottom  = (data[4] >> 8);
1395		int top     = (data[4] & 0xff);
1396		int xpos    = (data[0]);
1397		int pitch   = (INT16)data[5];
1398		UINT16 addr = data[1];
1399		int color   = sega16sp->colorbase + (((data[6] >> 8) & 0x3f) << 4);
1400		int bank    = sega16sp->bank[(data[6] >> 4) & 0x7];
1401		int sprpri  = 1 << ((data[6] >> 0) & 0x3);
1402
1403		system16a_bootleg_draw_core();
1404		}
1405		}
1406
1407		/* 4 player passing shot is different to this.. */
1408		void segaic16_sprites_16a_bootleg_passhtb_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
1409		{
1410		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x10000;
1411		const UINT16 *spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
1412		sega16sp_state *sega16sp = get_safe_token(device);
1413		UINT16* data = sega16sp->spriteram;
1414
1415		for (data = sega16sp->spriteram; data < sega16sp->spriteram+ sega16sp->ramsize/2; data += 8)
1416		{
1417		int bottom  = (data[1] >> 8)-1;
1418		int top     = (data[1] & 0xff)-1;
1419		int xpos    = (data[0]);
1420		int pitch   = (INT16)data[3];
1421		UINT16 addr = data[2];
1422		int color   = sega16sp->colorbase + (((data[5] >> 8) & 0x3f) << 4);
1423		int bank    = sega16sp->bank[(data[5] >> 4) & 0x7];
1424		int sprpri  = 1 << ((data[5] >> 0) & 0x3);
1425
1426		system16a_bootleg_draw_core();
1427		}
1428		}
1429
1430		void segaic16_sprites_16a_bootleg_shinobld_draw(running_machine &machine, device_t *device, bitmap_ind16 &bitmap, const rectangle &cliprect)
1431		{
1432		UINT8 numbanks = machine.root_device().memregion("gfx2")->bytes() / 0x10000;
1433		const UINT16 *spritebase = (const UINT16 *)machine.root_device().memregion("gfx2")->base();
1434		sega16sp_state *sega16sp = get_safe_token(device);
1435		UINT16* data = sega16sp->spriteram;
1436
1437		for (data = sega16sp->spriteram; data < sega16sp->spriteram+ sega16sp->ramsize/2; data += 8)
1438		{
1439		int bottom  = (data[0] >> 8)-1;
1440		int top     = (data[0] & 0xff)-1;
1441		int xpos    = (data[1]);
1442		int pitch   = (INT16)data[2];
1443		UINT16 addr = data[3];
1444		int color   = sega16sp->colorbase + (((data[4] >> 8) & 0x3f) << 4);
1445		int bank    = sega16sp->bank[(data[4] >> 4) & 0x7];
1446		int sprpri  = 1 << ((data[4] >> 0) & 0x3);
1447
1448		system16a_bootleg_draw_core();
1449		}
1450		}
1451
1452		/*************************************
1453		*
1454		*  General sprite drawing
1455		*
1456		*************************************/
1457
1458		void segaic16_sprites_draw(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect, int which)
1459		{
1460		device_t* device = 0;
1461		sega16sp_state *sega16sp;
1462
1463		if (!which)
1464		device = screen.machine().device("segaspr1");
1465		else
1466		device = screen.machine().device("segaspr2");
1467
1468		if (!device)
1469		fatalerror("segaic16_sprites_draw device not found\n");
1470
1471		sega16sp = get_safe_token(device);
1472
1473		if (!sega16sp->which)
1474		sega16sp->spriteram = segaic16_spriteram_0;
1475		else
1476		sega16sp->spriteram = segaic16_spriteram_1;
1477
1478		(*sega16sp->draw)(screen.machine(), device, bitmap, cliprect);
1479		}
1480
1481
1482
1483		/*************************************
1484		*
1485		*  General sprite banking
1486		*
1487		*************************************/
1488
1489		void segaic16_sprites_set_bank(running_machine &machine, int which, int banknum, int offset)
1490		{
1491		device_t* device = 0;
1492
1493		if (!which)
1494		device = machine.device("segaspr1");
1495		else
1496		device = machine.device("segaspr2");
1497
1498		if (!device)
1499		fatalerror("segaic16_sprites_set_bank device not found\n");
1500
1501		sega16sp_state *sega16sp = get_safe_token(device);
1502
1503		if (sega16sp->bank[banknum] != offset)
1504		{
1505		screen_device &screen = *machine.primary_screen;
1506		screen.update_partial(screen.vpos());
1507		sega16sp->bank[banknum] = offset;
1508		}
1509		}
1510
1511
1512
1513		/*************************************
1514		*
1515		*  General sprite screen flipping
1516		*
1517		*************************************/
1518
1519		void segaic16_sprites_set_flip(running_machine &machine, int which, int flip)
1520		{
1521		device_t* device = 0;
1522
1523		if (!which)
1524		device = machine.device("segaspr1");
1525		else
1526		device = machine.device("segaspr2");
1527
1528		if (!device)
1529		fatalerror("segaic16_sprites_set_flip device not found\n");
1530
1531		sega16sp_state *sega16sp = get_safe_token(device);
1532
1533		flip = (flip != 0);
1534		if (sega16sp->flip != flip)
1535		{
1536		screen_device &screen = *machine.primary_screen;
1537		screen.update_partial(screen.vpos());
1538		sega16sp->flip = flip;
1539		}
1540		}
1541
1542
1543
1544		/*************************************
1545		*
1546		*  General sprite shadows
1547		*
1548		*************************************/
1549
1550		void segaic16_sprites_set_shadow(running_machine &machine, int which, int shadow)
1551		{
1552		device_t* device = 0;
1553
1554		if (!which)
1555		device = machine.device("segaspr1");
1556		else
1557		device = machine.device("segaspr2");
1558
1559		if (!device)
1560		fatalerror("segaic16_sprites_set_shadow device not found\n");
1561
1562		sega16sp_state *sega16sp = get_safe_token(device);
1563
1564		shadow = (shadow != 0);
1565		if (sega16sp->shadow != shadow)
1566		{
1567		screen_device &screen = *machine.primary_screen;
1568		screen.update_partial(screen.vpos());
1569		sega16sp->shadow = shadow;
1570		}
1571		}
1572
1573
1574
1575		/*************************************
1576		*
1577		*  General sprite buffer control
1578		*
1579		*************************************/
1580
1581		static void segaic16_sprites_buffer(device_t* device)
1582		{
1583		sega16sp_state *sega16sp = get_safe_token(device);
1584
1585		if (!sega16sp->which)
1586		sega16sp->spriteram = segaic16_spriteram_0;
1587		else
1588		sega16sp->spriteram = segaic16_spriteram_1;
1589
1590
1591		if (sega16sp->buffer)
1592		{
1593		UINT32 *src = (UINT32 *)sega16sp->spriteram;
1594		UINT32 *dst = (UINT32 *)sega16sp->buffer;
1595		int i;
1596
1597		/* swap the halves of the sprite RAM */
1598		for (i = 0; i < sega16sp->ramsize/4; i++)
1599		{
1600		UINT32 temp = *src;
1601		*src++ = *dst;
1602		*dst++ = temp;
1603		}
1604
1605		/* hack for thunderblade */
1606		*sega16sp->spriteram = 0xffff;
1607		}
1608
1609		/* we will render the sprites when the video update happens */
1610		}
1611
1612
1613		WRITE16_HANDLER( segaic16_sprites_draw_0_w )
1614		{
1615		device_t* device = 0;
1616
1617		device = space->machine().device("segaspr1");
1618
1619		if (!device)
1620		fatalerror("segaic16_sprites_draw_0_w device not found\n");
1621
1622		segaic16_sprites_buffer(device);
1623		}
1624
1625
1626		WRITE16_HANDLER( segaic16_sprites_draw_1_w )
1627		{
1628		device_t* device = 0;
1629
1630		device = space->machine().device("segaspr2");
1631
1632		if (!device)
1633		fatalerror("segaic16_sprites_draw_1_w device not found\n");
1634
1635		if (device)
1636		segaic16_sprites_buffer(device);
1637		}
1638
1639
1640		/*****************************************************************************
1641		DEVICE INTERFACE
1642		*****************************************************************************/
1643
1644		static DEVICE_START( sega16sp )
1645		{
1646		sega16sp_state *sega16sp = get_safe_token(device);
1647		const sega16sp_interface *intf = get_interface(device);
1648		int i;
1649
1650		sega16sp->flip = 0;
1651		sega16sp->shadow = 0;
1652
1653		for (i=0;i<16;i++)
1654		sega16sp->bank[i] = i;// intf->bank[i];
1655
1656		sega16sp->which = intf->which;
1657		sega16sp->colorbase = intf->colorbase;
1658		sega16sp->ramsize = intf->ramsize;
1659		sega16sp->xoffs = intf->xoffs;
1660		sega16sp->draw = intf->draw;
1661
1662		if (intf->buffer)
1663		sega16sp->buffer = auto_alloc_array(device->machine(), UINT16, sega16sp->ramsize/2);
1664
1665
1666		device->save_item(NAME(sega16sp->flip));
1667		device->save_item(NAME(sega16sp->shadow));
1668		device->save_item(NAME(sega16sp->bank));
1669		device->save_item(NAME(sega16sp->colorbase));
1670		device->save_item(NAME(sega16sp->xoffs));
1671
1672		if (intf->buffer)
1673		device->save_pointer(NAME(((UINT8 *) sega16sp->buffer)), sega16sp->ramsize);
1674
1675
1676		}
1677
1678
1679		DEVICE_GET_INFO( sega16sp )
1680		{
1681		switch (state)
1682		{
1683		/* --- the following bits of info are returned as 64-bit signed integers --- */
1684		case DEVINFO_INT_TOKEN_BYTES:         info->i = sizeof(sega16sp_state);               break;
1685
1686		/* --- the following bits of info are returned as pointers to data or functions --- */
1687		case DEVINFO_FCT_START:               info->start = DEVICE_START_NAME(sega16sp);      break;
1688		case DEVINFO_FCT_STOP:               /* Nothing */                           break;
1689		case DEVINFO_FCT_RESET:               /*info->reset = DEVICE_RESET_NAME(sega16sp);*/   break;
1690
1691		/* --- the following bits of info are returned as NULL-terminated strings --- */
1692		case DEVINFO_STR_NAME:               strcpy(info->s, "Sega System SH/HO/OR/16/18/X/Y Sprites");            break;
1693		case DEVINFO_STR_FAMILY:            strcpy(info->s, "Sega Video ICs");               break;
1694		case DEVINFO_STR_VERSION:            strcpy(info->s, "1.0");                     break;
1695		case DEVINFO_STR_SOURCE_FILE:         strcpy(info->s, __FILE__);                  break;
1696		case DEVINFO_STR_CREDITS:            strcpy(info->s, "Copyright MAME Team");         break;
1697		}
1698		}

trunk/src/mame/video/sega16sp.h

r0	r17594
	1	/***************************************************************************
	2
	3	Sega 16-bit sprite hardware
	4
	5	****************************************************************************
	6
	7	Copyright Aaron Giles
	8	All rights reserved.
	9
	10	Redistribution and use in source and binary forms, with or without
	11	modification, are permitted provided that the following conditions are
	12	met:
	13
	14	* Redistributions of source code must retain the above copyright
	15	notice, this list of conditions and the following disclaimer.
	16	* Redistributions in binary form must reproduce the above copyright
	17	notice, this list of conditions and the following disclaimer in
	18	the documentation and/or other materials provided with the
	19	distribution.
	20	* Neither the name 'MAME' nor the names of its contributors may be
	21	used to endorse or promote products derived from this software
	22	without specific prior written permission.
	23
	24	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	25	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	26	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	27	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	28	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	29	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	30	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	32	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	33	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	POSSIBILITY OF SUCH DAMAGE.
	35
	36	***************************************************************************/
	37
	38	#pragma once
	39
	40	#include "sprite.h"
	41
	42
	43	#ifndef __SEGA16SP_H__
	44	#define __SEGA16SP_H__
	45
	46
	47	//**************************************************************************
	48	//  INTERFACE CONFIGURATION MACROS
	49	//**************************************************************************
	50
	51	#define MCFG_SEGA_HANGON_SPRITES_ADD(_tag) \
	52	MCFG_DEVICE_ADD(_tag, SEGA_HANGON_SPRITES, 0) \
	53
	54	#define MCFG_SEGA_SHARRIER_SPRITES_ADD(_tag) \
	55	MCFG_DEVICE_ADD(_tag, SEGA_SHARRIER_SPRITES, 0) \
	56
	57	#define MCFG_SEGA_OUTRUN_SPRITES_ADD(_tag) \
	58	MCFG_DEVICE_ADD(_tag, SEGA_OUTRUN_SPRITES, 0) \
	59
	60	#define MCFG_SEGA_SYS16A_SPRITES_ADD(_tag) \
	61	MCFG_DEVICE_ADD(_tag, SEGA_SYS16A_SPRITES, 0) \
	62
	63	#define MCFG_SEGA_SYS16B_SPRITES_ADD(_tag) \
	64	MCFG_DEVICE_ADD(_tag, SEGA_SYS16B_SPRITES, 0) \
	65
	66	#define MCFG_SEGA_XBOARD_SPRITES_ADD(_tag) \
	67	MCFG_DEVICE_ADD(_tag, SEGA_XBOARD_SPRITES, 0) \
	68
	69	#define MCFG_SEGA_YBOARD_SPRITES_ADD(_tag) \
	70	MCFG_DEVICE_ADD(_tag, SEGA_YBOARD_SPRITES, 0) \
	71
	72
	73	#define MCFG_BOOTLEG_SYS16A_SPRITES_ADD(_tag) \
	74	MCFG_DEVICE_ADD(_tag, BOOTLEG_SYS16A_SPRITES, 0) \
	75
	76	#define MCFG_BOOTLEG_SYS16A_SPRITES_REMAP(_0,_1,_2,_3,_4,_5,_6,_7) \
	77	bootleg_sys16a_sprite_device::static_set_remap(*device, _0,_1,_2,_3,_4,_5,_6,_7);
	78
	79	#define MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(_xorigin) \
	80	bootleg_sys16a_sprite_device::static_set_xorigin(*device, _xorigin);
	81
	82	#define MCFG_BOOTLEG_SYS16A_SPRITES_YORIGIN(_yorigin) \
	83	bootleg_sys16a_sprite_device::static_set_yorigin(*device, _yorigin);
	84
	85
	86	#define MCFG_BOOTLEG_SYS16B_SPRITES_ADD(_tag) \
	87	MCFG_DEVICE_ADD(_tag, SEGA_SYS16B_SPRITES, 0) \
	88
	89	#define MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(_xorigin) \
	90	bootleg_sys16a_sprite_device::static_set_xorigin(*device, _xorigin);
	91
	92
	93
	94	//**************************************************************************
	95	//  TYPE DEFINITIONS
	96	//**************************************************************************
	97
	98
	99	// ======================> sega_16bit_sprite_device
	100
	101	class sega_16bit_sprite_device : public sprite16_device_ind16
	102	{
	103	protected:
	104	// construction/destruction
	105	sega_16bit_sprite_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner);
	106
	107	public:
	108	// live configuration
	109	void set_bank(int banknum, int offset) { m_bank[banknum] = offset; }
	110	void set_flip(bool flip) { m_flip = flip; }
	111
	112	// write trigger memory handler
	113	DECLARE_WRITE16_MEMBER( draw_write );
	114
	115	protected:
	116	// device-level overrides
	117	virtual void device_start();
	118
	119	// internal state
	120	bool                  m_flip;               // screen flip?
	121	UINT8                  m_bank[16];            // banking redirection
	122	};
	123
	124
	125	// ======================> sega_hangon_sprite_device
	126
	127	class sega_hangon_sprite_device : public sega_16bit_sprite_device
	128	{
	129	public:
	130	// construction/destruction
	131	sega_hangon_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	132
	133	protected:
	134	// subclass overrides
	135	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	136	};
	137
	138
	139	// ======================> sega_sharrier_sprite_device
	140
	141	class sega_sharrier_sprite_device : public sega_16bit_sprite_device
	142	{
	143	public:
	144	// construction/destruction
	145	sega_sharrier_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	146
	147	protected:
	148	// subclass overrides
	149	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	150	};
	151
	152
	153	// ======================> sega_outrun_sprite_device
	154
	155	class sega_outrun_sprite_device : public sega_16bit_sprite_device
	156	{
	157	public:
	158	// construction/destruction
	159	sega_outrun_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	160	protected:
	161	sega_outrun_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock, bool xboard_variant);
	162
	163	// subclass overrides
	164	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	165
	166	// configuration
	167	bool         m_is_xboard;
	168	};
	169
	170	class sega_xboard_sprite_device : public sega_outrun_sprite_device
	171	{
	172	public:
	173	// construction/destruction
	174	sega_xboard_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	175	};
	176
	177
	178	// ======================> sega_sys16a_sprite_device
	179
	180	class sega_sys16a_sprite_device : public sega_16bit_sprite_device
	181	{
	182	public:
	183	// construction/destruction
	184	sega_sys16a_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	185
	186	protected:
	187	// subclass overrides
	188	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	189	};
	190
	191
	192	// ======================> bootleg_sys16a_sprite_device
	193
	194	class bootleg_sys16a_sprite_device : public sega_16bit_sprite_device
	195	{
	196	public:
	197	// construction/destruction
	198	bootleg_sys16a_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	199
	200	// configuration
	201	static void static_set_remap(device_t &device, UINT8 offs0, UINT8 offs1, UINT8 offs2, UINT8 offs3, UINT8 offs4, UINT8 offs5, UINT8 offs6, UINT8 offs7);
	202
	203	protected:
	204	// subclass overrides
	205	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	206
	207	// internal state
	208	UINT8      m_addrmap[8];
	209	};
	210
	211
	212	// ======================> sega_sys16b_sprite_device
	213
	214	class sega_sys16b_sprite_device : public sega_16bit_sprite_device
	215	{
	216	public:
	217	// construction/destruction
	218	sega_sys16b_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	219
	220	protected:
	221	// subclass overrides
	222	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	223	};
	224
	225
	226	// ======================> sega_yboard_sprite_device
	227
	228	class sega_yboard_sprite_device : public sega_16bit_sprite_device
	229	{
	230	public:
	231	// construction/destruction
	232	sega_yboard_sprite_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	233
	234	protected:
	235	// subclass overrides
	236	virtual void draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
	237	};
	238
	239
	240	// device type definition
	241	extern const device_type SEGA_HANGON_SPRITES;
	242	extern const device_type SEGA_SHARRIER_SPRITES;
	243	extern const device_type SEGA_OUTRUN_SPRITES;
	244	extern const device_type SEGA_SYS16A_SPRITES;
	245	extern const device_type BOOTLEG_SYS16A_SPRITES;
	246	extern const device_type SEGA_SYS16B_SPRITES;
	247	extern const device_type SEGA_XBOARD_SPRITES;
	248	extern const device_type SEGA_YBOARD_SPRITES;
	249
	250
	251	#endif
	252

trunk/src/mame/video/segas16a.c

r17593	r17594
46	46
47	47	void segas16a_state::video_start()
48	48	{
49		// compute palette info
50		segaic16_palette_init(0x800);
51
52	49	// initialize the tile/text layers
53	50	segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16A, 0x000, 0, 1);
54	51	}
r17593	r17594
67	64	return 0;
68	65	}
69	66
	67	// start the sprites drawing
	68	m_sprites->draw_async(cliprect);
	69
70	70	// reset priorities
71	71	machine().priority_bitmap.fill(0, cliprect);
72	72
r17593	r17594
87	87	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
88	88	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
89	89
90		// draw the sprites
91		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	90	// mix in sprites
	91	bitmap_ind16 &sprites = m_sprites->bitmap();
	92	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	93	for (int y = rect->min_y; y <= rect->max_y; y++)
	94	{
	95	UINT16 *dest = &bitmap.pix(y);
	96	UINT16 *src = &sprites.pix(y);
	97	UINT8 *pri = &machine().priority_bitmap.pix(y);
	98	for (int x = rect->min_x; x <= rect->max_x; x++)
	99	{
	100	// only process written pixels
	101	UINT16 pix = src[x];
	102	if (pix != 0xffff)
	103	{
	104	// compare sprite priority against tilemap priority
	105	int priority = pix >> 10;
	106	if ((1 << priority) > pri[x])
	107	{
	108	// if color bits are all 1, this triggers shadow/hilight
	109	if ((pix & 0x3f0) == 0x3f0)
	110	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	111
	112	// otherwise, just add in sprite palette base
	113	else
	114	dest[x] = 1024 + (pix & 0x3ff);
	115	}
	116	}
	117	}
	118	}
	119
92	120	return 0;
93	121	}

trunk/src/mame/video/segahang.c

r17593	r17594
46	46
47	47	void segahang_state::video_start()
48	48	{
49		// compute palette info
50		segaic16_palette_init(0x800);
51
52	49	// initialize the tile/text layers
53	50	segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_HANGON, 0x000, 0, 2);
54	51
r17593	r17594
70	67	return 0;
71	68	}
72	69
	70	// start the sprites drawing
	71	m_sprites->draw_async(cliprect);
	72
73	73	// reset priorities
74	74	machine().priority_bitmap.fill(0, cliprect);
75	75
r17593	r17594
93	93	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x08);
94	94	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
95	95
96		// draw the sprites
97		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	96	// mix in sprites
	97	bitmap_ind16 &sprites = m_sprites->bitmap();
	98	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	99	for (int y = rect->min_y; y <= rect->max_y; y++)
	100	{
	101	UINT16 *dest = &bitmap.pix(y);
	102	UINT16 *src = &sprites.pix(y);
	103	UINT8 *pri = &machine().priority_bitmap.pix(y);
	104
	105	// hangon mixing
	106	if (!m_sharrier_video)
	107	{
	108	for (int x = rect->min_x; x <= rect->max_x; x++)
	109	{
	110	// only process written pixels
	111	UINT16 pix = src[x];
	112	if (pix != 0xffff)
	113	{
	114	// compare sprite priority against tilemap priority
	115	int priority = pix >> 10;
	116	if ((1 << priority) > pri[x])
	117	{
	118	// if color bits are all 1, this triggers shadow/hilight
	119	if ((pix & 0x3f0) == 0x3f0)
	120	dest[x] += m_shadow ? m_palette_entries*2 : m_palette_entries;
	121
	122	// otherwise, just add in sprite palette base
	123	else
	124	dest[x] = 1024 + (pix & 0x3ff);
	125	}
	126	}
	127	}
	128	}
	129
	130	// sharrier mixing
	131	else
	132	{
	133	for (int x = rect->min_x; x <= rect->max_x; x++)
	134	{
	135	// only process written pixels
	136	UINT16 pix = src[x];
	137	if (pix != 0xffff)
	138	{
	139	// compare sprite priority against tilemap priority
	140	int priority = ((pix >> 9) & 2) | 1;
	141	if ((1 << priority) > pri[x])
	142	{
	143	// if shadow bit is 0 and pix data is 0xa, this triggers shadow/hilight
	144	if ((pix & 0x80f) == 0x00a)
	145	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	146
	147	// otherwise, just add in sprite palette base
	148	else
	149	dest[x] = 1024 + (pix & 0x3ff);
	150	}
	151	}
	152	}
	153	}
	154	}
	155
98	156	return 0;
99	157	}
100	158

trunk/src/mame/video/segas16b.c

r17593	r17594
46	46
47	47	void segas16b_state::video_start()
48	48	{
49		// compute palette info
50		segaic16_palette_init(0x800);
51
52	49	// initialize the tile/text layers
53	50	segaic16_tilemap_init(machine(), 0, m_tilemap_type, 0x000, 0, 2);
54	51	}
r17593	r17594
67	64	return 0;
68	65	}
69	66
	67	// start the sprites drawing
	68	m_sprites->draw_async(cliprect);
	69
70	70	// reset priorities
71	71	machine().priority_bitmap.fill(0, cliprect);
72	72
r17593	r17594
87	87	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 0, 0x04);
88	88	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
89	89
90		// draw the sprites
91		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	90	// mix in sprites
	91	bitmap_ind16 &sprites = m_sprites->bitmap();
	92	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	93	for (int y = rect->min_y; y <= rect->max_y; y++)
	94	{
	95	UINT16 *dest = &bitmap.pix(y);
	96	UINT16 *src = &sprites.pix(y);
	97	UINT8 *pri = &machine().priority_bitmap.pix(y);
	98	for (int x = rect->min_x; x <= rect->max_x; x++)
	99	{
	100	// only process written pixels
	101	UINT16 pix = src[x];
	102	if (pix != 0xffff)
	103	{
	104	// compare sprite priority against tilemap priority
	105	int priority = (pix >> 10) & 3;
	106	if ((1 << priority) > pri[x])
	107	{
	108	// if the color is set to maximum, shadow pixels underneath us
	109	if ((pix & 0x03f0) == 0x03f0)
	110	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
	111
	112	// otherwise, just add in sprite palette base
	113	else
	114	dest[x] = 1024 + (pix & 0x3ff);
	115	}
	116	}
	117	}
	118	}
	119
92	120	return 0;
93	121	}

trunk/src/mame/video/segas18.c

r17593	r17594
63	63	m_vdp_enable = false;
64	64	m_vdp_mixing = 0;
65	65
66		// compute palette info
67		segaic16_palette_init(0x800);
68
69	66	// initialize the tile/text layers
70	67	segaic16_tilemap_init(machine(), 0, SEGAIC16_TILEMAP_16B, 0x000, 0, 8);
71	68
r17593	r17594
227	224	return 0;
228	225	}
229	226
	227	// start the sprites drawing
	228	m_sprites->draw_async(cliprect);
	229
230	230	// reset priorities
231	231	machine().priority_bitmap.fill(0, cliprect);
232	232
r17593	r17594
250	250	segaic16_tilemap_draw(screen, bitmap, cliprect, 0, SEGAIC16_TILEMAP_TEXT, 1, 0x08);
251	251	if (m_vdp_enable && vdplayer == 3) draw_vdp(screen, bitmap, cliprect, vdppri);
252	252
253		// draw the sprites
254		segaic16_sprites_draw(screen, bitmap, cliprect, 0);
	253	// mix in sprites
	254	bitmap_ind16 &sprites = m_sprites->bitmap();
	255	for (const sparse_dirty_rect *rect = m_sprites->first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	256	for (int y = rect->min_y; y <= rect->max_y; y++)
	257	{
	258	UINT16 *dest = &bitmap.pix(y);
	259	UINT16 *src = &sprites.pix(y);
	260	UINT8 *pri = &machine().priority_bitmap.pix(y);
	261	for (int x = rect->min_x; x <= rect->max_x; x++)
	262	{
	263	// only process written pixels
	264	UINT16 pix = src[x];
	265	if (pix != 0xffff)
	266	{
	267	// compare sprite priority against tilemap priority
	268	int priority = (pix >> 10) & 3;
	269	if ((1 << priority) > pri[x])
	270	{
	271	// if the color is set to maximum, shadow pixels underneath us
	272	if ((pix & 0x03f0) == 0x03f0)
	273	dest[x] += (m_paletteram[dest[x]] & 0x8000) ? m_palette_entries*2 : m_palette_entries;
255	274
	275	// otherwise, just add in sprite palette base
	276	else
	277	dest[x] = 1024 + (pix & 0x3ff);
	278	}
	279	}
	280	}
	281	}
	282
256	283	#if DEBUG_VDP
257	284	if (m_vdp_enable && machine().input().code_pressed(KEYCODE_V))
258	285	{

trunk/src/mame/includes/segaxbd.h

r17593	r17594
40	40	#include "cpu/z80/z80.h"
41	41	#include "machine/segaic16.h"
42	42	#include "video/segaic16.h"
	43	#include "video/sega16sp.h"
43	44
44	45
45	46	// ======================> segaxbd_state
46	47
47		class segaxbd_state : public driver_device
	48	class segaxbd_state : public sega_16bit_common_base
48	49	{
49	50	public:
50	51	// construction/destruction
51	52	segaxbd_state(const machine_config &mconfig, device_type type, const char *tag)
52		: driver_device(mconfig, type, tag),
	53	: sega_16bit_common_base(mconfig, type, tag),
53	54	m_maincpu(*this, "maincpu"),
54	55	m_subcpu(*this, "subcpu"),
55	56	m_soundcpu(*this, "soundcpu"),
56	57	m_soundcpu2(*this, "soundcpu2"),
57	58	m_mcu(*this, "mcu"),
58	59	m_cmptimer_1(*this, "cmptimer_main"),
	60	m_sprites(*this, "sprites"),
59	61	m_gprider_hack(false),
60	62	m_road_priority(1),
61	63	m_scanline_timer(NULL),
r17593	r17594
145	147	optional_device<z80_device> m_soundcpu2;
146	148	optional_device<i8751_device> m_mcu;
147	149	required_device<sega_315_5250_compare_timer_device> m_cmptimer_1;
	150	required_device<sega_xboard_sprite_device> m_sprites;
148	151
149	152	// configuration
150	153	bool         m_gprider_hack;

trunk/src/mame/includes/segaybd.h

r17593	r17594
39	39	#include "cpu/z80/z80.h"
40	40	#include "machine/segaic16.h"
41	41	#include "video/segaic16.h"
	42	#include "video/sega16sp.h"
42	43
43	44
44	45	// ======================> segaybd_state
45	46
46		class segaybd_state : public driver_device
	47	class segaybd_state : public sega_16bit_common_base
47	48	{
48	49	public:
49	50	// construction/destruction
50	51	segaybd_state(const machine_config &mconfig, device_type type, const char *tag)
51		: driver_device(mconfig, type, tag),
	52	: sega_16bit_common_base(mconfig, type, tag),
52	53	m_maincpu(*this, "maincpu"),
53	54	m_subx(*this, "subx"),
54	55	m_suby(*this, "suby"),
55	56	m_soundcpu(*this, "soundcpu"),
	57	m_bsprites(*this, "bsprites"),
	58	m_ysprites(*this, "ysprites"),
56	59	m_pdrift_bank(0),
57	60	m_scanline_timer(NULL),
58	61	m_irq2_scanline(0),
r17593	r17594
121	124	required_device<m68000_device> m_subx;
122	125	required_device<m68000_device> m_suby;
123	126	required_device<z80_device> m_soundcpu;
	127	required_device<sega_sys16b_sprite_device> m_bsprites;
	128	required_device<sega_yboard_sprite_device> m_ysprites;
124	129
125	130	// configuration
126	131	output_delegate   m_output_cb1;

trunk/src/mame/includes/segaorun.h

r17593	r17594
41	41	#include "machine/nvram.h"
42	42	#include "machine/segaic16.h"
43	43	#include "video/segaic16.h"
	44	#include "video/sega16sp.h"
44	45
45	46
46	47	// ======================> segaorun_state
47	48
48		class segaorun_state : public driver_device
	49	class segaorun_state : public sega_16bit_common_base
49	50	{
50	51	public:
51	52	// construction/destruction
52	53	segaorun_state(const machine_config &mconfig, device_type type, const char *tag)
53		: driver_device(mconfig, type, tag),
	54	: sega_16bit_common_base(mconfig, type, tag),
54	55	m_mapper(*this, "mapper"),
55	56	m_maincpu(*this, "maincpu"),
56	57	m_subcpu(*this, "subcpu"),
57	58	m_soundcpu(*this, "soundcpu"),
58	59	m_i8255(*this, "i8255"),
59	60	m_nvram(*this, "nvram"),
	61	m_sprites(*this, "sprites"),
60	62	m_workram(*this, "workram"),
61	63	m_custom_map(NULL),
62	64	m_shangon_video(false),
r17593	r17594
134	136	required_device<z80_device> m_soundcpu;
135	137	required_device<i8255_device> m_i8255;
136	138	optional_device<nvram_device> m_nvram;
	139	required_device<sega_16bit_sprite_device> m_sprites;
137	140
138	141	// memory
139	142	required_shared_ptr<UINT16> m_workram;

trunk/src/mame/includes/system16.h

r17593	r17594
1	1
2	2	// later, this might be merged with segas1x_state in segas16.h
3	3
4		class segas1x_bootleg_state : public driver_device
	4	#include "video/sega16sp.h"
	5	#include "machine/segaic16.h"
	6
	7	class segas1x_bootleg_state : public sega_16bit_common_base
5	8	{
6	9	public:
7	10	segas1x_bootleg_state(const machine_config &mconfig, device_type type, const char *tag)
8		: driver_device(mconfig, type, tag) ,
	11	: sega_16bit_common_base(mconfig, type, tag) ,
9	12	m_textram(*this, "textram"),
10	13	m_bg0_tileram(*this, "bg0_tileram"),
11	14	m_bg1_tileram(*this, "bg1_tileram"),
12	15	m_tileram(*this, "tileram"),
13	16	m_goldnaxeb2_bgpage(*this, "gab2_bgpage"),
14		m_goldnaxeb2_fgpage(*this, "gab2_fgpage"){ }
	17	m_goldnaxeb2_fgpage(*this, "gab2_fgpage"),
	18	m_sprites(*this, "sprites")
	19	{ }
15	20
16	21	required_shared_ptr<UINT16> m_textram;
17	22	optional_shared_ptr<UINT16> m_bg0_tileram;
r17593	r17594
20	25	optional_shared_ptr<UINT16> m_goldnaxeb2_bgpage;
21	26	optional_shared_ptr<UINT16> m_goldnaxeb2_fgpage;
22	27
	28	required_device<sega_16bit_sprite_device> m_sprites;
23	29
24	30	UINT16 m_coinctrl;
25	31

trunk/src/mame/includes/segas16a.h

r17593	r17594
45	45	#include "machine/segaic16.h"
46	46	#include "sound/2151intf.h"
47	47	#include "video/segaic16.h"
	48	#include "video/sega16sp.h"
48	49
49	50
50	51	// ======================> segas16a_state
51	52
52		class segas16a_state : public driver_device
	53	class segas16a_state : public sega_16bit_common_base
53	54	{
54	55	public:
55	56	// construction/destruction
56	57	segas16a_state(const machine_config &mconfig, device_type type, const char *tag)
57		: driver_device(mconfig, type, tag),
	58	: sega_16bit_common_base(mconfig, type, tag),
58	59	m_maincpu(*this, "maincpu"),
59	60	m_soundcpu(*this, "soundcpu"),
60	61	m_mcu(*this, "mcu"),
r17593	r17594
63	64	m_n7751(*this, "n7751"),
64	65	m_n7751_i8243(*this, "n7751_8243"),
65	66	m_nvram(*this, "nvram"),
	67	m_sprites(*this, "sprites"),
66	68	m_workram(*this, "nvram"),
67	69	m_video_control(0),
68	70	m_mcu_control(0),
r17593	r17594
158	160	optional_device<n7751_device> m_n7751;
159	161	optional_device<i8243_device> m_n7751_i8243;
160	162	required_device<nvram_device> m_nvram;
	163	required_device<sega_sys16a_sprite_device> m_sprites;
161	164
162	165	// memory pointers
163	166	required_shared_ptr<UINT16> m_workram;

trunk/src/mame/includes/segahang.h

r17593	r17594
41	41	#include "machine/i8255.h"
42	42	#include "machine/segaic16.h"
43	43	#include "video/segaic16.h"
	44	#include "video/sega16sp.h"
44	45
45	46
46	47	// ======================> segahang_state
47	48
48		class segahang_state : public driver_device
	49	class segahang_state : public sega_16bit_common_base
49	50	{
50	51	public:
51	52	// construction/destruction
52	53	segahang_state(const machine_config &mconfig, device_type type, const char *tag)
53		: driver_device(mconfig, type, tag),
	54	: sega_16bit_common_base(mconfig, type, tag),
54	55	m_maincpu(*this, "maincpu"),
55	56	m_subcpu(*this, "subcpu"),
56	57	m_soundcpu(*this, "soundcpu"),
57	58	m_mcu(*this, "mcu"),
58	59	m_i8255_1(*this, "i8255_1"),
59	60	m_i8255_2(*this, "i8255_2"),
	61	m_sprites(*this, "sprites"),
60	62	m_workram(*this, "workram"),
61	63	m_sharrier_video(false),
62	64	m_adc_select(0)
r17593	r17594
87	89	DECLARE_DRIVER_INIT(enduror);
88	90	DECLARE_DRIVER_INIT(endurobl);
89	91	DECLARE_DRIVER_INIT(endurob2);
	92
90	93	// video updates
91	94	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
92	95
r17593	r17594
116	119	optional_device<i8751_device> m_mcu;
117	120	required_device<i8255_device> m_i8255_1;
118	121	required_device<i8255_device> m_i8255_2;
119
	122	required_device<sega_16bit_sprite_device> m_sprites;
	123
120	124	// memory pointers
121	125	required_shared_ptr<UINT16> m_workram;
122	126
r17593	r17594
126	130
127	131	// internal state
128	132	UINT8               m_adc_select;
	133	bool               m_shadow;
129	134	};

trunk/src/mame/includes/segas16b.h

r17593	r17594
44	44	#include "sound/2413intf.h"
45	45	#include "sound/upd7759.h"
46	46	#include "video/segaic16.h"
	47	#include "video/sega16sp.h"
47	48
48	49
49	50	// ======================> segas16b_state
50	51
51		class segas16b_state : public driver_device
	52	class segas16b_state : public sega_16bit_common_base
52	53	{
53	54	public:
54	55	// construction/destruction
55	56	segas16b_state(const machine_config &mconfig, device_type type, const char *tag)
56		: driver_device(mconfig, type, tag),
	57	: sega_16bit_common_base(mconfig, type, tag),
57	58	m_mapper(*this, "mapper"),
58	59	m_maincpu(*this, "maincpu"),
59	60	m_soundcpu(*this, "soundcpu"),
r17593	r17594
65	66	m_cmptimer_1(*this, "cmptimer_1"),
66	67	m_cmptimer_2(*this, "cmptimer_2"),
67	68	m_nvram(*this, "nvram"),
	69	m_sprites(*this, "sprites"),
68	70	m_workram(*this, "workram"),
69	71	m_romboard(ROM_BOARD_INVALID),
70	72	m_tilemap_type(SEGAIC16_TILEMAP_16B),
r17593	r17594
193	195	DECLARE_WRITE16_MEMBER( sjryuko_custom_io_w );
194	196
195	197	// devices
196		required_device<sega_315_5195_mapper_device> m_mapper;
	198	optional_device<sega_315_5195_mapper_device> m_mapper;
197	199	required_device<m68000_device> m_maincpu;
198	200	optional_device<z80_device> m_soundcpu;
199	201	optional_device<i8751_device> m_mcu;
r17593	r17594
204	206	optional_device<sega_315_5250_compare_timer_device> m_cmptimer_1;
205	207	optional_device<sega_315_5250_compare_timer_device> m_cmptimer_2;
206	208	required_device<nvram_device> m_nvram;
	209	required_device<sega_sys16b_sprite_device> m_sprites;
207	210
208	211	// memory pointers
209	212	required_shared_ptr<UINT16> m_workram;

trunk/src/mame/includes/segas18.h

r17593	r17594
38	38	#include "cpu/m68000/m68000.h"
39	39	#include "cpu/mcs51/mcs51.h"
40	40	#include "cpu/z80/z80.h"
	41	#include "machine/megavdp.h"
41	42	#include "machine/nvram.h"
42	43	#include "machine/segaic16.h"
43	44	#include "video/segaic16.h"
44		#include "machine/megavdp.h"
	45	#include "video/sega16sp.h"
45	46
46	47
47	48	// ======================> segas18_state
48	49
49		class segas18_state : public driver_device
	50	class segas18_state : public sega_16bit_common_base
50	51	{
51	52	public:
52	53	// construction/destruction
53	54	segas18_state(const machine_config &mconfig, device_type type, const char *tag)
54		: driver_device(mconfig, type, tag),
	55	: sega_16bit_common_base(mconfig, type, tag),
55	56	m_mapper(*this, "mapper"),
56	57	m_maincpu(*this, "maincpu"),
57	58	m_soundcpu(*this, "soundcpu"),
58	59	m_mcu(*this, "mcu"),
59	60	m_vdp(*this, "gen_vdp"),
60	61	m_nvram(*this, "nvram"),
	62	m_sprites(*this, "sprites"),
61	63	m_workram(*this, "workram"),
62	64	m_romboard(ROM_BOARD_INVALID),
63	65	m_has_guns(false),
r17593	r17594
150	152	optional_device<i8751_device> m_mcu;
151	153	required_device<sega_genesis_vdp_device> m_vdp;
152	154	required_device<nvram_device> m_nvram;
	155	required_device<sega_sys16b_sprite_device> m_sprites;
153	156
154	157	// memory pointers
155	158	required_shared_ptr<UINT16> m_workram;

trunk/src/mame/drivers/segaxbd.c

r17593	r17594
927	927	AM_RANGE(0x0e0000, 0x0e0007) AM_MIRROR(0x003ff8) AM_DEVREADWRITE("multiplier_main", sega_315_5248_multiplier_device, read, write)
928	928	AM_RANGE(0x0e4000, 0x0e401f) AM_MIRROR(0x003fe0) AM_DEVREADWRITE("divider_main", sega_315_5249_divider_device, read, write)
929	929	AM_RANGE(0x0e8000, 0x0e801f) AM_MIRROR(0x003fe0) AM_DEVREADWRITE("cmptimer_main", sega_315_5250_compare_timer_device, read, write)
930		AM_RANGE(0x100000, 0x100fff) AM_MIRROR(0x00f000) AM_RAM AM_SHARE("spriteram")
931		AM_RANGE(0x110000, 0x11ffff) AM_WRITE_LEGACY(segaic16_sprites_draw_0_w)
932		AM_RANGE(0x120000, 0x123fff) AM_MIRROR(0x00c000) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_SHARE("paletteram")
	930	AM_RANGE(0x100000, 0x100fff) AM_MIRROR(0x00f000) AM_RAM AM_SHARE("sprites")
	931	AM_RANGE(0x110000, 0x11ffff) AM_DEVWRITE("sprites", sega_xboard_sprite_device, draw_write)
	932	AM_RANGE(0x120000, 0x123fff) AM_MIRROR(0x00c000) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
933	933	AM_RANGE(0x130000, 0x13ffff) AM_READWRITE(adc_r, adc_w)
934	934	AM_RANGE(0x140000, 0x14000f) AM_MIRROR(0x00fff0) AM_READWRITE(iochip_0_r, iochip_0_w)
935	935	AM_RANGE(0x150000, 0x15000f) AM_MIRROR(0x00fff0) AM_READWRITE(iochip_1_r, iochip_1_w)
r17593	r17594
1613	1613	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK/8, 400, 0, 320, 262, 0, 224)
1614	1614	MCFG_SCREEN_UPDATE_DRIVER(segaxbd_state, screen_update)
1615	1615
1616		MCFG_SEGA16SP_ADD_XBOARD("segaspr1")
	1616	MCFG_SEGA_XBOARD_SPRITES_ADD("sprites")
1617	1617
1618	1618	// sound hardware
1619	1619	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
r17593	r17594
1736	1736	ROM_LOAD( "epr-10925.153", 0x10000, 0x10000, CRC(4ef048cc) SHA1(3b386b3bfa600f114dbc19796bb6864a88ff4562) )
1737	1737	ROM_LOAD( "epr-10924.152", 0x20000, 0x10000, CRC(50c15a6d) SHA1(fc202cc583fc6804647abc884fdf332e72ea3100) )
1738	1738
1739		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	1739	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
1740	1740	ROM_LOAD32_BYTE( "mpr-10932.90",  0x000000, 0x20000, CRC(cc0821d6) SHA1(22e84419a585209bbda1466d2180504c316a9b7f) ) // First 8 roms are MPR, the rest are EPR
1741	1741	ROM_LOAD32_BYTE( "mpr-10934.94",  0x000001, 0x20000, CRC(4a51b1fa) SHA1(2eed018a5a1e935bb72b6f440a794466a1397dc5) )
1742	1742	ROM_LOAD32_BYTE( "mpr-10936.98",  0x000002, 0x20000, CRC(ada70d64) SHA1(ba6203b0fdb4c4998b7be5b446eb8354751d553a) )
r17593	r17594
1787	1787	ROM_LOAD( "epr-11114.153", 0x10000, 0x10000, CRC(2e97f633) SHA1(074125c106dd00785903b2e10cd7e28d5036eb60) )
1788	1788	ROM_LOAD( "epr-11113.152", 0x20000, 0x10000, CRC(36058c8c) SHA1(52befe6c6c53f10b6fd4971098abc8f8d3eef9d4) )
1789	1789
1790		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	1790	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
1791	1791	ROM_LOAD32_BYTE( "mpr-10932.90",  0x000000, 0x20000, CRC(cc0821d6) SHA1(22e84419a585209bbda1466d2180504c316a9b7f) ) // First 8 roms are MPR, the rest are EPR
1792	1792	ROM_LOAD32_BYTE( "mpr-10934.94",  0x000001, 0x20000, CRC(4a51b1fa) SHA1(2eed018a5a1e935bb72b6f440a794466a1397dc5) )
1793	1793	ROM_LOAD32_BYTE( "mpr-10936.98",  0x000002, 0x20000, CRC(ada70d64) SHA1(ba6203b0fdb4c4998b7be5b446eb8354751d553a) )
r17593	r17594
1854	1854	ROM_LOAD( "opr-12792.153", 0x10000, 0x10000, CRC(e506723c) SHA1(d04dc29686fe348f8f715d14c027de0e508c770f) )
1855	1855	ROM_LOAD( "opr-12793.152", 0x20000, 0x10000, CRC(0ce8cce3) SHA1(1a6b1af2b0b9e8240e681f7b15e9d08595753fe6) )
1856	1856
1857		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	1857	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
1858	1858	ROM_LOAD32_BYTE( "epr-12787.90",  0x000000, 0x20000, CRC(6431a3a6) SHA1(63a732b7dfd2b83fe7684d47fea26063c4ece099) )
1859	1859	ROM_LOAD32_BYTE( "epr-12788.94",  0x000001, 0x20000, CRC(1982a0ce) SHA1(e4756f31b0094e0e9ddb2df53a5c938ac5559230) )
1860	1860	ROM_LOAD32_BYTE( "epr-12789.98",  0x000002, 0x20000, CRC(97d03274) SHA1(b4b9921db53949bc8e91f8a2992e89c172fe8893) )
r17593	r17594
1908	1908	ROM_LOAD( "opr-12792.153", 0x10000, 0x10000, CRC(e506723c) SHA1(d04dc29686fe348f8f715d14c027de0e508c770f) )
1909	1909	ROM_LOAD( "opr-12793.152", 0x20000, 0x10000, CRC(0ce8cce3) SHA1(1a6b1af2b0b9e8240e681f7b15e9d08595753fe6) )
1910	1910
1911		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	1911	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
1912	1912	ROM_LOAD32_BYTE( "epr-12787.90",  0x000000, 0x20000, CRC(6431a3a6) SHA1(63a732b7dfd2b83fe7684d47fea26063c4ece099) )
1913	1913	ROM_LOAD32_BYTE( "epr-12788.94",  0x000001, 0x20000, CRC(1982a0ce) SHA1(e4756f31b0094e0e9ddb2df53a5c938ac5559230) )
1914	1914	ROM_LOAD32_BYTE( "epr-12789.98",  0x000002, 0x20000, CRC(97d03274) SHA1(b4b9921db53949bc8e91f8a2992e89c172fe8893) )
r17593	r17594
1965	1965	ROM_LOAD( "opr-12792.153", 0x10000, 0x10000, CRC(e506723c) SHA1(d04dc29686fe348f8f715d14c027de0e508c770f) )
1966	1966	ROM_LOAD( "opr-12793.152", 0x20000, 0x10000, CRC(0ce8cce3) SHA1(1a6b1af2b0b9e8240e681f7b15e9d08595753fe6) )
1967	1967
1968		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	1968	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
1969	1969	ROM_LOAD32_BYTE( "epr-12787.90",  0x000000, 0x20000, CRC(6431a3a6) SHA1(63a732b7dfd2b83fe7684d47fea26063c4ece099) )
1970	1970	ROM_LOAD32_BYTE( "epr-12788.94",  0x000001, 0x20000, CRC(1982a0ce) SHA1(e4756f31b0094e0e9ddb2df53a5c938ac5559230) )
1971	1971	ROM_LOAD32_BYTE( "epr-12789.98",  0x000002, 0x20000, CRC(97d03274) SHA1(b4b9921db53949bc8e91f8a2992e89c172fe8893) )
r17593	r17594
2025	2025	ROM_LOAD( "epr-11315.ic153", 0x10000, 0x10000, CRC(35813088) SHA1(ea1ec982d1509efb26e7b6a150825a6a905efed9) )
2026	2026	ROM_LOAD( "epr-11316.ic152", 0x20000, 0x10000, CRC(84290dff) SHA1(c13fb6ef12a991f79a95072f953a02b5c992aa2d) )
2027	2027
2028		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2028	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2029	2029	ROM_LOAD32_BYTE( "epr-11323.ic90",  0x000000, 0x20000, CRC(27e40735) SHA1(284ddb88efe741fb78199ea619c9b230ee689803) )
2030	2030	ROM_LOAD32_BYTE( "epr-11322.ic94",  0x000001, 0x20000, CRC(10364d74) SHA1(393b19a972b5d8817ffd438f13ded73cd58ebe56) )
2031	2031	ROM_LOAD32_BYTE( "epr-11321.ic98",  0x000002, 0x20000, CRC(8e738f58) SHA1(9f2dceebf01e582cf60f072ae411000d8503894b) )
r17593	r17594
2079	2079	ROM_LOAD( "epr-11315.ic153", 0x10000, 0x10000, CRC(35813088) SHA1(ea1ec982d1509efb26e7b6a150825a6a905efed9) )
2080	2080	ROM_LOAD( "epr-11316.ic152", 0x20000, 0x10000, CRC(84290dff) SHA1(c13fb6ef12a991f79a95072f953a02b5c992aa2d) )
2081	2081
2082		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2082	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2083	2083	ROM_LOAD32_BYTE( "epr-11323.ic90",  0x000000, 0x20000, CRC(27e40735) SHA1(284ddb88efe741fb78199ea619c9b230ee689803) )
2084	2084	ROM_LOAD32_BYTE( "epr-11322.ic94",  0x000001, 0x20000, CRC(10364d74) SHA1(393b19a972b5d8817ffd438f13ded73cd58ebe56) )
2085	2085	ROM_LOAD32_BYTE( "epr-11321.ic98",  0x000002, 0x20000, CRC(8e738f58) SHA1(9f2dceebf01e582cf60f072ae411000d8503894b) )
r17593	r17594
2137	2137	ROM_LOAD( "epr-12056.ic153", 0x10000, 0x10000, CRC(3cd4c306) SHA1(b0f178688870c67936a15383024c392072e3bc66) )
2138	2138	ROM_LOAD( "epr-12057.ic152", 0x20000, 0x10000, CRC(37e91770) SHA1(69e26f4d3c4ebfaf0225a9b1c60038595929ef05) )
2139	2139
2140		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2140	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2141	2141	ROM_LOAD32_BYTE( "mpr-12064.ic90",  0x000000, 0x20000, CRC(84562a69) SHA1(815189a65065def213ef171fe40a44a455dfe75a) )
2142	2142	ROM_LOAD32_BYTE( "mpr-12063.ic94",  0x000001, 0x20000, CRC(d163727c) SHA1(50ed2b401e107a359874dad5d86eec788f5504eb) )
2143	2143	ROM_LOAD32_BYTE( "mpr-12062.ic98",  0x000002, 0x20000, CRC(6b57833b) SHA1(1d70894c81a4cd39f43067701a598d2c4fbffa58) )
r17593	r17594
2193	2193	ROM_LOAD( "epr-12880.ic153", 0x10000, 0x10000, CRC(27ff04a5) SHA1(b554a6e060f4803100be8efa52977b503eb0f31d) )
2194	2194	ROM_LOAD( "epr-12881.ic152", 0x20000, 0x10000, CRC(72f14491) SHA1(b7a6cbd08470a5edda77cdd0337abd502c4905fd) )
2195	2195
2196		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2196	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2197	2197	ROM_LOAD32_BYTE( "epr-12872.ic90",  0x000000, 0x20000, CRC(68d56139) SHA1(b5f32edbda10c31d52f90defea2bae226676069f) )
2198	2198	ROM_LOAD32_BYTE( "epr-12873.ic94",  0x000001, 0x20000, CRC(3d3ec450) SHA1(ac96ad8c7b365478bd1e5826a073e242f1208247) )
2199	2199	ROM_LOAD32_BYTE( "epr-12874.ic98",  0x000002, 0x20000, CRC(7d6bde23) SHA1(88b12ec6386cdad60b0028b72033a0037a0cdbdb) )
r17593	r17594
2289	2289	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2290	2290	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2291	2291
2292		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2292	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2293	2293	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2294	2294	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2295	2295	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2355	2355	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2356	2356	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2357	2357
2358		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2358	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2359	2359	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2360	2360	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2361	2361	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2471	2471	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2472	2472	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2473	2473
2474		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2474	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2475	2475	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2476	2476	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2477	2477	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2536	2536	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2537	2537	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2538	2538
2539		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2539	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2540	2540	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2541	2541	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2542	2542	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2602	2602	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2603	2603	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2604	2604
2605		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2605	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2606	2606	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2607	2607	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2608	2608	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2710	2710	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2711	2711	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2712	2712
2713		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2713	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2714	2714	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2715	2715	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2716	2716	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2775	2775	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2776	2776	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2777	2777
2778		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2778	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2779	2779	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2780	2780	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2781	2781	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2840	2840	ROM_LOAD( "epr-12430.153", 0x10000, 0x10000, CRC(05e00134) SHA1(8baaa80815d5dabd38dc8600e357975b96d23b95) )
2841	2841	ROM_LOAD( "epr-12431.152", 0x20000, 0x10000, CRC(35572f4a) SHA1(d66456ecf7b59f81736fb873c553926b56bb3977))
2842	2842
2843		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2843	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2844	2844	ROM_LOAD32_BYTE( "mpr-12425.90",  0x000000, 0x20000, CRC(14bf2a15) SHA1(84db3ac09e4a8fe470ac051d8d5de1814b48bc72) )
2845	2845	ROM_LOAD32_BYTE( "mpr-12426.94",  0x000001, 0x20000, CRC(28b60dc0) SHA1(ad69d449434853445a076319a55a29014217a100) )
2846	2846	ROM_LOAD32_BYTE( "mpr-12427.98",  0x000002, 0x20000, CRC(0a367928) SHA1(bcb558b7c23906397e66a7f046b09eb5036c0888) )
r17593	r17594
2910	2910	ROM_LOAD( "opr-13554.ic153", 0x10000, 0x10000, CRC(4e3df9f0) SHA1(8b481c2cd25c58612ac8ac3ffb7eeae9ca247d2e) )
2911	2911	ROM_LOAD( "opr-13555.ic152", 0x20000, 0x10000, CRC(6c4a1d42) SHA1(6c37b045b21173f1e2f7bd19d01c00979b8107fb) )
2912	2912
2913		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2913	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2914	2914	ROM_LOAD32_BYTE( "opr-13552.ic90",  0x000000, 0x20000, CRC(cc2cf706) SHA1(ad39c22e652ebcd90ffb5e17ae35985645f93c71) )
2915	2915	ROM_LOAD32_BYTE( "opr-13551.ic94",  0x000001, 0x20000, CRC(d6f276c1) SHA1(9ec68157ea460e09ef4b69aa8ea17687dc47ea59) )
2916	2916	ROM_LOAD32_BYTE( "opr-13550.ic98",  0x000002, 0x20000, CRC(f16518dd) SHA1(a5f1785cd28f03069cb238ac92c6afb5a26cbd37) )
r17593	r17594
2963	2963	ROM_LOAD( "opr-13554.ic153", 0x10000, 0x10000, CRC(4e3df9f0) SHA1(8b481c2cd25c58612ac8ac3ffb7eeae9ca247d2e) )
2964	2964	ROM_LOAD( "opr-13555.ic152", 0x20000, 0x10000, CRC(6c4a1d42) SHA1(6c37b045b21173f1e2f7bd19d01c00979b8107fb) )
2965	2965
2966		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	2966	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
2967	2967	ROM_LOAD32_BYTE( "opr-13552.ic90",  0x000000, 0x20000, CRC(cc2cf706) SHA1(ad39c22e652ebcd90ffb5e17ae35985645f93c71) )
2968	2968	ROM_LOAD32_BYTE( "opr-13551.ic94",  0x000001, 0x20000, CRC(d6f276c1) SHA1(9ec68157ea460e09ef4b69aa8ea17687dc47ea59) )
2969	2969	ROM_LOAD32_BYTE( "opr-13550.ic98",  0x000002, 0x20000, CRC(f16518dd) SHA1(a5f1785cd28f03069cb238ac92c6afb5a26cbd37) )
r17593	r17594
3021	3021	ROM_LOAD( "epr-13384.ic153", 0x10000, 0x10000, CRC(fe8238bd) SHA1(601910bd86536e6b08f5308b298c8f01fa60f233) )
3022	3022	ROM_LOAD( "epr-13385.ic152", 0x20000, 0x10000, CRC(6df1b995) SHA1(5aab19b87a9ef162c30ccf5974cb795e37dba91f) )
3023	3023
3024		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	3024	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
3025	3025	ROM_LOAD32_BYTE( "epr-13382.ic90",  0x000000, 0x20000, CRC(01dac209) SHA1(4c6b03308193c472f6cdbcede306f8ce6db0cc4b) )
3026	3026	ROM_LOAD32_BYTE( "epr-13381.ic94",  0x000001, 0x20000, CRC(3a50d931) SHA1(9d9cb1793f3b8f562ce0ea49f2afeef099f20859) )
3027	3027	ROM_LOAD32_BYTE( "epr-13380.ic98",  0x000002, 0x20000, CRC(ad1024c8) SHA1(86e941424b2e2e00940886e5daed640a78ed7403) )
r17593	r17594
3076	3076	ROM_LOAD( "epr-13384.ic153", 0x10000, 0x10000, CRC(fe8238bd) SHA1(601910bd86536e6b08f5308b298c8f01fa60f233) )
3077	3077	ROM_LOAD( "epr-13385.ic152", 0x20000, 0x10000, CRC(6df1b995) SHA1(5aab19b87a9ef162c30ccf5974cb795e37dba91f) )
3078	3078
3079		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	3079	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
3080	3080	ROM_LOAD32_BYTE( "epr-13382.ic90",  0x000000, 0x20000, CRC(01dac209) SHA1(4c6b03308193c472f6cdbcede306f8ce6db0cc4b) )
3081	3081	ROM_LOAD32_BYTE( "epr-13381.ic94",  0x000001, 0x20000, CRC(3a50d931) SHA1(9d9cb1793f3b8f562ce0ea49f2afeef099f20859) )
3082	3082	ROM_LOAD32_BYTE( "epr-13380.ic98",  0x000002, 0x20000, CRC(ad1024c8) SHA1(86e941424b2e2e00940886e5daed640a78ed7403) )
r17593	r17594
3131	3131	ROM_LOAD( "epr-13384.ic153", 0x10000, 0x10000, CRC(fe8238bd) SHA1(601910bd86536e6b08f5308b298c8f01fa60f233) )
3132	3132	ROM_LOAD( "epr-13385.ic152", 0x20000, 0x10000, CRC(6df1b995) SHA1(5aab19b87a9ef162c30ccf5974cb795e37dba91f) )
3133	3133
3134		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	3134	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
3135	3135	ROM_LOAD32_BYTE( "epr-13382.ic90",  0x000000, 0x20000, CRC(01dac209) SHA1(4c6b03308193c472f6cdbcede306f8ce6db0cc4b) )
3136	3136	ROM_LOAD32_BYTE( "epr-13381.ic94",  0x000001, 0x20000, CRC(3a50d931) SHA1(9d9cb1793f3b8f562ce0ea49f2afeef099f20859) )
3137	3137	ROM_LOAD32_BYTE( "epr-13380.ic98",  0x000002, 0x20000, CRC(ad1024c8) SHA1(86e941424b2e2e00940886e5daed640a78ed7403) )
r17593	r17594
3182	3182	ROM_LOAD( "epr-13962", 0x10000, 0x10000, CRC(7d7605bc) SHA1(20d3a7116807db7c831e285233d8c67317980e4a) )
3183	3183	ROM_LOAD( "epr-13963", 0x20000, 0x10000, CRC(f3376b65) SHA1(36b9292518a112409d03b97ea048b7ab22734841) )
3184	3184
3185		ROM_REGION32_LE( 0x200000, "gfx2", 0 ) // sprites
	3185	ROM_REGION32_LE( 0x200000, "sprites", 0 ) // sprites
3186	3186	ROM_LOAD32_BYTE( "epr-13960",  0x000000, 0x20000, CRC(b974128d) SHA1(14450615b3a10b1de6d098a282f80f80c98c34b8) )
3187	3187	ROM_LOAD32_BYTE( "epr-13959",  0x000001, 0x20000, CRC(db245b22) SHA1(301b7caea7a3b42ab1ab21894ad61b8b14ef1e7c) )
3188	3188	ROM_LOAD32_BYTE( "epr-13958",  0x000002, 0x20000, CRC(7803a027) SHA1(ff659da334e4440a6de9be43dde9dfa21dae5f14) )
r17593	r17594
3218	3218	m_iochip_custom_io_w[0][3] = iowrite_delegate(FUNC(segaxbd_state::generic_iochip0_lamps_w), this);
3219	3219
3220	3220	// point globals to allocated memory regions
3221		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
3222		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
3223	3221	segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
3224	3222	segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
3225	3223	segaic16_roadram_0 = reinterpret_cast<UINT16 *>(memshare("roadram")->ptr());

trunk/src/mame/drivers/segaybd.c

r17593	r17594
725	725	AM_RANGE(0x080000, 0x080007) AM_MIRROR(0x001ff8) AM_DEVREADWRITE("multiplier_subx", sega_315_5248_multiplier_device, read, write)
726	726	AM_RANGE(0x084000, 0x08401f) AM_MIRROR(0x001fe0) AM_DEVREADWRITE("divider_subx", sega_315_5249_divider_device, read, write)
727	727	AM_RANGE(0x0c0000, 0x0cffff) AM_RAM AM_SHARE("shareram")
728		AM_RANGE(0x180000, 0x18ffff) AM_RAM AM_SHARE("spriteram2")
	728	AM_RANGE(0x180000, 0x18ffff) AM_RAM AM_SHARE("ysprites")
729	729	AM_RANGE(0x1f8000, 0x1fbfff) AM_RAM
730	730	AM_RANGE(0x1fc000, 0x1fffff) AM_RAM AM_SHARE("backupram")
731	731	ADDRESS_MAP_END
r17593	r17594
738	738	AM_RANGE(0x084000, 0x08401f) AM_MIRROR(0x001fe0) AM_DEVREADWRITE("divider_suby", sega_315_5249_divider_device, read, write)
739	739	AM_RANGE(0x0c0000, 0x0cffff) AM_RAM AM_SHARE("shareram")
740	740	AM_RANGE(0x180000, 0x1807ff) AM_MIRROR(0x007800) AM_RAM AM_SHARE("rotateram")
741		AM_RANGE(0x188000, 0x188fff) AM_MIRROR(0x007000) AM_RAM AM_SHARE("spriteram")
742		AM_RANGE(0x190000, 0x193fff) AM_MIRROR(0x004000) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_SHARE("paletteram")
	741	AM_RANGE(0x188000, 0x188fff) AM_MIRROR(0x007000) AM_RAM AM_SHARE("bsprites")
	742	AM_RANGE(0x190000, 0x193fff) AM_MIRROR(0x004000) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
743	743	AM_RANGE(0x198000, 0x19ffff) AM_READ_LEGACY(segaic16_rotate_control_0_r)
744	744	AM_RANGE(0x1f0000, 0x1fffff) AM_RAM
745	745	ADDRESS_MAP_END
r17593	r17594
1235	1235	MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1)
1236	1236	MCFG_SCREEN_UPDATE_DRIVER(segaybd_state,screen_update)
1237	1237
1238		MCFG_SEGA16SP_ADD_YBOARD_16B("segaspr1")
1239		MCFG_SEGA16SP_ADD_YBOARD("segaspr2")
	1238	MCFG_SEGA_SYS16B_SPRITES_ADD("bsprites")
	1239	MCFG_SEGA_YBOARD_SPRITES_ADD("ysprites")
1240	1240
1241	1241	MCFG_PALETTE_LENGTH(8192*3)
1242	1242
r17593	r17594
1291	1291	ROM_LOAD16_BYTE( "epr-11816b.54",   0x000000, 0x20000, CRC(317dd0c2) SHA1(7f1c7dcfb111385e2a94912975c2f9bfe78445ac) )
1292	1292	ROM_LOAD16_BYTE( "epr-11815b.53",   0x000001, 0x20000, CRC(f1fb22f1) SHA1(da3ce521b0a19b391913c35af34084d29edceca7) )
1293	1293
1294		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1294	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1295	1295	ROM_LOAD16_BYTE( "mpr-11467.16",   0x000000, 0x20000, CRC(6e60e736) SHA1(73086744cb2fe1ce162f851cb879755c21819b33) )
1296	1296	ROM_LOAD16_BYTE( "mpr-11468.14",   0x000001, 0x20000, CRC(74ca9ca5) SHA1(c6f27ce43ef270088e6155c8240fd15afa5729fd) )
1297	1297	ROM_LOAD16_BYTE( "epr-11694.17",   0x040000, 0x20000, CRC(7e297b84) SHA1(bbf1aa2b0b6b1f9fdaf9bea77d24b7f4f9320696) )
1298	1298	ROM_LOAD16_BYTE( "epr-11695.15",   0x040001, 0x20000, CRC(38a864be) SHA1(ef7d89511713d695f6a454c42f079d3507d9690d) )
1299	1299
1300		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1300	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1301	1301	ROMX_LOAD( "mpr-11469.67",   0x000000, 0x20000, CRC(ed7a2299) SHA1(1aecf9ccba1fed0b7908008e798c522251a08b0f), ROM_SKIP(7) )
1302	1302	ROMX_LOAD( "mpr-11470.75",   0x000001, 0x20000, CRC(34dea550) SHA1(da95b8346c3530573461553629af4cc493bbb4af), ROM_SKIP(7) )
1303	1303	ROMX_LOAD( "mpr-11477.63",   0x000002, 0x20000, CRC(a2784653) SHA1(00a123d1fc8116ca678d6d8dbf1a5450feee014d), ROM_SKIP(7) )
r17593	r17594
1366	1366	ROM_LOAD16_BYTE( "epr-11690a.54",  0x000000, 0x20000, CRC(e18bc177) SHA1(3fb179c9074954fc9b64da1463f542d60a99ec84) )
1367	1367	ROM_LOAD16_BYTE( "epr-11689a.53",  0x000001, 0x20000, CRC(6010e63e) SHA1(00aa5e8516f094409a407744b84ef183393b8b19) )
1368	1368
1369		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1369	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1370	1370	ROM_LOAD16_BYTE( "mpr-11467.16",   0x000000, 0x20000, CRC(6e60e736) SHA1(73086744cb2fe1ce162f851cb879755c21819b33) )
1371	1371	ROM_LOAD16_BYTE( "mpr-11468.14",   0x000001, 0x20000, CRC(74ca9ca5) SHA1(c6f27ce43ef270088e6155c8240fd15afa5729fd) )
1372	1372	ROM_LOAD16_BYTE( "epr-11694.17",   0x040000, 0x20000, CRC(7e297b84) SHA1(bbf1aa2b0b6b1f9fdaf9bea77d24b7f4f9320696) )
1373	1373	ROM_LOAD16_BYTE( "epr-11695.15",   0x040001, 0x20000, CRC(38a864be) SHA1(ef7d89511713d695f6a454c42f079d3507d9690d) )
1374	1374
1375		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1375	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1376	1376	ROMX_LOAD( "mpr-11469.67",   0x000000, 0x20000, CRC(ed7a2299) SHA1(1aecf9ccba1fed0b7908008e798c522251a08b0f), ROM_SKIP(7) )
1377	1377	ROMX_LOAD( "mpr-11470.75",   0x000001, 0x20000, CRC(34dea550) SHA1(da95b8346c3530573461553629af4cc493bbb4af), ROM_SKIP(7) )
1378	1378	ROMX_LOAD( "mpr-11477.63",   0x000002, 0x20000, CRC(a2784653) SHA1(00a123d1fc8116ca678d6d8dbf1a5450feee014d), ROM_SKIP(7) )
r17593	r17594
1441	1441	ROM_LOAD16_BYTE( "epr-11513.54",   0x000000, 0x20000, CRC(e18bc177) SHA1(3fb179c9074954fc9b64da1463f542d60a99ec84) )
1442	1442	ROM_LOAD16_BYTE( "epr-11512.53",   0x000001, 0x20000, CRC(6010e63e) SHA1(00aa5e8516f094409a407744b84ef183393b8b19) )
1443	1443
1444		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1444	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1445	1445	ROM_LOAD16_BYTE( "mpr-11467.16",   0x000000, 0x20000, CRC(6e60e736) SHA1(73086744cb2fe1ce162f851cb879755c21819b33) )
1446	1446	ROM_LOAD16_BYTE( "mpr-11468.14",   0x000001, 0x20000, CRC(74ca9ca5) SHA1(c6f27ce43ef270088e6155c8240fd15afa5729fd) )
1447	1447	ROM_LOAD16_BYTE( "epr-11694.17",   0x040000, 0x20000, CRC(7e297b84) SHA1(bbf1aa2b0b6b1f9fdaf9bea77d24b7f4f9320696) )
1448	1448	ROM_LOAD16_BYTE( "epr-11695.15",   0x040001, 0x20000, CRC(38a864be) SHA1(ef7d89511713d695f6a454c42f079d3507d9690d) )
1449	1449
1450		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1450	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1451	1451	ROMX_LOAD( "mpr-11469.67",   0x000000, 0x20000, CRC(ed7a2299) SHA1(1aecf9ccba1fed0b7908008e798c522251a08b0f), ROM_SKIP(7) )
1452	1452	ROMX_LOAD( "mpr-11470.75",   0x000001, 0x20000, CRC(34dea550) SHA1(da95b8346c3530573461553629af4cc493bbb4af), ROM_SKIP(7) )
1453	1453	ROMX_LOAD( "mpr-11477.63",   0x000002, 0x20000, CRC(a2784653) SHA1(00a123d1fc8116ca678d6d8dbf1a5450feee014d), ROM_SKIP(7) )
r17593	r17594
1523	1523	ROM_LOAD16_BYTE( "epr-13030.54",  0x000000, 0x20000, CRC(81abcabf) SHA1(cb4e817d66a7f384aa9757758c51cd1bf7347dd0) )
1524	1524	ROM_LOAD16_BYTE( "epr-13029.53",  0x000001, 0x20000, CRC(f3638efb) SHA1(f82a46fc8616cbe0235746161c587e54adecfe50) )
1525	1525
1526		ROM_REGION16_BE( 0x200000, "gfx2", 0)
	1526	ROM_REGION16_BE( 0x200000, "bsprites", 0)
1527	1527	ROM_LOAD16_BYTE( "epr-13039.16",  0x000000, 0x80000, CRC(d7e1266d) SHA1(b0fc4cc60a7e876ae2af343bba6da3fb926ea9c5) )
1528	1528	ROM_LOAD16_BYTE( "epr-13037.14",  0x000001, 0x80000, CRC(b801a250) SHA1(7d1f6a1f2022a4f302f22d11fa79057cf8134ad2) )
1529	1529	ROM_LOAD16_BYTE( "epr-13040.17",  0x100000, 0x80000, CRC(4aeb3a85) SHA1(5521fd2d3956839bdbe7b70a9e60cd9fb72a42f1) )
1530	1530	ROM_LOAD16_BYTE( "epr-13038.15",  0x100001, 0x80000, CRC(0b2edb6d) SHA1(04944d6e6f020cd6d33641110847706516630227) )
1531	1531
1532		ROM_REGION64_BE( 0x1000000, "gfx1", 0 )
	1532	ROM_REGION64_BE( 0x1000000, "ysprites", 0 )
1533	1533	ROMX_LOAD( "epr-13048.67",  0x000000, 0x80000, CRC(fe1eb0dd) SHA1(5e292fc0b83505eb289e026d4be24c9038ef1418), ROM_SKIP(7) )
1534	1534	ROMX_LOAD( "epr-13056.75",  0x000001, 0x80000, CRC(5904f8e6) SHA1(fbb01dadc796624c360d44b7631e3f1f285abf2e), ROM_SKIP(7) )
1535	1535	ROMX_LOAD( "epr-13044.63",  0x000002, 0x80000, CRC(4d931f89) SHA1(ff603f4347e4728a2849d9f480893ad0af7abc5c), ROM_SKIP(7) )
r17593	r17594
1592	1592	ROM_LOAD16_BYTE( "epr-13325a.54",  0x000000, 0x20000, CRC(aba307e5) SHA1(a27a7d3699a95d7c6265a23157b2fefd362003dd) )
1593	1593	ROM_LOAD16_BYTE( "epr-13324a.53",  0x000001, 0x20000, CRC(eb1b19e5) SHA1(3d1d7299cb3befc22afc0db0376d7f94dec37367) )
1594	1594
1595		ROM_REGION16_BE( 0x200000, "gfx2", 0)
	1595	ROM_REGION16_BE( 0x200000, "bsprites", 0)
1596	1596	ROM_LOAD16_BYTE( "epr-13039.16",  0x000000, 0x80000, CRC(d7e1266d) SHA1(b0fc4cc60a7e876ae2af343bba6da3fb926ea9c5) )
1597	1597	ROM_LOAD16_BYTE( "epr-13037.14",  0x000001, 0x80000, CRC(b801a250) SHA1(7d1f6a1f2022a4f302f22d11fa79057cf8134ad2) )
1598	1598	ROM_LOAD16_BYTE( "epr-13040.17",  0x100000, 0x80000, CRC(4aeb3a85) SHA1(5521fd2d3956839bdbe7b70a9e60cd9fb72a42f1) )
1599	1599	ROM_LOAD16_BYTE( "epr-13038.15",  0x100001, 0x80000, CRC(0b2edb6d) SHA1(04944d6e6f020cd6d33641110847706516630227) )
1600	1600
1601		ROM_REGION64_BE( 0x1000000, "gfx1", 0 )
	1601	ROM_REGION64_BE( 0x1000000, "ysprites", 0 )
1602	1602	ROMX_LOAD( "epr-13048.67",  0x000000, 0x80000, CRC(fe1eb0dd) SHA1(5e292fc0b83505eb289e026d4be24c9038ef1418), ROM_SKIP(7) )
1603	1603	ROMX_LOAD( "epr-13056.75",  0x000001, 0x80000, CRC(5904f8e6) SHA1(fbb01dadc796624c360d44b7631e3f1f285abf2e), ROM_SKIP(7) )
1604	1604	ROMX_LOAD( "epr-13044.63",  0x000002, 0x80000, CRC(4d931f89) SHA1(ff603f4347e4728a2849d9f480893ad0af7abc5c), ROM_SKIP(7) )
r17593	r17594
1668	1668	ROM_LOAD16_BYTE( "epr-12019a.54", 0x000000, 0x20000, CRC(11188a30) SHA1(42dd0344d92529848b53a8cec4c145237ccd5b51) )
1669	1669	ROM_LOAD16_BYTE( "epr-12018a.53", 0x000001, 0x20000, CRC(1c582e1f) SHA1(c32d2f921554bddd7dedcb81e231aa91f50fa27b) )
1670	1670
1671		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1671	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1672	1672	ROM_LOAD16_BYTE( "epr-11789.16",  0x000000, 0x20000, CRC(b86f8d2b) SHA1(a053f2021841fd0ef89fd3f28050a698b36c435e) )
1673	1673	ROM_LOAD16_BYTE( "epr-11791.14",  0x000001, 0x20000, CRC(36b2910a) SHA1(9948b91837f944a7a606542fa685525e74bbe398) )
1674	1674	ROM_LOAD16_BYTE( "epr-11790.17",  0x040000, 0x20000, CRC(2a564e66) SHA1(5f30fc15bfd017d75cfffe1e9e62ed0bcf32a98e) )
1675	1675	ROM_LOAD16_BYTE( "epr-11792.15",  0x040001, 0x20000, CRC(c85caf6e) SHA1(2411ea99ec7f6e2b0b4f219e86ff2172539ad2c4) )
1676	1676
1677		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1677	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1678	1678	ROMX_LOAD( "epr-11757.67",  0x000000, 0x20000, CRC(e46dc478) SHA1(baf79e230aef3d63fb50373b2b1626f7c56ee94f), ROM_SKIP(7) )
1679	1679	ROMX_LOAD( "epr-11758.75",  0x000001, 0x20000, CRC(5b435c87) SHA1(6b42b08e73957c36cd8faa896ca14461d00afd29), ROM_SKIP(7) )
1680	1680	ROMX_LOAD( "epr-11773.63",  0x000002, 0x20000, CRC(1b5d5758) SHA1(54f58a274740a0566e0553d145c0c284ffd1d36b), ROM_SKIP(7) )
r17593	r17594
1750	1750	ROM_LOAD16_BYTE( "epr-12019.54", 0x000000, 0x20000, CRC(e514d7b6) SHA1(27ae99f5f3e8d2f248916f7a252e2c0686638df5) )
1751	1751	ROM_LOAD16_BYTE( "epr-12018.53", 0x000001, 0x20000, CRC(0a3f7faf) SHA1(fe20a164a7a2c9e9bf0e7aade75b0488bdc93d79) )
1752	1752
1753		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1753	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1754	1754	ROM_LOAD16_BYTE( "epr-11789.16",  0x000000, 0x20000, CRC(b86f8d2b) SHA1(a053f2021841fd0ef89fd3f28050a698b36c435e) )
1755	1755	ROM_LOAD16_BYTE( "epr-11791.14",  0x000001, 0x20000, CRC(36b2910a) SHA1(9948b91837f944a7a606542fa685525e74bbe398) )
1756	1756	ROM_LOAD16_BYTE( "epr-11790.17",  0x040000, 0x20000, CRC(2a564e66) SHA1(5f30fc15bfd017d75cfffe1e9e62ed0bcf32a98e) )
1757	1757	ROM_LOAD16_BYTE( "epr-11792.15",  0x040001, 0x20000, CRC(c85caf6e) SHA1(2411ea99ec7f6e2b0b4f219e86ff2172539ad2c4) )
1758	1758
1759		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1759	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1760	1760	ROMX_LOAD( "epr-11757.67",  0x000000, 0x20000, CRC(e46dc478) SHA1(baf79e230aef3d63fb50373b2b1626f7c56ee94f), ROM_SKIP(7) )
1761	1761	ROMX_LOAD( "epr-11758.75",  0x000001, 0x20000, CRC(5b435c87) SHA1(6b42b08e73957c36cd8faa896ca14461d00afd29), ROM_SKIP(7) )
1762	1762	ROMX_LOAD( "epr-11773.63",  0x000002, 0x20000, CRC(1b5d5758) SHA1(54f58a274740a0566e0553d145c0c284ffd1d36b), ROM_SKIP(7) )
r17593	r17594
1833	1833	ROM_LOAD16_BYTE( "epr-11903.54",  0x000000, 0x20000, CRC(d004f411) SHA1(212a985275647fae24b580ebaffc1230c06318ac) )
1834	1834	ROM_LOAD16_BYTE( "epr-11902.53",  0x000001, 0x20000, CRC(e8028e08) SHA1(de4ee5011e9552e624b6223e0e1ef00bc271a811) )
1835	1835
1836		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1836	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1837	1837	ROM_LOAD16_BYTE( "epr-11789.16",  0x000000, 0x20000, CRC(b86f8d2b) SHA1(a053f2021841fd0ef89fd3f28050a698b36c435e) )
1838	1838	ROM_LOAD16_BYTE( "epr-11791.14",  0x000001, 0x20000, CRC(36b2910a) SHA1(9948b91837f944a7a606542fa685525e74bbe398) )
1839	1839	ROM_LOAD16_BYTE( "epr-11790.17",  0x040000, 0x20000, CRC(2a564e66) SHA1(5f30fc15bfd017d75cfffe1e9e62ed0bcf32a98e) )
1840	1840	ROM_LOAD16_BYTE( "epr-11792.15",  0x040001, 0x20000, CRC(c85caf6e) SHA1(2411ea99ec7f6e2b0b4f219e86ff2172539ad2c4) )
1841	1841
1842		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1842	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1843	1843	ROMX_LOAD( "epr-11757.67",  0x000000, 0x20000, CRC(e46dc478) SHA1(baf79e230aef3d63fb50373b2b1626f7c56ee94f), ROM_SKIP(7) )
1844	1844	ROMX_LOAD( "epr-11758.75",  0x000001, 0x20000, CRC(5b435c87) SHA1(6b42b08e73957c36cd8faa896ca14461d00afd29), ROM_SKIP(7) )
1845	1845	ROMX_LOAD( "epr-11773.63",  0x000002, 0x20000, CRC(1b5d5758) SHA1(54f58a274740a0566e0553d145c0c284ffd1d36b), ROM_SKIP(7) )
r17593	r17594
1919	1919	ROM_LOAD16_BYTE( "epr-11750b.54", 0x000000, 0x20000, CRC(bc14ce30) SHA1(9bbadee0946e0abaac4f0d2625ba5550f11fa8a9) )
1920	1920	ROM_LOAD16_BYTE( "epr-11749b.53", 0x000001, 0x20000, CRC(9e385568) SHA1(74e22eaed645cc80b1eb0c52912186066e58b9d2) )
1921	1921
1922		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	1922	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
1923	1923	ROM_LOAD16_BYTE( "epr-11789.16",  0x000000, 0x20000, CRC(b86f8d2b) SHA1(a053f2021841fd0ef89fd3f28050a698b36c435e) )
1924	1924	ROM_LOAD16_BYTE( "epr-11791.14",  0x000001, 0x20000, CRC(36b2910a) SHA1(9948b91837f944a7a606542fa685525e74bbe398) )
1925	1925	ROM_LOAD16_BYTE( "epr-11790.17",  0x040000, 0x20000, CRC(2a564e66) SHA1(5f30fc15bfd017d75cfffe1e9e62ed0bcf32a98e) )
1926	1926	ROM_LOAD16_BYTE( "epr-11792.15",  0x040001, 0x20000, CRC(c85caf6e) SHA1(2411ea99ec7f6e2b0b4f219e86ff2172539ad2c4) )
1927	1927
1928		ROM_REGION64_BE( 0x400000, "gfx1", 0)
	1928	ROM_REGION64_BE( 0x400000, "ysprites", 0)
1929	1929	ROMX_LOAD( "epr-11757.67",  0x000000, 0x20000, CRC(e46dc478) SHA1(baf79e230aef3d63fb50373b2b1626f7c56ee94f), ROM_SKIP(7) )
1930	1930	ROMX_LOAD( "epr-11758.75",  0x000001, 0x20000, CRC(5b435c87) SHA1(6b42b08e73957c36cd8faa896ca14461d00afd29), ROM_SKIP(7) )
1931	1931	ROMX_LOAD( "epr-11773.63",  0x000002, 0x20000, CRC(1b5d5758) SHA1(54f58a274740a0566e0553d145c0c284ffd1d36b), ROM_SKIP(7) )
r17593	r17594
2009	2009	ROM_LOAD16_BYTE( "epr-14092.54",  0x000000, 0x20000, CRC(18eb23c5) SHA1(53e5681c7450a3879ed80c1680168d6295caa887) )
2010	2010	ROM_LOAD16_BYTE( "epr-14091.53",  0x000001, 0x20000, CRC(72a56f71) SHA1(d45d3072ea92b5dde5c70138e56e7f0ca248880e) )
2011	2011
2012		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	2012	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
2013	2013	ROM_LOAD16_BYTE( "mpr-13999.16", 0x000000, 0x40000, CRC(9a1dd53c) SHA1(cb01f2c64554914ea693879dfcb498181a1e7a9a) )
2014	2014	ROM_LOAD16_BYTE( "mpr-13997.14", 0x000001, 0x40000, CRC(1fdf1b87) SHA1(ed46af0f72081d545015b73a8d12240664f29506) )
2015	2015
2016		ROM_REGION64_BE( 0xc00000, "gfx1", 0)
	2016	ROM_REGION64_BE( 0xc00000, "ysprites", 0)
2017	2017	ROMX_LOAD( "mpr-14021.67",  0x000000, 0x80000, CRC(9fa88781) SHA1(a035fd0fe1d37a589adf3a5029c20d237d5cc827), ROM_SKIP(7) )
2018	2018	ROMX_LOAD( "mpr-14022.75",  0x000001, 0x80000, CRC(49e824bb) SHA1(c1330719b5718aa664b5788244d8cb7b7103a57c), ROM_SKIP(7) )
2019	2019	ROMX_LOAD( "mpr-14009.63",  0x000002, 0x80000, CRC(35b5187e) SHA1(6f0f6471c4135d07a2c852cdc50322b99176712e), ROM_SKIP(7) )
r17593	r17594
2069	2069	ROM_LOAD16_BYTE( "epr-13990.54.verify",  0x000000, 0x20000, CRC(18eb23c5) SHA1(53e5681c7450a3879ed80c1680168d6295caa887) ) // Need to verify EPR #, same as epr-14092.54 above
2070	2070	ROM_LOAD16_BYTE( "epr-13989.53.verify",  0x000001, 0x20000, CRC(8f4f824e) SHA1(d470f23ce2dca4e75b7b714175d47338c41bb721) ) // Need to verify EPR #
2071	2071
2072		ROM_REGION16_BE( 0x080000, "gfx2", 0 )
	2072	ROM_REGION16_BE( 0x080000, "bsprites", 0 )
2073	2073	ROM_LOAD16_BYTE( "mpr-13999.16", 0x000000, 0x40000, CRC(9a1dd53c) SHA1(cb01f2c64554914ea693879dfcb498181a1e7a9a) )
2074	2074	ROM_LOAD16_BYTE( "mpr-13997.14", 0x000001, 0x40000, CRC(1fdf1b87) SHA1(ed46af0f72081d545015b73a8d12240664f29506) )
2075	2075
2076		ROM_REGION64_BE( 0xc00000, "gfx1", 0)
	2076	ROM_REGION64_BE( 0xc00000, "ysprites", 0)
2077	2077	ROMX_LOAD( "mpr-14021.67",  0x000000, 0x80000, CRC(9fa88781) SHA1(a035fd0fe1d37a589adf3a5029c20d237d5cc827), ROM_SKIP(7) )
2078	2078	ROMX_LOAD( "mpr-14022.75",  0x000001, 0x80000, CRC(49e824bb) SHA1(c1330719b5718aa664b5788244d8cb7b7103a57c), ROM_SKIP(7) )
2079	2079	ROMX_LOAD( "mpr-14009.63",  0x000002, 0x80000, CRC(35b5187e) SHA1(6f0f6471c4135d07a2c852cdc50322b99176712e), ROM_SKIP(7) )
r17593	r17594
2132	2132	ROM_LOAD16_BYTE( "epr-13828.54",  0x000000, 0x20000, CRC(2470cf5f) SHA1(eb1a732228fe7ad9cf0747d2b53e391c5a733667) )
2133	2133	ROM_LOAD16_BYTE( "epr-13827.53",  0x000001, 0x20000, CRC(a9d0cf7d) SHA1(c40c73c9e9105ed6503b77b65a6423a26057d810) )
2134	2134
2135		ROM_REGION16_BE( 0x200000, "gfx2", 0)
	2135	ROM_REGION16_BE( 0x200000, "bsprites", 0)
2136	2136	ROM_LOAD16_BYTE( "epr-13833.16",  0x000000, 0x80000, CRC(6148e11a) SHA1(5802208cf0415f6af39de162e9f12e7c205915f7) )
2137	2137	ROM_LOAD16_BYTE( "epr-13832.14",  0x000001, 0x80000, CRC(41679754) SHA1(58d46f33a4318bbc9e2a20eb5550a66ee0b2e62f) )
2138	2138	ROM_LOAD16_BYTE( "epr-13040.17",  0x100000, 0x80000, CRC(4aeb3a85) SHA1(5521fd2d3956839bdbe7b70a9e60cd9fb72a42f1) )
2139	2139	ROM_LOAD16_BYTE( "epr-13038.15",  0x100001, 0x80000, CRC(0b2edb6d) SHA1(04944d6e6f020cd6d33641110847706516630227) )
2140	2140
2141		ROM_REGION64_BE( 0x1000000, "gfx1", 0 )
	2141	ROM_REGION64_BE( 0x1000000, "ysprites", 0 )
2142	2142	ROMX_LOAD( "epr-13048.67",  0x000000, 0x80000, CRC(fe1eb0dd) SHA1(5e292fc0b83505eb289e026d4be24c9038ef1418), ROM_SKIP(7) )
2143	2143	ROMX_LOAD( "epr-13056.75",  0x000001, 0x80000, CRC(5904f8e6) SHA1(fbb01dadc796624c360d44b7631e3f1f285abf2e), ROM_SKIP(7) )
2144	2144	ROMX_LOAD( "epr-13044.63",  0x000002, 0x80000, CRC(4d931f89) SHA1(ff603f4347e4728a2849d9f480893ad0af7abc5c), ROM_SKIP(7) )
r17593	r17594
2200	2200	m_scanline_timer = timer_alloc(TID_IRQ2_GEN);
2201	2201
2202	2202	// point globals to allocated memory regions
2203		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
2204		segaic16_spriteram_1 = reinterpret_cast<UINT16 *>(memshare("spriteram2")->ptr());
2205		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
2206	2203	segaic16_rotateram_0 = reinterpret_cast<UINT16 *>(memshare("rotateram")->ptr());
2207	2204
2208	2205	// save state

trunk/src/mame/drivers/segas16a.c

r17593	r17594
233	233
234	234	// bit 7: screen flip
235	235	segaic16_tilemap_set_flip(machine(), 0, data & 0x80);
236		segaic16_sprites_set_flip(machine(), 0, data & 0x80);
	236	m_sprites->set_flip(data & 0x80);
237	237
238	238	// bit 6: set 8751 interrupt line
239	239	if (m_mcu != NULL)
r17593	r17594
1007	1007	AM_RANGE(0x000000, 0x03ffff) AM_MIRROR(0x380000) AM_ROM
1008	1008	AM_RANGE(0x400000, 0x407fff) AM_MIRROR(0xb88000) AM_RAM_WRITE_LEGACY(segaic16_tileram_0_w) AM_SHARE("tileram")
1009	1009	AM_RANGE(0x410000, 0x410fff) AM_MIRROR(0xb8f000) AM_RAM_WRITE_LEGACY(segaic16_textram_0_w) AM_SHARE("textram")
1010		AM_RANGE(0x440000, 0x4407ff) AM_MIRROR(0x3bf800) AM_RAM AM_SHARE("spriteram")
1011		AM_RANGE(0x840000, 0x840fff) AM_MIRROR(0x3bf000) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_SHARE("paletteram")
	1010	AM_RANGE(0x440000, 0x4407ff) AM_MIRROR(0x3bf800) AM_RAM AM_SHARE("sprites")
	1011	AM_RANGE(0x840000, 0x840fff) AM_MIRROR(0x3bf000) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
1012	1012	AM_RANGE(0xc40000, 0xc43fff) AM_MIRROR(0x39c000) AM_READWRITE(misc_io_r, misc_io_w)
1013	1013	AM_RANGE(0xc60000, 0xc6ffff) AM_READ(watchdog_reset16_r)
1014	1014	AM_RANGE(0xc70000, 0xc73fff) AM_MIRROR(0x38c000) AM_RAM AM_SHARE("nvram")
r17593	r17594
1969	1969	MCFG_SCREEN_VISIBLE_AREA(0*8, 40*8-1, 0*8, 28*8-1)
1970	1970	MCFG_SCREEN_UPDATE_DRIVER(segas16a_state, screen_update)
1971	1971
1972		MCFG_SEGA16SP_ADD_16A("segaspr1")
	1972	MCFG_SEGA_SYS16A_SPRITES_ADD("sprites")
1973	1973
1974	1974	MCFG_GFXDECODE(segas16a)
1975	1975	MCFG_PALETTE_LENGTH(2048*3)
r17593	r17594
2075	2075	ROM_LOAD( "epr-11576.94", 0x10000, 0x10000, CRC(067ed682) SHA1(13e2e1f812e5a3994a0f1d35eb210881645e74cd) )
2076	2076	ROM_LOAD( "epr-11577.93", 0x20000, 0x10000, CRC(f67cf331) SHA1(457b9e618dfa678ae374cdeb25488af3de2e8949) )
2077	2077
2078		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2078	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2079	2079	ROM_LOAD16_BYTE( "epr-11501.10", 0x00001, 0x08000, CRC(09179ead) SHA1(3e6bf04e1e9ea867d087a47ff04ad0a064a8e299) )
2080	2080	ROM_CONTINUE(                    0x40001, 0x08000 )
2081	2081	ROM_LOAD16_BYTE( "epr-11505.11", 0x00000, 0x08000, CRC(b67f1ecf) SHA1(3a26cdf91e5a1a11c1a8857e713a9e00cc1bfce0) )
r17593	r17594
2127	2127	ROM_LOAD( "epr-10282.94", 0x10000, 0x10000, CRC(b67b8910) SHA1(f3f029a3e6547114cec28e5cf8fda65ef434c353) )
2128	2128	ROM_LOAD( "epr-10283.93", 0x20000, 0x10000, CRC(e7dbfd2d) SHA1(91bae3fbc4a3c612dc507eecfa8de1c2e1e7afee) )
2129	2129
2130		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites
	2130	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites
2131	2131	ROM_LOAD16_BYTE( "epr-10285", 0x00001, 0x08000, CRC(98aa3d04) SHA1(1d26d17a72e55281e3444fee9c5af69ffb9e3c69) )
2132	2132	ROM_LOAD16_BYTE( "epr-10286", 0x10001, 0x08000, CRC(8da050cf) SHA1(c28e8968dbd9c110672581f4486f70d5f45df7f5) )
2133	2133	ROM_LOAD16_BYTE( "epr-10287", 0x20001, 0x08000, CRC(7989b74a) SHA1(a87acafe82b37a11d8f8b1f2ee4c9b2e1bb8161c) )
r17593	r17594
2163	2163	ROM_LOAD( "epr-10432.94", 0x08000, 0x08000, CRC(db8cd24e) SHA1(656d98844ad9ccaa68e3f501137dddd0a27d999d) )
2164	2164	ROM_LOAD( "epr-10433.93", 0x10000, 0x08000, CRC(e163c8c2) SHA1(ac54c5ecedca5b1a2c550de32687ca57c4d3a411) )
2165	2165
2166		ROM_REGION16_BE( 0x040000, "gfx2", 0 ) // sprites
	2166	ROM_REGION16_BE( 0x040000, "sprites", 0 ) // sprites
2167	2167	ROM_LOAD16_BYTE( "epr-10437.10", 0x00001, 0x8000, CRC(522f7618) SHA1(9a6bc857dfef1dd1b7bffa034523c1c4cd8b3f4c) )
2168	2168	ROM_LOAD16_BYTE( "epr-10441.11", 0x00000, 0x8000, CRC(74e3a35c) SHA1(26b980a0a3aee94ac38e0e0c7d305bb35a60d1c4) )
2169	2169	ROM_LOAD16_BYTE( "epr-10438.17", 0x10001, 0x8000, CRC(738a6362) SHA1(a3c5f10c263cb216d275875f6333484a1cca281b) )
r17593	r17594
2200	2200	ROM_LOAD( "epr-10432.94", 0x08000, 0x08000, CRC(db8cd24e) SHA1(656d98844ad9ccaa68e3f501137dddd0a27d999d) )
2201	2201	ROM_LOAD( "epr-10433.93", 0x10000, 0x08000, CRC(e163c8c2) SHA1(ac54c5ecedca5b1a2c550de32687ca57c4d3a411) )
2202	2202
2203		ROM_REGION16_BE( 0x040000, "gfx2", 0 ) // sprites
	2203	ROM_REGION16_BE( 0x040000, "sprites", 0 ) // sprites
2204	2204	ROM_LOAD16_BYTE( "epr-10437.10", 0x00001, 0x8000, CRC(522f7618) SHA1(9a6bc857dfef1dd1b7bffa034523c1c4cd8b3f4c) )
2205	2205	ROM_LOAD16_BYTE( "epr-10441.11", 0x00000, 0x8000, CRC(74e3a35c) SHA1(26b980a0a3aee94ac38e0e0c7d305bb35a60d1c4) )
2206	2206	ROM_LOAD16_BYTE( "epr-10438.17", 0x10001, 0x8000, CRC(738a6362) SHA1(a3c5f10c263cb216d275875f6333484a1cca281b) )
r17593	r17594
2245	2245	ROM_LOAD( "epr-10740.94", 0x10000, 0x10000, CRC(47f93015) SHA1(68247a6bffd1d4d1c450148dd46214d01ce1c668) )
2246	2246	ROM_LOAD( "epr-10741.93", 0x20000, 0x10000, CRC(4970739c) SHA1(5bdf4222209ec46e0015bfc0f90578dd9b30bdd1) )
2247	2247
2248		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2248	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2249	2249	ROM_LOAD16_BYTE( "epr-10709.10", 0x00001, 0x08000, CRC(addf0a90) SHA1(a92c9531f1817763773471ce63f566b9e88360a0) )
2250	2250	ROM_CONTINUE(                    0x40001, 0x08000 )
2251	2251	ROM_LOAD16_BYTE( "epr-10713.11", 0x00000, 0x08000, CRC(ececde3a) SHA1(9c12d4665179bf433c42f5ddc8a043ad592aa90e) )
r17593	r17594
2296	2296	ROM_LOAD( "10740", 0x10000, 0x10000, CRC(47f93015) SHA1(68247a6bffd1d4d1c450148dd46214d01ce1c668) )
2297	2297	ROM_LOAD( "10741", 0x20000, 0x10000, CRC(4970739c) SHA1(5bdf4222209ec46e0015bfc0f90578dd9b30bdd1) )
2298	2298
2299		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2299	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2300	2300	ROM_LOAD16_BYTE( "10709.b1", 0x00001, 0x08000, CRC(addf0a90) SHA1(a92c9531f1817763773471ce63f566b9e88360a0) )
2301	2301	ROM_CONTINUE(                0x40001, 0x08000 )
2302	2302	ROM_LOAD16_BYTE( "10713.b5", 0x00000, 0x08000, CRC(ececde3a) SHA1(9c12d4665179bf433c42f5ddc8a043ad592aa90e) )
r17593	r17594
2347	2347	ROM_LOAD( "epr-10740.94", 0x10000, 0x10000, CRC(47f93015) SHA1(68247a6bffd1d4d1c450148dd46214d01ce1c668) )
2348	2348	ROM_LOAD( "epr-10741.93", 0x20000, 0x10000, CRC(4970739c) SHA1(5bdf4222209ec46e0015bfc0f90578dd9b30bdd1) )
2349	2349
2350		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2350	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2351	2351	ROM_LOAD16_BYTE( "epr-10709.10", 0x00001, 0x08000, CRC(addf0a90) SHA1(a92c9531f1817763773471ce63f566b9e88360a0) )
2352	2352	ROM_CONTINUE(                    0x40001, 0x08000 )
2353	2353	ROM_LOAD16_BYTE( "epr-10713.11", 0x00000, 0x08000, CRC(ececde3a) SHA1(9c12d4665179bf433c42f5ddc8a043ad592aa90e) )
r17593	r17594
2402	2402	ROM_LOAD( "epr-10322.c10", 0x08000, 0x8000, CRC(b53d3217) SHA1(baebf20925e9f8ab6660f041a24721716d5b7d92) )
2403	2403	ROM_LOAD( "epr-10323.c11", 0x10000, 0x8000, CRC(915a3e61) SHA1(6504a8b26b7b4880971cd69ac2c8aae30dcfa18c) )
2404	2404
2405		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites
	2405	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites
2406	2406	ROM_LOAD16_BYTE( "epr-10012.c5",  0x00001, 0x08000, CRC(990824e8) SHA1(bd45f75d07cb4e17583c2d76050e5f819f4b7efe) )
2407	2407	ROM_LOAD16_BYTE( "epr-10016.b2",  0x00000, 0x08000, CRC(af5dc72f) SHA1(97bbb76940c702e642d8222dda71447b8f60b616) )
2408	2408	ROM_LOAD16_BYTE( "epr-10013.c6",  0x10001, 0x08000, CRC(9a0919c5) SHA1(e39e60c1e834b3b46bf2ef1c5952841bebe66ade) )
r17593	r17594
2447	2447	ROM_LOAD( "epr-7708a.c10", 0x08000, 0x8000, CRC(411be9a4) SHA1(808a9c941d353f34c3491ca2cde984e73cc7a87d) )
2448	2448	ROM_LOAD( "epr-7709a.c11", 0x10000, 0x8000, CRC(74ceb5a8) SHA1(93ed6bb4a3c820f3a7ee5e9b2c2ce35d2bed8529) )
2449	2449
2450		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites
	2450	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites
2451	2451	ROM_LOAD16_BYTE( "epr-7715.c5",  0x00001, 0x08000, CRC(bf47e040) SHA1(5aa1b9adaa2095844c10993402a0597bb5768efb) )
2452	2452	ROM_LOAD16_BYTE( "epr-7719.b2",  0x00000, 0x08000, CRC(fa5c5d6c) SHA1(6cac5d3fd705d1365348d57a18bbeb1eb9e412b8) )
2453	2453	ROM_LOAD16_BYTE( "epr-10013.c6", 0x10001, 0x08000, CRC(9a0919c5) SHA1(e39e60c1e834b3b46bf2ef1c5952841bebe66ade) )   // 7716
r17593	r17594
2494	2494	ROM_LOAD( "epr-7389.94",  0x08000, 0x08000, CRC(2f4f71b8) SHA1(ceb39e95cd43904b8e4f89c7227491e139fb3ca6) )
2495	2495	ROM_LOAD( "epr-7390.93",  0x10000, 0x08000, CRC(d90609c6) SHA1(4232f6ecb21f242c0c8d81e06b88bc742668609f) )
2496	2496
2497		ROM_REGION16_BE( 0x30000, "gfx2", 0 ) // sprites
	2497	ROM_REGION16_BE( 0x30000, "sprites", 0 ) // sprites
2498	2498	ROM_LOAD16_BYTE( "epr-7392.10",  0x00001, 0x8000, CRC(5bb7c8b6) SHA1(eaa0ed63ac4f66ee285757e842bdd7b005292600) )
2499	2499	ROM_LOAD16_BYTE( "epr-7396.11",  0x00000, 0x8000, CRC(74ae4b57) SHA1(1f24b1faea765994b85f0e7ac8e944c8da22103f) )
2500	2500	ROM_LOAD16_BYTE( "epr-7393.17",  0x10001, 0x8000, CRC(14fc7e82) SHA1(ca7caca989a3577dd30ad4f66b0fcce712a454ef) )
r17593	r17594
2524	2524	ROM_LOAD( "epr-7389.94",  0x08000, 0x08000, CRC(2f4f71b8) SHA1(ceb39e95cd43904b8e4f89c7227491e139fb3ca6) )
2525	2525	ROM_LOAD( "epr-7390.93",  0x10000, 0x08000, CRC(d90609c6) SHA1(4232f6ecb21f242c0c8d81e06b88bc742668609f) )
2526	2526
2527		ROM_REGION16_BE( 0x30000, "gfx2", 0 ) // sprites
	2527	ROM_REGION16_BE( 0x30000, "sprites", 0 ) // sprites
2528	2528	ROM_LOAD16_BYTE( "epr-7392.10",  0x00001, 0x8000, CRC(5bb7c8b6) SHA1(eaa0ed63ac4f66ee285757e842bdd7b005292600) )
2529	2529	ROM_LOAD16_BYTE( "epr-7396.11",  0x00000, 0x8000, CRC(74ae4b57) SHA1(1f24b1faea765994b85f0e7ac8e944c8da22103f) )
2530	2530	ROM_LOAD16_BYTE( "epr-7393.17",  0x10001, 0x8000, CRC(14fc7e82) SHA1(ca7caca989a3577dd30ad4f66b0fcce712a454ef) )
r17593	r17594
2554	2554	ROM_LOAD( "epr-7389.94",  0x08000, 0x08000, CRC(2f4f71b8) SHA1(ceb39e95cd43904b8e4f89c7227491e139fb3ca6) )
2555	2555	ROM_LOAD( "epr-7390.93",  0x10000, 0x08000, CRC(d90609c6) SHA1(4232f6ecb21f242c0c8d81e06b88bc742668609f) )
2556	2556
2557		ROM_REGION16_BE( 0x30000, "gfx2", 0 ) // sprites
	2557	ROM_REGION16_BE( 0x30000, "sprites", 0 ) // sprites
2558	2558	ROM_LOAD16_BYTE( "epr-7392.10",  0x00001, 0x8000, CRC(5bb7c8b6) SHA1(eaa0ed63ac4f66ee285757e842bdd7b005292600) )
2559	2559	ROM_LOAD16_BYTE( "epr-7396.11",  0x00000, 0x8000, CRC(74ae4b57) SHA1(1f24b1faea765994b85f0e7ac8e944c8da22103f) )
2560	2560	ROM_LOAD16_BYTE( "epr-7393.17",  0x10001, 0x8000, CRC(14fc7e82) SHA1(ca7caca989a3577dd30ad4f66b0fcce712a454ef) )
r17593	r17594
2587	2587	ROM_LOAD( "epr-7052.10a", 0x08000, 0x08000, CRC(2550db0e) SHA1(28f8d68f43d26f12793fe295c205cc86adc4e96a) )
2588	2588	ROM_LOAD( "epr-7053.11a", 0x10000, 0x08000, CRC(5bfea038) SHA1(01dc6e14cc7bba9f7930e68573c441fa2841f49a) )
2589	2589
2590		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites
	2590	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites
2591	2591	ROM_LOAD16_BYTE( "epr-7055.5a", 0x00001, 0x8000, CRC(1fb860bd) SHA1(4a4155d0352dfae9e402a2b2f1558ef17b1303b4) )
2592	2592	ROM_LOAD16_BYTE( "epr-7059.2b", 0x00000, 0x8000, CRC(3d14091d) SHA1(36208415b2012b6e948fefa15b0f7041748066be) )
2593	2593	ROM_LOAD16_BYTE( "epr-7056.6a", 0x10001, 0x8000, CRC(b35dd968) SHA1(e306b5e38acf583d7b2089302622ad25ae5564b0) )
r17593	r17594
2630	2630	ROM_LOAD( "epr-11835.94", 0x10000, 0x10000, CRC(6a07acc0) SHA1(218071612ee6fa89b16a47a77325a962ba38926d) )
2631	2631	ROM_LOAD( "epr-11836.93", 0x20000, 0x10000, CRC(93c74928) SHA1(43ea7855d5d4dcc4921b3a7b814acc75c5cfde15) )
2632	2632
2633		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2633	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2634	2634	ROM_LOAD16_BYTE( "epr-11842.10", 0x00001, 0x08000, CRC(b6e94727) SHA1(0838e034f1f10d9cd1312c8c94b5c57387c0c271) )
2635	2635	ROM_CONTINUE(                    0x40001, 0x08000 )
2636	2636	ROM_LOAD16_BYTE( "epr-11845.11", 0x00000, 0x08000, CRC(17e8d5d5) SHA1(ac1074b0a705be13c6e3391441e6cfec1d2b3f8a) )
r17593	r17594
2679	2679	ROM_LOAD( "epr-7462.10c", 0x08000, 0x08000, CRC(7914af28) SHA1(4bf59fe4a0b0aa5d4cc0b6f9375ffab3c96e8a2b) )
2680	2680	ROM_LOAD( "epr-7463.11c", 0x10000, 0x08000, CRC(827c5603) SHA1(8db3bd6eae5aeeb229e017471049ef5347974df5) )
2681	2681
2682		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites  - the same as quartet 2
	2682	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites  - the same as quartet 2
2683	2683	ROM_LOAD16_BYTE( "epr-7465.5c",  0x00001, 0x8000, CRC(8a1ab7d7) SHA1(a2f317538c70a1603b65d795223407cbaaf88524) )
2684	2684	ROM_LOAD16_BYTE( "epr-7469.2b",  0x00000, 0x8000, CRC(cb65ae4f) SHA1(3ee7b3b4cce113a6f394e8dfd317cdb6ffae64f7) )
2685	2685	ROM_LOAD16_BYTE( "epr-7466.6c",  0x10001, 0x8000, CRC(b2d3f4f3) SHA1(65e654fde10bee4cb5eee8234d0babb78fe41cfb) )
r17593	r17594
2729	2729	ROM_LOAD( "epr-7462.10c", 0x08000, 0x08000, CRC(7914af28) SHA1(4bf59fe4a0b0aa5d4cc0b6f9375ffab3c96e8a2b) )
2730	2730	ROM_LOAD( "epr-7463.11c", 0x10000, 0x08000, CRC(827c5603) SHA1(8db3bd6eae5aeeb229e017471049ef5347974df5) )
2731	2731
2732		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites  - the same as quartet 2
	2732	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites  - the same as quartet 2
2733	2733	ROM_LOAD16_BYTE( "epr-7465.5c",  0x00001, 0x8000, CRC(8a1ab7d7) SHA1(a2f317538c70a1603b65d795223407cbaaf88524) )
2734	2734	ROM_LOAD16_BYTE( "epr-7469.2b",  0x00000, 0x8000, CRC(cb65ae4f) SHA1(3ee7b3b4cce113a6f394e8dfd317cdb6ffae64f7) )
2735	2735	ROM_LOAD16_BYTE( "epr-7466.6c",  0x10001, 0x8000, CRC(b2d3f4f3) SHA1(65e654fde10bee4cb5eee8234d0babb78fe41cfb) )
r17593	r17594
2785	2785	ROM_LOAD( "epr-7699.c10", 0x08000, 0x08000, CRC(77ec901d) SHA1(b5961895473c16a8f4a111185cce48b05ab66885) )
2786	2786	ROM_LOAD( "epr-7700.c11", 0x10000, 0x08000, CRC(7e348cce) SHA1(82bba65280faaf3280208c85caef48ec8baeade8) )
2787	2787
2788		ROM_REGION16_BE( 0x040000, "gfx2", 0 ) // sprites
	2788	ROM_REGION16_BE( 0x040000, "sprites", 0 ) // sprites
2789	2789	ROM_LOAD16_BYTE( "epr-7465.5c",  0x00001, 0x8000, CRC(8a1ab7d7) SHA1(a2f317538c70a1603b65d795223407cbaaf88524) )
2790	2790	ROM_LOAD16_BYTE( "epr-7469.2b",  0x00000, 0x8000, CRC(cb65ae4f) SHA1(3ee7b3b4cce113a6f394e8dfd317cdb6ffae64f7) )
2791	2791	ROM_LOAD16_BYTE( "epr-7466.6c",  0x10001, 0x8000, CRC(b2d3f4f3) SHA1(65e654fde10bee4cb5eee8234d0babb78fe41cfb) )
r17593	r17594
2829	2829	ROM_LOAD( "epr-7699.c10", 0x08000, 0x08000, CRC(77ec901d) SHA1(b5961895473c16a8f4a111185cce48b05ab66885) )
2830	2830	ROM_LOAD( "epr-7700.c11", 0x10000, 0x08000, CRC(7e348cce) SHA1(82bba65280faaf3280208c85caef48ec8baeade8) )
2831	2831
2832		ROM_REGION16_BE( 0x040000, "gfx2", 0 ) // sprites
	2832	ROM_REGION16_BE( 0x040000, "sprites", 0 ) // sprites
2833	2833	ROM_LOAD16_BYTE( "epr-7465.5c",  0x00001, 0x8000, CRC(8a1ab7d7) SHA1(a2f317538c70a1603b65d795223407cbaaf88524) )
2834	2834	ROM_LOAD16_BYTE( "epr-7469.2b",  0x00000, 0x8000, CRC(cb65ae4f) SHA1(3ee7b3b4cce113a6f394e8dfd317cdb6ffae64f7) )
2835	2835	ROM_LOAD16_BYTE( "epr-7466.6c",  0x10001, 0x8000, CRC(b2d3f4f3) SHA1(65e654fde10bee4cb5eee8234d0babb78fe41cfb) )
r17593	r17594
2873	2873	ROM_LOAD( "epr-10757.94", 0x10000, 0x10000, CRC(497e1740) SHA1(95b166a9db46a27087e417c1b2cbb76bee2e64a7) )
2874	2874	ROM_LOAD( "epr-10758.93", 0x20000, 0x10000, CRC(61d61486) SHA1(d48ff87216947b78903cd98a10436babdf8b75a0) )
2875	2875
2876		ROM_REGION16_BE( 0x70000, "gfx2", 0 ) // sprites
	2876	ROM_REGION16_BE( 0x70000, "sprites", 0 ) // sprites
2877	2877	ROM_LOAD16_BYTE( "epr-10760.10", 0x00001, 0x08000, CRC(30e2c50a) SHA1(1fb9e69d4cb97fdcb0f98c2a7ede246aaa4ac382) )
2878	2878	ROM_CONTINUE(                    0x40001, 0x08000 )
2879	2879	ROM_LOAD16_BYTE( "epr-10763.11", 0x00000, 0x08000, CRC(794e3e8b) SHA1(91ca1cb9aabf99adc8426feed4494a992afb8c4a) )
r17593	r17594
2913	2913	ROM_LOAD( "epr-11265.94", 0x10000, 0x10000, CRC(87d0f321) SHA1(885b38eaff2dcaeab4eeaa20cc8a2885d520abd6) )
2914	2914	ROM_LOAD( "epr-11266.93", 0x20000, 0x10000, CRC(efb4af87) SHA1(0b8a905023e1bc808fd2b1c3cfa3778cde79e659) )
2915	2915
2916		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2916	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2917	2917	ROM_LOAD16_BYTE( "epr-11290.10", 0x00001, 0x08000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
2918	2918	ROM_CONTINUE(                    0x40001, 0x08000 )
2919	2919	ROM_LOAD16_BYTE( "epr-11294.11", 0x00000, 0x08000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
r17593	r17594
2956	2956	ROM_LOAD( "b6", 0x10000, 0x10000, CRC(87d0f321) SHA1(885b38eaff2dcaeab4eeaa20cc8a2885d520abd6) )
2957	2957	ROM_LOAD( "b7", 0x20000, 0x10000, CRC(efb4af87) SHA1(0b8a905023e1bc808fd2b1c3cfa3778cde79e659) )
2958	2958
2959		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	2959	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
2960	2960	ROM_LOAD16_BYTE( "b10", 0x00001, 0x08000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
2961	2961	ROM_CONTINUE(           0x40001, 0x08000 )
2962	2962	ROM_LOAD16_BYTE( "b14", 0x00000, 0x08000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
r17593	r17594
3003	3003	ROM_LOAD( "7.4b", 0x10000, 0x10000, CRC(87d0f321) SHA1(885b38eaff2dcaeab4eeaa20cc8a2885d520abd6) )
3004	3004	ROM_LOAD( "6.5b", 0x20000, 0x10000, CRC(efb4af87) SHA1(0b8a905023e1bc808fd2b1c3cfa3778cde79e659) )
3005	3005
3006		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	3006	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
3007	3007	ROM_LOAD16_BYTE( "9.6r",  0x00001, 0x08000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
3008	3008	ROM_CONTINUE(             0x40001, 0x08000 )
3009	3009	ROM_LOAD16_BYTE( "13.8r", 0x00000, 0x08000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
r17593	r17594
3056	3056	ROM_LOAD( "epr-11265.94", 0x10000, 0x10000, CRC(87d0f321) SHA1(885b38eaff2dcaeab4eeaa20cc8a2885d520abd6) )
3057	3057	ROM_LOAD( "epr-11266.93", 0x20000, 0x10000, CRC(efb4af87) SHA1(0b8a905023e1bc808fd2b1c3cfa3778cde79e659) )
3058	3058
3059		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	3059	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
3060	3060	ROM_LOAD16_BYTE( "epr-11290.10", 0x00001, 0x08000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
3061	3061	ROM_CONTINUE(                    0x40001, 0x08000 )
3062	3062	ROM_LOAD16_BYTE( "epr-11294.11", 0x00000, 0x08000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
r17593	r17594
3114	3114	ROM_LOAD( "12226-93.b11", 0x10000, 0x08000, CRC(210e6999) SHA1(5707cc613060b0070a822850b9afab8293f64dd7) )
3115	3115	//(epr- xxxxx - S16a location . S16b location
3116	3116
3117		ROM_REGION16_BE( 0x80000, "gfx2", ROMREGION_ERASE00 ) // sprites
	3117	ROM_REGION16_BE( 0x80000, "sprites", ROMREGION_ERASE00 ) // sprites
3118	3118	ROM_LOAD16_BYTE( "12232-10.b1", 0x00001, 0x08000, CRC(0adec62b) SHA1(cd798a7994cea73bffe78feac4e692d755074b1d) )
3119	3119	ROM_CONTINUE(                   0x40001, 0x08000 )
3120	3120	ROM_LOAD16_BYTE( "12236-11.b5", 0x00000, 0x08000, CRC(286b9af8) SHA1(085251b8ce8b7fadf15b8ebd5872f0337adf142b) )
r17593	r17594
3197	3197	ROM_LOAD( "epr-12203.rom", 0x10000, 0x10000, CRC(a6e58ec5) SHA1(5a6c43c989768270e0ab61cfaa5ef86d4607fe20) )
3198	3198	ROM_LOAD( "epr-12204.rom", 0x20000, 0x10000, CRC(0ae98e23) SHA1(f067b81b85f9e03a6373c7c53ff52d5395b8a985) )
3199	3199
3200		ROM_REGION16_BE( 0x10000, "gfx2", 0 ) // sprites
	3200	ROM_REGION16_BE( 0x10000, "sprites", 0 ) // sprites
3201	3201	ROM_LOAD16_BYTE( "epr-12169.b1",  0x00001, 0x8000, CRC(dacc6165) SHA1(87b1a7643e3630ff73b2b117752496e1ea5da23d) )
3202	3202	ROM_LOAD16_BYTE( "epr-12170.b5",  0x00000, 0x8000, CRC(87354e42) SHA1(e7fd55aee59b51d82cb9b619fbb815ad6839560c) )
3203	3203
r17593	r17594
3222	3222	ROM_LOAD( "epr-12203.rom", 0x10000, 0x10000, CRC(a6e58ec5) SHA1(5a6c43c989768270e0ab61cfaa5ef86d4607fe20) )
3223	3223	ROM_LOAD( "epr-12204.rom", 0x20000, 0x10000, CRC(0ae98e23) SHA1(f067b81b85f9e03a6373c7c53ff52d5395b8a985) )
3224	3224
3225		ROM_REGION16_BE( 0x10000, "gfx2", 0 ) // sprites
	3225	ROM_REGION16_BE( 0x10000, "sprites", 0 ) // sprites
3226	3226	ROM_LOAD16_BYTE( "epr-12169.b1",  0x00001, 0x8000, CRC(dacc6165) SHA1(87b1a7643e3630ff73b2b117752496e1ea5da23d) )
3227	3227	ROM_LOAD16_BYTE( "epr-12170.b5",  0x00000, 0x8000, CRC(87354e42) SHA1(e7fd55aee59b51d82cb9b619fbb815ad6839560c) )
3228	3228
r17593	r17594
3295	3295	ROM_LOAD( "epr-10544.94", 0x08000, 0x8000, CRC(84fb9a3a) SHA1(efde54cc9582f68e58cae05f717a4fc8f620c0fc) )
3296	3296	ROM_LOAD( "epr-10545.93", 0x10000, 0x8000, CRC(c8694bc0) SHA1(e48fc349ef454ded86141937f70b006e64da6b6b) )
3297	3297
3298		ROM_REGION16_BE( 0x40000, "gfx2", 0 ) // sprites
	3298	ROM_REGION16_BE( 0x40000, "sprites", 0 ) // sprites
3299	3299	ROM_LOAD16_BYTE( "epr-10548.10",  0x00001, 0x8000, CRC(aa150735) SHA1(b6e6ff9229c641e196fc7a0a2cf7aa362f554676) )
3300	3300	ROM_LOAD16_BYTE( "epr-10552.11",  0x00000, 0x8000, CRC(6fcbb9f7) SHA1(0a0fab930477d8b79e500263bbc80d3bf73778f8) )
3301	3301	ROM_LOAD16_BYTE( "epr-10549.17",  0x10001, 0x8000, CRC(2f59f067) SHA1(1fb64cce2f98ddcb5ecb662e63ea636a8da08bcd) )
r17593	r17594
3340	3340	ROM_LOAD( "epr-12087.bin", 0x10000, 0x10000, CRC(6f0396b7) SHA1(0a340f2b58e5ecfe504197a8fd2111181e868a3e) )
3341	3341	ROM_LOAD( "epr-12088.bin", 0x20000, 0x10000, CRC(ba8c0749) SHA1(7d996c7a1ad249c06ef7ec9c87a83710c98005d3) )
3342	3342
3343		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	3343	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
3344	3344	ROM_LOAD16_BYTE( "epr-12090.b1", 0x00001, 0x008000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
3345	3345	ROM_CONTINUE(                    0x40001, 0x008000 )
3346	3346	ROM_LOAD16_BYTE( "epr-12094.b5", 0x00000, 0x008000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
r17593	r17594
3378	3378	ROM_LOAD( "epr-12087.94", 0x10000, 0x10000, CRC(5fb761aa) SHA1(dcf88e68732a8ec122d0603d87f6ea1f1614adef) )
3379	3379	ROM_LOAD( "epr-12088.83", 0x20000, 0x10000, CRC(00579c39) SHA1(12acdea75e3d040d60a9f32d05fd9e0191d38f21) )
3380	3380
3381		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	3381	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
3382	3382	ROM_LOAD16_BYTE( "epr-12090.10", 0x00001, 0x008000, CRC(c85904c1) SHA1(e5af26ce870813bd5a88b430fc3881c7fcb63aef) )
3383	3383	ROM_CONTINUE(                    0x40001, 0x008000 )
3384	3384	ROM_LOAD16_BYTE( "epr-12094.11", 0x00000, 0x008000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
r17593	r17594
3415	3415	ROM_LOAD( "epr-12087.94", 0x10000, 0x10000, CRC(5fb761aa) SHA1(dcf88e68732a8ec122d0603d87f6ea1f1614adef) )
3416	3416	ROM_LOAD( "epr-12088.83", 0x20000, 0x10000, CRC(00579c39) SHA1(12acdea75e3d040d60a9f32d05fd9e0191d38f21) )
3417	3417
3418		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	3418	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
3419	3419	ROM_LOAD16_BYTE( "epr-12090.b1", 0x00001, 0x008000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
3420	3420	ROM_CONTINUE(                    0x40001, 0x008000 )
3421	3421	ROM_LOAD16_BYTE( "epr-12094.b5", 0x00000, 0x008000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
r17593	r17594
3460	3460	m_custom_io_w = write16_delegate(FUNC(segas16a_state::standard_io_w), this);
3461	3461
3462	3462	// point globals to allocated memory regions
3463		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
3464		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
3465	3463	segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
3466	3464	segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
3467	3465

trunk/src/mame/drivers/segahang.c

r17593	r17594
119	119
120	120	// bit 7: screen flip
121	121	segaic16_tilemap_set_flip(machine(), 0, data & 0x80);
122		segaic16_sprites_set_flip(machine(), 0, data & 0x80);
	122	m_sprites->set_flip(data & 0x80);
123	123
124	124	// bit 6: shadow/highlight control
125		segaic16_sprites_set_shadow(machine(), 0, ~data & 0x40);
	125	m_shadow = ~data & 0x40;
126	126
127	127	// bit 4: enable display
128	128	segaic16_set_display_enable(machine(), data & 0x10);
r17593	r17594
244	244	}
245	245
246	246	logerror("%06X:hangon_io_r - unknown read access to address %04X\n", m_maincpu->pc(), offset * 2);
247		return segaic16_open_bus_r(&space, 0, mem_mask);
	247	return open_bus_r(space, 0, mem_mask);
248	248	}
249	249
250	250
r17593	r17594
305	305	}
306	306
307	307	logerror("%06X:sharrier_io_r - unknown read access to address %04X\n", m_maincpu->pc(), offset * 2);
308		return segaic16_open_bus_r(&space, 0, mem_mask);
	308	return open_bus_r(space, 0, mem_mask);
309	309	}
310	310
311	311
r17593	r17594
474	474	AM_RANGE(0x20c000, 0x20ffff) AM_RAM AM_SHARE("workram")
475	475	AM_RANGE(0x400000, 0x403fff) AM_RAM_WRITE_LEGACY(segaic16_tileram_0_w) AM_SHARE("tileram")
476	476	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE_LEGACY(segaic16_textram_0_w) AM_SHARE("textram")
477		AM_RANGE(0x600000, 0x6007ff) AM_RAM AM_SHARE("spriteram")
478		AM_RANGE(0xa00000, 0xa00fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_SHARE("paletteram")
	477	AM_RANGE(0x600000, 0x6007ff) AM_RAM AM_SHARE("sprites")
	478	AM_RANGE(0xa00000, 0xa00fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
479	479	AM_RANGE(0xc00000, 0xc3ffff) AM_ROM AM_REGION("subcpu", 0)
480	480	AM_RANGE(0xc68000, 0xc68fff) AM_RAM AM_SHARE("roadram")
481	481	AM_RANGE(0xc7c000, 0xc7ffff) AM_RAM AM_SHARE("subram")
r17593	r17594
488	488	AM_RANGE(0x040000, 0x043fff) AM_RAM AM_SHARE("workram")
489	489	AM_RANGE(0x100000, 0x107fff) AM_RAM_WRITE_LEGACY(segaic16_tileram_0_w) AM_SHARE("tileram")
490	490	AM_RANGE(0x108000, 0x108fff) AM_RAM_WRITE_LEGACY(segaic16_textram_0_w) AM_SHARE("textram")
491		AM_RANGE(0x110000, 0x110fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_SHARE("paletteram")
	491	AM_RANGE(0x110000, 0x110fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
492	492	AM_RANGE(0x124000, 0x127fff) AM_RAM AM_SHARE("subram")
493		AM_RANGE(0x130000, 0x130fff) AM_RAM AM_SHARE("spriteram")
	493	AM_RANGE(0x130000, 0x130fff) AM_RAM AM_SHARE("sprites")
494	494	AM_RANGE(0x140000, 0x14ffff) AM_READWRITE(sharrier_io_r, sharrier_io_w)
495	495	AM_RANGE(0xc68000, 0xc68fff) AM_RAM AM_SHARE("roadram")
496	496	ADDRESS_MAP_END
r17593	r17594
855	855
856	856	static MACHINE_CONFIG_DERIVED( hangon_base, shared_base )
857	857	// video hardware
858		MCFG_SEGA16SP_ADD_HANGON("segaspr1")
	858	MCFG_SEGA_HANGON_SPRITES_ADD("sprites")
859	859	MACHINE_CONFIG_END
860	860
861	861
r17593	r17594
870	870	MCFG_CPU_CLOCK(MASTER_CLOCK_10MHz)
871	871
872	872	// video hardware
873		MCFG_SEGA16SP_ADD_SHARRIER("segaspr1")
	873	MCFG_SEGA_SHARRIER_SPRITES_ADD("sprites")
874	874	MACHINE_CONFIG_END
875	875
876	876
r17593	r17594
1063	1063	ROM_LOAD( "epr-6842.ic23", 0x08000, 0x08000, CRC(f677b568) SHA1(636ca60bd4be9b5c2be09de8ae49db1063aa6c79) )
1064	1064	ROM_LOAD( "epr-6843.ic7",  0x10000, 0x08000, CRC(a257f0da) SHA1(9828f8ce4ef245ffb8dbad347f9ca74ed81aa998) )
1065	1065
1066		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	1066	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
1067	1067	ROM_LOAD16_BYTE( "epr-6819.ic27", 0x000001, 0x8000, CRC(469dad07) SHA1(6d01c0b3506e28832928ad74d518577ff5be323b) )
1068	1068	ROM_LOAD16_BYTE( "epr-6820.ic34", 0x000000, 0x8000, CRC(87cbc6de) SHA1(b64652e062e1b88c6f6ae8dd2ffe4533bb27ba45) )
1069	1069	ROM_LOAD16_BYTE( "epr-6821.ic28", 0x010001, 0x8000, CRC(15792969) SHA1(b061dbf24e8b511116446794753c8b0cc49e2149) )
r17593	r17594
1089	1089	ROM_LOAD( "epr-6831.ic5", 0x00000, 0x8000, CRC(cfef5481) SHA1(c04b302fee58f0e59a097b2be2b61e5d03df7c91) )
1090	1090	ROM_LOAD( "epr-6832.ic6", 0x08000, 0x8000, CRC(4165aea5) SHA1(be05c6d295807af2f396a1ff72d5a3d2a1e6054d) )
1091	1091
1092		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1092	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1093	1093	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1094	1094	ROM_END
1095	1095
r17593	r17594
1118	1118	ROM_LOAD( "epr-6842.ic23", 0x08000, 0x08000, CRC(f677b568) SHA1(636ca60bd4be9b5c2be09de8ae49db1063aa6c79) )
1119	1119	ROM_LOAD( "epr-6843.ic7",  0x10000, 0x08000, CRC(a257f0da) SHA1(9828f8ce4ef245ffb8dbad347f9ca74ed81aa998) )
1120	1120
1121		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	1121	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
1122	1122	ROM_LOAD16_BYTE( "epr-6819.ic27", 0x000001, 0x8000, CRC(469dad07) SHA1(6d01c0b3506e28832928ad74d518577ff5be323b) )
1123	1123	ROM_LOAD16_BYTE( "epr-6820.ic34", 0x000000, 0x8000, CRC(87cbc6de) SHA1(b64652e062e1b88c6f6ae8dd2ffe4533bb27ba45) )
1124	1124	ROM_LOAD16_BYTE( "epr-6821.ic28", 0x010001, 0x8000, CRC(15792969) SHA1(b061dbf24e8b511116446794753c8b0cc49e2149) )
r17593	r17594
1144	1144	ROM_LOAD( "epr-6831.ic5", 0x00000, 0x8000, CRC(cfef5481) SHA1(c04b302fee58f0e59a097b2be2b61e5d03df7c91) )
1145	1145	ROM_LOAD( "epr-6832.ic6", 0x08000, 0x8000, CRC(4165aea5) SHA1(be05c6d295807af2f396a1ff72d5a3d2a1e6054d) )
1146	1146
1147		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1147	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1148	1148	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1149	1149	ROM_END
1150	1150
r17593	r17594
1185	1185	ROM_LOAD( "epr-10651.23", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1186	1186	ROM_LOAD( "epr-10650.7",  0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1187	1187
1188		ROM_REGION16_BE( 0x00e0000, "gfx2", 0 ) // sprites
	1188	ROM_REGION16_BE( 0x00e0000, "sprites", 0 ) // sprites
1189	1189	ROM_LOAD16_BYTE( "epr-10675.22", 0x000001, 0x010000, CRC(d6ac012b) SHA1(305023b1a0a9d84cfc081ffc2ad7578b53d562f2) )
1190	1190	ROM_LOAD16_BYTE( "epr-10682.11", 0x000000, 0x010000, CRC(d9d83250) SHA1(f8ca3197edcdf53643a5b335c3c044ddc1310cd4) )
1191	1191	ROM_LOAD16_BYTE( "epr-10676.21", 0x020001, 0x010000, CRC(25ebf2c5) SHA1(abcf673ae4e280417dd9f46d18c0ec7c0e4802ae) )
r17593	r17594
1211	1211	ROM_LOAD( "epr-10835.55", 0x00000, 0x10000, CRC(da08ca2b) SHA1(2c94c127efd66f6cf86b25e2653637818a99aed1) )
1212	1212	ROM_LOAD( "epr-10836.56", 0x10000, 0x10000, CRC(8b10e601) SHA1(75e9bcdd3f096be9bed672d61064b9240690deec) )
1213	1213
1214		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1214	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1215	1215	ROM_LOAD( "epr-6844.119", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1216	1216	ROM_END
1217	1217
r17593	r17594
1237	1237	ROM_LOAD( "epr-10651.23", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1238	1238	ROM_LOAD( "epr-10650.7",  0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1239	1239
1240		ROM_REGION16_BE( 0x00e0000, "gfx2", 0 ) // sprites
	1240	ROM_REGION16_BE( 0x00e0000, "sprites", 0 ) // sprites
1241	1241	ROM_LOAD16_BYTE( "epr-10675.22", 0x000001, 0x010000, CRC(d6ac012b) SHA1(305023b1a0a9d84cfc081ffc2ad7578b53d562f2) )
1242	1242	ROM_LOAD16_BYTE( "epr-10682.11", 0x000000, 0x010000, CRC(d9d83250) SHA1(f8ca3197edcdf53643a5b335c3c044ddc1310cd4) )
1243	1243	ROM_LOAD16_BYTE( "s-hangon.20",  0x020001, 0x010000, CRC(eef23b3d) SHA1(2416fa9991afbdddf25d469082e53858289550db) )
r17593	r17594
1263	1263	ROM_LOAD( "epr-10835.55", 0x00000, 0x10000, CRC(da08ca2b) SHA1(2c94c127efd66f6cf86b25e2653637818a99aed1) )
1264	1264	ROM_LOAD( "epr-10836.56", 0x10000, 0x10000, CRC(8b10e601) SHA1(75e9bcdd3f096be9bed672d61064b9240690deec) )
1265	1265
1266		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1266	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1267	1267	ROM_LOAD( "epr-6844.119", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1268	1268	ROM_END
1269	1269
r17593	r17594
1299	1299	ROM_LOAD( "epr-7197.ic46", 0x08000, 0x08000, CRC(39d98bd1) SHA1(5aab91bdd08b0f1ea537cd43ccc2e82fd01dd031) )
1300	1300	ROM_LOAD( "epr-7198.ic60", 0x10000, 0x08000, CRC(3da3ea6b) SHA1(9a6ce304a14e6ef0be41d867284a63b941f960fb) )
1301	1301
1302		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1302	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1303	1303	ROM_LOAD32_BYTE( "epr-7230.ic36", 0x00000, 0x8000, CRC(93e2d264) SHA1(ca56de13756ab77408506d88f291da1da8134435) )
1304	1304	ROM_LOAD32_BYTE( "epr-7222.ic28", 0x00001, 0x8000, CRC(edbf5fc3) SHA1(a93f8c431075741c181eb422b24c9303487ca16c) )
1305	1305	ROM_LOAD32_BYTE( "epr-7214.ic18", 0x00002, 0x8000, CRC(e8c537d8) SHA1(c9b3c0f33272c47d32e6aa349d72f7e355468e0e) )
r17593	r17594
1347	1347	ROM_REGION( 0x10000, "mcu", 0 )   // Internal i8751 MCU code
1348	1348	ROM_LOAD( "315-5163a.ic32", 0x00000, 0x1000, NO_DUMP )
1349	1349
1350		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1350	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1351	1351	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1352	1352	ROM_END
1353	1353
r17593	r17594
1380	1380	ROM_LOAD( "epr-7197.ic46", 0x08000, 0x08000, CRC(39d98bd1) SHA1(5aab91bdd08b0f1ea537cd43ccc2e82fd01dd031) )
1381	1381	ROM_LOAD( "epr-7198.ic60", 0x10000, 0x08000, CRC(3da3ea6b) SHA1(9a6ce304a14e6ef0be41d867284a63b941f960fb) )
1382	1382
1383		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1383	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1384	1384	ROM_LOAD32_BYTE( "epr-7230.ic36", 0x00000, 0x8000, CRC(93e2d264) SHA1(ca56de13756ab77408506d88f291da1da8134435) )
1385	1385	ROM_LOAD32_BYTE( "epr-7222.ic28", 0x00001, 0x8000, CRC(edbf5fc3) SHA1(a93f8c431075741c181eb422b24c9303487ca16c) )
1386	1386	ROM_LOAD32_BYTE( "epr-7214.ic18", 0x00002, 0x8000, CRC(e8c537d8) SHA1(c9b3c0f33272c47d32e6aa349d72f7e355468e0e) )
r17593	r17594
1428	1428	ROM_REGION( 0x10000, "mcu", 0 )   // Internal i8751 MCU code
1429	1429	ROM_LOAD( "315-5163.ic32", 0x00000, 0x1000, NO_DUMP )
1430	1430
1431		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1431	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1432	1432	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1433	1433	ROM_END
1434	1434
r17593	r17594
1463	1463	ROM_LOAD( "epr-7645.ic46", 0x08000, 0x08000, CRC(4caa0095) SHA1(a24c741cdca0542e462f17ff94f132c62710e198) )
1464	1464	ROM_LOAD( "epr-7646.ic60", 0x10000, 0x08000, CRC(7e432683) SHA1(c8249b23fce77eb456166161c2d9aa34309efe31) )
1465	1465
1466		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1466	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1467	1467	ROM_LOAD32_BYTE( "epr-7678.ic36", 0x00000, 0x8000, CRC(9fb5e656) SHA1(264b0ad017eb0fc7e0b542e6dd160ba964c100fd) )
1468	1468	ROM_LOAD32_BYTE( "epr-7670.ic28", 0x00001, 0x8000, CRC(dbbe2f6e) SHA1(310797a61f91d6866e728e0da3b30828e06d1b52) )
1469	1469	ROM_LOAD32_BYTE( "epr-7662.ic18", 0x00002, 0x8000, CRC(cb0c13c5) SHA1(856d1234fd8f8146e20fe6c65c0a535b7b7512cd) )
r17593	r17594
1507	1507	ROM_LOAD( "epr-7681.rom", 0x00000, 0x8000, CRC(bc0c4d12) SHA1(3de71bde4c23e3c31984f20fc4bc7e221354c56f) )
1508	1508	ROM_LOAD( "epr-7680.rom", 0x10000, 0x8000, CRC(627b3c8c) SHA1(806fe7dce619ad19c09178061be4607d2beba14d) )
1509	1509
1510		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1510	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1511	1511	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1512	1512
1513	1513	ROM_REGION( 0x2000, "maincpu:key", 0 ) // decryption key
r17593	r17594
1542	1542	ROM_LOAD( "epr-7645.ic46", 0x08000, 0x08000, CRC(4caa0095) SHA1(a24c741cdca0542e462f17ff94f132c62710e198) )
1543	1543	ROM_LOAD( "epr-7646.ic60", 0x10000, 0x08000, CRC(7e432683) SHA1(c8249b23fce77eb456166161c2d9aa34309efe31) )
1544	1544
1545		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1545	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1546	1546	ROM_LOAD32_BYTE( "epr-7678.ic36", 0x00000, 0x8000, CRC(9fb5e656) SHA1(264b0ad017eb0fc7e0b542e6dd160ba964c100fd) )
1547	1547	ROM_LOAD32_BYTE( "epr-7670.ic28", 0x00001, 0x8000, CRC(dbbe2f6e) SHA1(310797a61f91d6866e728e0da3b30828e06d1b52) )
1548	1548	ROM_LOAD32_BYTE( "epr-7662.ic18", 0x00002, 0x8000, CRC(cb0c13c5) SHA1(856d1234fd8f8146e20fe6c65c0a535b7b7512cd) )
r17593	r17594
1587	1587	ROM_LOAD( "epr-7762.ic5", 0x00000, 0x8000, CRC(bc0c4d12) SHA1(3de71bde4c23e3c31984f20fc4bc7e221354c56f) )
1588	1588	ROM_LOAD( "epr-7763.ic6", 0x08000, 0x8000, CRC(627b3c8c) SHA1(806fe7dce619ad19c09178061be4607d2beba14d) )
1589	1589
1590		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1590	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1591	1591	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1592	1592
1593	1593	ROM_REGION( 0x2000, "maincpu:key", 0 ) // decryption key
r17593	r17594
1619	1619	ROM_LOAD( "epr-7645.ic46", 0x08000, 0x08000, CRC(4caa0095) SHA1(a24c741cdca0542e462f17ff94f132c62710e198) )
1620	1620	ROM_LOAD( "epr-7646.ic60", 0x10000, 0x08000, CRC(7e432683) SHA1(c8249b23fce77eb456166161c2d9aa34309efe31) )
1621	1621
1622		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1622	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1623	1623	ROM_LOAD32_BYTE( "epr-7678.ic36", 0x00000, 0x8000, CRC(9fb5e656) SHA1(264b0ad017eb0fc7e0b542e6dd160ba964c100fd) )
1624	1624	ROM_LOAD32_BYTE( "epr-7670.ic28", 0x00001, 0x8000, CRC(dbbe2f6e) SHA1(310797a61f91d6866e728e0da3b30828e06d1b52) )
1625	1625	ROM_LOAD32_BYTE( "epr-7662.ic18", 0x00002, 0x8000, CRC(cb0c13c5) SHA1(856d1234fd8f8146e20fe6c65c0a535b7b7512cd) )
r17593	r17594
1664	1664	ROM_LOAD( "epr-7762.ic5", 0x00000, 0x8000, CRC(bc0c4d12) SHA1(3de71bde4c23e3c31984f20fc4bc7e221354c56f) )
1665	1665	ROM_LOAD( "epr-7763.ic6", 0x10000, 0x8000, CRC(627b3c8c) SHA1(806fe7dce619ad19c09178061be4607d2beba14d) )
1666	1666
1667		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1667	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1668	1668	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1669	1669	ROM_END
1670	1670
r17593	r17594
1694	1694	ROM_LOAD( "epr-7645.ic46", 0x08000, 0x08000, CRC(4caa0095) SHA1(a24c741cdca0542e462f17ff94f132c62710e198) )
1695	1695	ROM_LOAD( "epr-7646.ic60", 0x10000, 0x08000, CRC(7e432683) SHA1(c8249b23fce77eb456166161c2d9aa34309efe31) )
1696	1696
1697		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1697	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1698	1698	ROM_LOAD32_BYTE( "epr-7678.ic36", 0x00000, 0x8000, CRC(9fb5e656) SHA1(264b0ad017eb0fc7e0b542e6dd160ba964c100fd) )
1699	1699	ROM_LOAD32_BYTE( "epr-7670.ic28", 0x00001, 0x8000, CRC(dbbe2f6e) SHA1(310797a61f91d6866e728e0da3b30828e06d1b52) )
1700	1700	ROM_LOAD32_BYTE( "epr-7662.ic18", 0x00002, 0x8000, CRC(cb0c13c5) SHA1(856d1234fd8f8146e20fe6c65c0a535b7b7512cd) )
r17593	r17594
1738	1738	ROM_LOAD( "epr-7681.rom", 0x00000, 0x8000, CRC(bc0c4d12) SHA1(3de71bde4c23e3c31984f20fc4bc7e221354c56f) )
1739	1739	ROM_LOAD( "epr-7680.rom", 0x10000, 0x8000, CRC(627b3c8c) SHA1(806fe7dce619ad19c09178061be4607d2beba14d) )
1740	1740
1741		ROM_REGION( 0x2000, "proms", 0 ) // zoom table
	1741	ROM_REGION( 0x2000, "sprites:zoom", 0 ) // zoom table
1742	1742	ROM_LOAD( "epr-6844.ic123", 0x0000, 0x2000, CRC(e3ec7bd6) SHA1(feec0fe664e16fac0fde61cf64b401b9b0575323) )
1743	1743	ROM_END
1744	1744
r17593	r17594
1755	1755	DRIVER_INIT_MEMBER(segahang_state,generic)
1756	1756	{
1757	1757	// point globals to allocated memory regions
1758		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
1759		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
1760	1758	segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
1761	1759	segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
1762	1760	segaic16_roadram_0 = reinterpret_cast<UINT16 *>(memshare("roadram")->ptr());
1763	1761
1764	1762	// save states
1765	1763	save_item(NAME(m_adc_select));
	1764	save_item(NAME(m_shadow));
1766	1765	}
1767	1766
1768	1767

trunk/src/mame/drivers/segas18.c

r17593	r17594
82	82	break;
83	83
84	84	case 6:
85		mapper.map_as_ram(0x00000, 0x02000, 0xffe000, "paletteram", write16_delegate(FUNC(segas18_state::legacy_wrapper<segaic16_paletteram_w>), this));
	85	mapper.map_as_ram(0x00000, 0x01000, 0xfff000, "paletteram", write16_delegate(FUNC(segas18_state::paletteram_w), this));
86	86	break;
87	87
88	88	case 5:
r17593	r17594
91	91	break;
92	92
93	93	case 4:
94		mapper.map_as_ram(0x00000, 0x00800, 0xfff800, "spriteram", write16_delegate());
	94	mapper.map_as_ram(0x00000, 0x00800, 0xfff800, "sprites", write16_delegate());
95	95	break;
96	96
97	97	case 3:
r17593	r17594
166	166	m_nvram->set_base(m_workram, m_workram.bytes());
167	167
168	168	// point globals to allocated memory regions
169		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
170		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
171	169	segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
172	170	segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
173	171
r17593	r17594
295	293	case 0x06/2:
296	294	set_grayscale(~data & 0x40);
297	295	segaic16_tilemap_set_flip(machine(), 0, data & 0x20);
298		segaic16_sprites_set_flip(machine(), 0, data & 0x20);
	296	m_sprites->set_flip(data & 0x20);
299	297	// These are correct according to cgfm's docs, but mwalker and ddcrew both
300	298	// enable the lockout and never turn it off
301	299	//            coin_lockout_w(machine(), 1, data & 0x08);
r17593	r17594
344	342	if (!m_custom_io_r.isnull())
345	343	return m_custom_io_r(space, offset, mem_mask);
346	344	logerror("%06X:misc_io_r - unknown read access to address %04X\n", cpu_get_pc(&space.device()), offset * 2);
347		return segaic16_open_bus_r(&space, 0, mem_mask);
	345	return open_bus_r(space, 0, mem_mask);
348	346	}
349	347
350	348
r17593	r17594
407	405	// sprite banking
408	406	else
409	407	{
410		int maxbanks = memregion("gfx2")->bytes() / 0x40000;
	408	int maxbanks = memregion("sprites")->bytes() / 0x40000;
411	409	if (data >= maxbanks)
412	410	data = 255;
413		segaic16_sprites_set_bank(machine(), 0, (offset - 8) * 2 + 0, data * 2 + 0);
414		segaic16_sprites_set_bank(machine(), 0, (offset - 8) * 2 + 1, data * 2 + 1);
	411	m_sprites->set_bank((offset - 8) * 2 + 0, data * 2 + 0);
	412	m_sprites->set_bank((offset - 8) * 2 + 1, data * 2 + 1);
415	413	}
416	414	}
417	415
r17593	r17594
436	434	case 0x3024/2:
437	435	return ioport("P34START")->read();
438	436	}
439		return segaic16_open_bus_r(&space, 0, mem_mask);
	437	return open_bus_r(space, 0, mem_mask);
440	438	}
441	439
442	440
r17593	r17594
460	458	m_lghost_value <<= 1;
461	459	return result;
462	460	}
463		return segaic16_open_bus_r(&space, 0, mem_mask);
	461	return open_bus_r(space, 0, mem_mask);
464	462	}
465	463
466	464
r17593	r17594
520	518	case 0x3014/2:
521	519	return (ioport("TRACKY3")->read() - m_wwally_last_y[2]) & 0xff;
522	520	}
523		return segaic16_open_bus_r(&space, 0, mem_mask);
	521	return open_bus_r(space, 0, mem_mask);
524	522	}
525	523
526	524
r17593	r17594
598	596
599	597	// these get overwritten by the memory mapper above, but we put them here
600	598	// so they are properly allocated and tracked for saving
601		AM_RANGE(0x100000, 0x1007ff) AM_RAM AM_SHARE("spriteram")
602		AM_RANGE(0x200000, 0x201fff) AM_RAM AM_SHARE("paletteram")
	599	AM_RANGE(0x100000, 0x1007ff) AM_RAM AM_SHARE("sprites")
	600	AM_RANGE(0x200000, 0x200fff) AM_RAM AM_SHARE("paletteram")
603	601	AM_RANGE(0x300000, 0x30ffff) AM_RAM AM_SHARE("tileram")
604	602	AM_RANGE(0x400000, 0x400fff) AM_RAM AM_SHARE("textram")
605	603	AM_RANGE(0x500000, 0x503fff) AM_RAM AM_SHARE("workram")
r17593	r17594
1276	1274	MCFG_GFXDECODE(segas18)
1277	1275	MCFG_PALETTE_LENGTH(2048*3+2048 + 64*3)
1278	1276
1279		MCFG_SEGA16SP_ADD_16B("segaspr1")
	1277	MCFG_SEGA_SYS16B_SPRITES_ADD("sprites")
1280	1278
1281	1279	// sound hardware
1282	1280	MCFG_SPEAKER_STANDARD_MONO("mono")
r17593	r17594
1335	1333	ROM_LOAD( "epr-13074.bin", 0x40000, 0x40000, CRC(787afab8) SHA1(a119042bb2dad54e9733bfba4eaab0ac5fc0f9e7) )
1336	1334	ROM_LOAD( "epr-13075.bin", 0x80000, 0x40000, CRC(4e01b477) SHA1(4178ce4a87ea427c3b0195e64acef6cddfb3485f) )
1337	1335
1338		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	1336	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
1339	1337	ROM_LOAD16_BYTE( "mpr-13082.bin", 0x000001, 0x40000, CRC(a782b704) SHA1(ba15bdfbc267b8d86f03e5310ce60846ff846de3) )
1340	1338	ROM_LOAD16_BYTE( "mpr-13089.bin", 0x000000, 0x40000, CRC(2a4227f0) SHA1(47284dce8f896f8e8eace9c20302842cacb479c1) )
1341	1339	ROM_LOAD16_BYTE( "mpr-13081.bin", 0x080001, 0x40000, CRC(eb510228) SHA1(4cd387b160ec7050e1300ebe708853742169e643) )
r17593	r17594
1371	1369	ROM_LOAD( "epr-13074.bin", 0x40000, 0x40000, CRC(787afab8) SHA1(a119042bb2dad54e9733bfba4eaab0ac5fc0f9e7) )
1372	1370	ROM_LOAD( "epr-13075.bin", 0x80000, 0x40000, CRC(4e01b477) SHA1(4178ce4a87ea427c3b0195e64acef6cddfb3485f) )
1373	1371
1374		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	1372	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
1375	1373	ROM_LOAD16_BYTE( "mpr-13082.bin", 0x000001, 0x40000, CRC(a782b704) SHA1(ba15bdfbc267b8d86f03e5310ce60846ff846de3) )
1376	1374	ROM_LOAD16_BYTE( "mpr-13089.bin", 0x000000, 0x40000, CRC(2a4227f0) SHA1(47284dce8f896f8e8eace9c20302842cacb479c1) )
1377	1375	ROM_LOAD16_BYTE( "mpr-13081.bin", 0x080001, 0x40000, CRC(eb510228) SHA1(4cd387b160ec7050e1300ebe708853742169e643) )
r17593	r17594
1405	1403	ROM_LOAD( "epr-13074.bin", 0x40000, 0x40000, CRC(787afab8) SHA1(a119042bb2dad54e9733bfba4eaab0ac5fc0f9e7) )
1406	1404	ROM_LOAD( "epr-13075.bin", 0x80000, 0x40000, CRC(4e01b477) SHA1(4178ce4a87ea427c3b0195e64acef6cddfb3485f) )
1407	1405
1408		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	1406	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
1409	1407	ROM_LOAD16_BYTE( "mpr-13082.bin", 0x000001, 0x40000, CRC(a782b704) SHA1(ba15bdfbc267b8d86f03e5310ce60846ff846de3) )
1410	1408	ROM_LOAD16_BYTE( "mpr-13089.bin", 0x000000, 0x40000, CRC(2a4227f0) SHA1(47284dce8f896f8e8eace9c20302842cacb479c1) )
1411	1409	ROM_LOAD16_BYTE( "mpr-13081.bin", 0x080001, 0x40000, CRC(eb510228) SHA1(4cd387b160ec7050e1300ebe708853742169e643) )
r17593	r17594
1440	1438	ROM_LOAD( "epr-13074.bin", 0x40000, 0x40000, CRC(787afab8) SHA1(a119042bb2dad54e9733bfba4eaab0ac5fc0f9e7) )
1441	1439	ROM_LOAD( "epr-13075.bin", 0x80000, 0x40000, CRC(4e01b477) SHA1(4178ce4a87ea427c3b0195e64acef6cddfb3485f) )
1442	1440
1443		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	1441	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
1444	1442	ROM_LOAD16_BYTE( "mpr-13082.bin", 0x000001, 0x40000, CRC(a782b704) SHA1(ba15bdfbc267b8d86f03e5310ce60846ff846de3) )
1445	1443	ROM_LOAD16_BYTE( "mpr-13089.bin", 0x000000, 0x40000, CRC(2a4227f0) SHA1(47284dce8f896f8e8eace9c20302842cacb479c1) )
1446	1444	ROM_LOAD16_BYTE( "mpr-13081.bin", 0x080001, 0x40000, CRC(eb510228) SHA1(4cd387b160ec7050e1300ebe708853742169e643) )
r17593	r17594
1478	1476	ROM_LOAD( "opr-12885.b2", 0x10000, 0x10000, CRC(8041b814)SHA1(29fa49ba9a73eed07865a86ea774e2c6a60aed5b) )
1479	1477	ROM_LOAD( "opr-12886.b3", 0x20000, 0x10000, CRC(de32285e)SHA1(8994dc128d6a23763e5fcfca1868b336d4aa0a21) )
1480	1478
1481		ROM_REGION( 0x20000, "gfx2", 0 ) // sprites
	1479	ROM_REGION( 0x20000, "sprites", 0 ) // sprites
1482	1480	ROM_LOAD16_BYTE( "opr-12891.a11", 0x00001, 0x10000, CRC(90d31a8c)SHA1(1747652a5109ce65add197cf06535f2463a99fdc) )
1483	1481	ROM_LOAD16_BYTE( "opr-12887.b11", 0x00000, 0x10000, CRC(f0c0f49d)SHA1(7ecd591265165f3149241e2ceb5059faab88360f) )
1484	1482
r17593	r17594
1512	1510	ROM_LOAD( "mpr-13774.c2",  0x080000, 0x80000, CRC(2411a824) SHA1(0e383ccc4e0830ffb395d5102e2950610c147007) )
1513	1511	ROM_LOAD( "mpr-13775.c3",  0x100000, 0x80000, CRC(cf527bf6) SHA1(1f9cf1f0e92709f0465dc97ebbdaa715a419f7a7) )
1514	1512
1515		ROM_REGION16_BE( 0x600000, "gfx2", 0 ) // sprites
	1513	ROM_REGION16_BE( 0x600000, "sprites", 0 ) // sprites
1516	1514	ROM_LOAD16_BYTE( "mpr-13779.c10", 0x000001, 0x80000, CRC(c707f416) SHA1(e6a9d89849f7f1c303a3ca29a629f81397945a2d) )
1517	1515	ROM_LOAD16_BYTE( "mpr-13787.a10", 0x000000, 0x80000, CRC(f05c68c6) SHA1(b6a0535b6c734a0c89fdb6506c32ffe6ab3aa8cd) )
1518	1516	ROM_LOAD16_BYTE( "mpr-13780.c11", 0x200001, 0x80000, CRC(a4c341e0) SHA1(15a0b5a42b56465a7b7df98968cc2ed177ce6f59) )
r17593	r17594
1546	1544	ROM_LOAD( "mpr-13774.c2",  0x080000, 0x80000, CRC(2411a824) SHA1(0e383ccc4e0830ffb395d5102e2950610c147007) )
1547	1545	ROM_LOAD( "mpr-13775.c3",  0x100000, 0x80000, CRC(cf527bf6) SHA1(1f9cf1f0e92709f0465dc97ebbdaa715a419f7a7) )
1548	1546
1549		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1547	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1550	1548	ROM_LOAD16_BYTE( "mpr-13779.c10", 0x000001, 0x80000, CRC(c707f416) SHA1(e6a9d89849f7f1c303a3ca29a629f81397945a2d) )
1551	1549	ROM_LOAD16_BYTE( "mpr-13787.a10", 0x000000, 0x80000, CRC(f05c68c6) SHA1(b6a0535b6c734a0c89fdb6506c32ffe6ab3aa8cd) )
1552	1550	ROM_LOAD16_BYTE( "mpr-13780.c11", 0x200001, 0x80000, CRC(a4c341e0) SHA1(15a0b5a42b56465a7b7df98968cc2ed177ce6f59) )
r17593	r17594
1587	1585	ROM_LOAD( "epr-14128.c2", 0x40000, 0x40000, CRC(edba8e10) SHA1(25a2833ead4ca363802ddc2eb97c40976502921a) )
1588	1586	ROM_LOAD( "epr-14129.c3", 0x80000, 0x40000, CRC(e8ecc305) SHA1(a26d0c5c7826cd315f8b2c27e5a503a2a7b535c4) )
1589	1587
1590		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1588	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1591	1589	ROM_LOAD16_BYTE( "mpr-14134.c10", 0x000001, 0x80000, CRC(4fda6a4b) SHA1(a9e582e494ab967e8f3ccf4d5844bb8ef889928c) )
1592	1590	ROM_LOAD16_BYTE( "mpr-14142.a10", 0x000000, 0x80000, CRC(3cbf1f2a) SHA1(80b6b006936740087786acd538e28aca85fa6894) )
1593	1591	ROM_LOAD16_BYTE( "mpr-14135.c11", 0x200001, 0x80000, CRC(e9c74876) SHA1(aff9d071e77f01c6937188bf67be38fa898343e6) )
r17593	r17594
1624	1622	ROM_LOAD( "epr-14128.c2", 0x40000, 0x40000, CRC(edba8e10) SHA1(25a2833ead4ca363802ddc2eb97c40976502921a) )
1625	1623	ROM_LOAD( "epr-14129.c3", 0x80000, 0x40000, CRC(e8ecc305) SHA1(a26d0c5c7826cd315f8b2c27e5a503a2a7b535c4) )
1626	1624
1627		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1625	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1628	1626	ROM_LOAD16_BYTE( "mpr-14134.c10", 0x000001, 0x80000, CRC(4fda6a4b) SHA1(a9e582e494ab967e8f3ccf4d5844bb8ef889928c) )
1629	1627	ROM_LOAD16_BYTE( "mpr-14142.a10", 0x000000, 0x80000, CRC(3cbf1f2a) SHA1(80b6b006936740087786acd538e28aca85fa6894) )
1630	1628	ROM_LOAD16_BYTE( "mpr-14135.c11", 0x200001, 0x80000, CRC(e9c74876) SHA1(aff9d071e77f01c6937188bf67be38fa898343e6) )
r17593	r17594
1661	1659	ROM_LOAD( "epr-14128.c2", 0x40000, 0x40000, CRC(edba8e10) SHA1(25a2833ead4ca363802ddc2eb97c40976502921a) )
1662	1660	ROM_LOAD( "epr-14129.c3", 0x80000, 0x40000, CRC(e8ecc305) SHA1(a26d0c5c7826cd315f8b2c27e5a503a2a7b535c4) )
1663	1661
1664		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1662	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1665	1663	ROM_LOAD16_BYTE( "mpr-14134.c10", 0x000001, 0x80000, CRC(4fda6a4b) SHA1(a9e582e494ab967e8f3ccf4d5844bb8ef889928c) )
1666	1664	ROM_LOAD16_BYTE( "mpr-14142.a10", 0x000000, 0x80000, CRC(3cbf1f2a) SHA1(80b6b006936740087786acd538e28aca85fa6894) )
1667	1665	ROM_LOAD16_BYTE( "mpr-14135.c11", 0x200001, 0x80000, CRC(e9c74876) SHA1(aff9d071e77f01c6937188bf67be38fa898343e6) )
r17593	r17594
1699	1697	ROM_LOAD( "epr-14128.c2", 0x40000, 0x40000, CRC(edba8e10) SHA1(25a2833ead4ca363802ddc2eb97c40976502921a) )
1700	1698	ROM_LOAD( "epr-14129.c3", 0x80000, 0x40000, CRC(e8ecc305) SHA1(a26d0c5c7826cd315f8b2c27e5a503a2a7b535c4) )
1701	1699
1702		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1700	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1703	1701	ROM_LOAD16_BYTE( "mpr-14134.c10", 0x000001, 0x80000, CRC(4fda6a4b) SHA1(a9e582e494ab967e8f3ccf4d5844bb8ef889928c) )
1704	1702	ROM_LOAD16_BYTE( "mpr-14142.a10", 0x000000, 0x80000, CRC(3cbf1f2a) SHA1(80b6b006936740087786acd538e28aca85fa6894) )
1705	1703	ROM_LOAD16_BYTE( "mpr-14135.c11", 0x200001, 0x80000, CRC(e9c74876) SHA1(aff9d071e77f01c6937188bf67be38fa898343e6) )
r17593	r17594
1737	1735	ROM_LOAD( "epr-14128.c2", 0x40000, 0x40000, CRC(edba8e10) SHA1(25a2833ead4ca363802ddc2eb97c40976502921a) )
1738	1736	ROM_LOAD( "epr-14129.c3", 0x80000, 0x40000, CRC(e8ecc305) SHA1(a26d0c5c7826cd315f8b2c27e5a503a2a7b535c4) )
1739	1737
1740		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1738	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1741	1739	ROM_LOAD16_BYTE( "mpr-14134.c10", 0x000001, 0x80000, CRC(4fda6a4b) SHA1(a9e582e494ab967e8f3ccf4d5844bb8ef889928c) )
1742	1740	ROM_LOAD16_BYTE( "mpr-14142.a10", 0x000000, 0x80000, CRC(3cbf1f2a) SHA1(80b6b006936740087786acd538e28aca85fa6894) )
1743	1741	ROM_LOAD16_BYTE( "mpr-14135.c11", 0x200001, 0x80000, CRC(e9c74876) SHA1(aff9d071e77f01c6937188bf67be38fa898343e6) )
r17593	r17594
1780	1778	ROM_LOAD( "mpr-14782.c2", 0x100000, 0x100000, CRC(ccc98d05) SHA1(b89594bbfff45e3b4fe433aeeaf8b4073c2cabb5) )
1781	1779	ROM_LOAD( "mpr-14783.c3", 0x200000, 0x100000, CRC(ef202bec) SHA1(b557092f8a3e1c9889d34588344c6dd2c6f06731) )
1782	1780
1783		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1781	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1784	1782	ROM_LOAD16_BYTE( "mpr-14788.c10", 0x000001, 0x100000, CRC(b5b05536) SHA1(f8fde7ebca38c0a6f6a864c17771aa155e6fc30d) )
1785	1783	ROM_LOAD16_BYTE( "mpr-14796.a10", 0x000000, 0x100000, CRC(c033220a) SHA1(279d3ef62b41d2c6a18ce1217a549402a874638b) )
1786	1784	ROM_LOAD16_BYTE( "mpr-14789.c11", 0x200001, 0x100000, CRC(0f9bcb97) SHA1(c15ab3ece596c54e1c4d8e8a755473609334e8ba) )
r17593	r17594
1820	1818	ROM_LOAD( "mpr-14782.c2", 0x100000, 0x100000, CRC(ccc98d05) SHA1(b89594bbfff45e3b4fe433aeeaf8b4073c2cabb5) )
1821	1819	ROM_LOAD( "mpr-14783.c3", 0x200000, 0x100000, CRC(ef202bec) SHA1(b557092f8a3e1c9889d34588344c6dd2c6f06731) )
1822	1820
1823		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1821	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1824	1822	ROM_LOAD16_BYTE( "mpr-14788.c10", 0x000001, 0x100000, CRC(b5b05536) SHA1(f8fde7ebca38c0a6f6a864c17771aa155e6fc30d) )
1825	1823	ROM_LOAD16_BYTE( "mpr-14796.a10", 0x000000, 0x100000, CRC(c033220a) SHA1(279d3ef62b41d2c6a18ce1217a549402a874638b) )
1826	1824	ROM_LOAD16_BYTE( "mpr-14789.c11", 0x200001, 0x100000, CRC(0f9bcb97) SHA1(c15ab3ece596c54e1c4d8e8a755473609334e8ba) )
r17593	r17594
1860	1858	ROM_LOAD( "epr-13415.c2", 0x40000, 0x40000, CRC(bbb62c48) SHA1(7a4c5bd11b73a92deece72b55627f48ac167acd6) )
1861	1859	ROM_LOAD( "epr-13416.c3", 0x80000, 0x40000, CRC(1d11dbae) SHA1(331aa49c6b38d32ec33184dbd0851888463ddbc7) )
1862	1860
1863		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1861	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1864	1862	ROM_LOAD16_BYTE( "epr-13603.a10", 0x000000, 0x80000, CRC(5350a94e) SHA1(47e99803cab4b508feb51069c940d6c824d6961d) )
1865	1863	ROM_LOAD16_BYTE( "epr-13604.c10", 0x000001, 0x80000, CRC(4009c8e5) SHA1(97f513d312f4c90f8bffdf797afa3749779989a5) )
1866	1864	ROM_LOAD16_BYTE( "mpr-13421.a11", 0x200000, 0x80000, CRC(2fc75890) SHA1(9f97f07dba3b978df8eb357894168ad74f151d30) )
r17593	r17594
1900	1898	ROM_LOAD( "epr-13415.c2", 0x40000, 0x40000, CRC(bbb62c48) SHA1(7a4c5bd11b73a92deece72b55627f48ac167acd6) )
1901	1899	ROM_LOAD( "epr-13416.c3", 0x80000, 0x40000, CRC(1d11dbae) SHA1(331aa49c6b38d32ec33184dbd0851888463ddbc7) )
1902	1900
1903		ROM_REGION16_BE( 0x800000, "gfx2", 0 ) // sprites
	1901	ROM_REGION16_BE( 0x800000, "sprites", 0 ) // sprites
1904	1902	ROM_LOAD16_BYTE( "epr-13603.a10", 0x000000, 0x80000, CRC(5350a94e) SHA1(47e99803cab4b508feb51069c940d6c824d6961d) )
1905	1903	ROM_LOAD16_BYTE( "epr-13604.c10", 0x000001, 0x80000, CRC(4009c8e5) SHA1(97f513d312f4c90f8bffdf797afa3749779989a5) )
1906	1904	ROM_LOAD16_BYTE( "mpr-13421.a11", 0x200000, 0x80000, CRC(2fc75890) SHA1(9f97f07dba3b978df8eb357894168ad74f151d30) )
r17593	r17594
1939	1937	ROM_LOAD( "mpr-13217.b2", 0x40000, 0x40000, CRC(7d1ac3ec) SHA1(8495357304f1df135bba77ef3b96e79a883b8ff0) )
1940	1938	ROM_LOAD( "mpr-13218.b3", 0x80000, 0x40000, CRC(56d3393c) SHA1(50a2d065060692c9ecaa56046a781cb21d93e554) )
1941	1939
1942		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	1940	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
1943	1941	ROM_LOAD16_BYTE( "mpr-13224.b11", 0x000001, 0x40000, CRC(c59f107b) SHA1(10fa60fca6e34eda277c483bb1c0e81bb88c8a47) )
1944	1942	ROM_LOAD16_BYTE( "mpr-13231.a11", 0x000000, 0x40000, CRC(a5e96346) SHA1(a854f4dd5dc16975373255110fdb8ab3d121b1af) )
1945	1943	ROM_LOAD16_BYTE( "mpr-13223.b10", 0x080001, 0x40000, CRC(364f60ff) SHA1(9ac887ec0b2e32b504b7c6a5f3bb1ce3fe41a15a) )
r17593	r17594
1977	1975	ROM_LOAD( "mpr-13217.b2", 0x40000, 0x40000, CRC(7d1ac3ec) SHA1(8495357304f1df135bba77ef3b96e79a883b8ff0) )
1978	1976	ROM_LOAD( "mpr-13218.b3", 0x80000, 0x40000, CRC(56d3393c) SHA1(50a2d065060692c9ecaa56046a781cb21d93e554) )
1979	1977
1980		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	1978	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
1981	1979	ROM_LOAD16_BYTE( "mpr-13224.b11", 0x000001, 0x40000, CRC(c59f107b) SHA1(10fa60fca6e34eda277c483bb1c0e81bb88c8a47) )
1982	1980	ROM_LOAD16_BYTE( "mpr-13231.a11", 0x000000, 0x40000, CRC(a5e96346) SHA1(a854f4dd5dc16975373255110fdb8ab3d121b1af) )
1983	1981	ROM_LOAD16_BYTE( "mpr-13223.b10", 0x080001, 0x40000, CRC(364f60ff) SHA1(9ac887ec0b2e32b504b7c6a5f3bb1ce3fe41a15a) )
r17593	r17594
2015	2013	ROM_LOAD( "mpr-13217.b2", 0x40000, 0x40000, CRC(7d1ac3ec) SHA1(8495357304f1df135bba77ef3b96e79a883b8ff0) )
2016	2014	ROM_LOAD( "mpr-13218.b3", 0x80000, 0x40000, CRC(56d3393c) SHA1(50a2d065060692c9ecaa56046a781cb21d93e554) )
2017	2015
2018		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	2016	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
2019	2017	ROM_LOAD16_BYTE( "mpr-13224.b11", 0x000001, 0x40000, CRC(c59f107b) SHA1(10fa60fca6e34eda277c483bb1c0e81bb88c8a47) )
2020	2018	ROM_LOAD16_BYTE( "mpr-13231.a11", 0x000000, 0x40000, CRC(a5e96346) SHA1(a854f4dd5dc16975373255110fdb8ab3d121b1af) )
2021	2019	ROM_LOAD16_BYTE( "mpr-13223.b10", 0x080001, 0x40000, CRC(364f60ff) SHA1(9ac887ec0b2e32b504b7c6a5f3bb1ce3fe41a15a) )
r17593	r17594
2057	2055	ROM_LOAD( "epr-13098.b2", 0x40000, 0x40000, CRC(89fc9a9b) SHA1(d98691eb5fef8aca4ad5e416d0a3797d6ca9b012) )
2058	2056	ROM_LOAD( "epr-13099.b3", 0x80000, 0x40000, CRC(790e0ac6) SHA1(a4999b7015ef27d6cbe4f53bc0d7fe05ee40d178) )
2059	2057
2060		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	2058	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
2061	2059	ROM_LOAD16_BYTE( "epr-13173.b11",  0x000001, 0x40000, CRC(40a0ddfa) SHA1(f3917361f627865d2f1a22791904da056ce8a93a) )
2062	2060	ROM_LOAD16_BYTE( "epr-13176.a11",  0x000000, 0x40000, CRC(1184fbd2) SHA1(685ee2d7c4a0134af13ccf5d15f2e56a6b905195) )
2063	2061
r17593	r17594
2083	2081	ROM_LOAD( "mpr-12713.b2",  0x40000, 0x40000, CRC(852d2b1c) SHA1(8e5bc83d45e48b621ea3016207f2028fe41701e6) )
2084	2082	ROM_LOAD( "mpr-12714.b3",  0x80000, 0x40000, CRC(448226ce) SHA1(3060e4a43311069e2691d659c1e0c1a48edfeedb) )
2085	2083
2086		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	2084	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
2087	2085	ROM_LOAD16_BYTE( "mpr-12719.b11", 0x000001, 0x40000, CRC(d6888534) SHA1(2201f1921a68cf39e5a94b487c90e48d032d630f) )
2088	2086	ROM_LOAD16_BYTE( "mpr-12726.a11", 0x000000, 0x40000, CRC(ff344945) SHA1(2743778c42f53321f9691d60bbf94ea8baf1382f) )
2089	2087	ROM_LOAD16_BYTE( "mpr-12718.b10", 0x080001, 0x40000, CRC(ba2efc0c) SHA1(459a1a280f870c94aefb70127ed007cb090ed203) )
r17593	r17594
2113	2111	ROM_LOAD( "mpr-12713.b2",  0x40000, 0x40000, CRC(852d2b1c) SHA1(8e5bc83d45e48b621ea3016207f2028fe41701e6) )
2114	2112	ROM_LOAD( "mpr-12714.b3",  0x80000, 0x40000, CRC(448226ce) SHA1(3060e4a43311069e2691d659c1e0c1a48edfeedb) )
2115	2113
2116		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	2114	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
2117	2115	ROM_LOAD16_BYTE( "mpr-12719.b11", 0x000001, 0x40000, CRC(d6888534) SHA1(2201f1921a68cf39e5a94b487c90e48d032d630f) )
2118	2116	ROM_LOAD16_BYTE( "mpr-12726.a11", 0x000000, 0x40000, CRC(ff344945) SHA1(2743778c42f53321f9691d60bbf94ea8baf1382f) )
2119	2117	ROM_LOAD16_BYTE( "mpr-12718.b10", 0x080001, 0x40000, CRC(ba2efc0c) SHA1(459a1a280f870c94aefb70127ed007cb090ed203) )
r17593	r17594
2147	2145	ROM_LOAD( "mpr-12713.b2",  0x40000, 0x40000, CRC(852d2b1c) SHA1(8e5bc83d45e48b621ea3016207f2028fe41701e6) )
2148	2146	ROM_LOAD( "mpr-12714.b3",  0x80000, 0x40000, CRC(448226ce) SHA1(3060e4a43311069e2691d659c1e0c1a48edfeedb) )
2149	2147
2150		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	2148	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
2151	2149	ROM_LOAD16_BYTE( "mpr-12719.b11", 0x000001, 0x40000, CRC(d6888534) SHA1(2201f1921a68cf39e5a94b487c90e48d032d630f) )
2152	2150	ROM_LOAD16_BYTE( "mpr-12726.a11", 0x000000, 0x40000, CRC(ff344945) SHA1(2743778c42f53321f9691d60bbf94ea8baf1382f) )
2153	2151	ROM_LOAD16_BYTE( "mpr-12718.b10", 0x080001, 0x40000, CRC(ba2efc0c) SHA1(459a1a280f870c94aefb70127ed007cb090ed203) )
r17593	r17594
2183	2181	ROM_LOAD( "mpr-14720.c2", 0x040000, 0x40000, CRC(f96d19f4) SHA1(e350b551db8d01062397cd9a0c952a7b5dbf3fe6) )
2184	2182	ROM_LOAD( "mpr-14721.c3", 0x080000, 0x40000, CRC(c4ced91d) SHA1(4c8a070959ca10e2dddf407ddbba212415d78727) )
2185	2183
2186		ROM_REGION16_BE( 0x500000, "gfx2", 0 ) // sprites
	2184	ROM_REGION16_BE( 0x500000, "sprites", 0 ) // sprites
2187	2185	ROM_LOAD16_BYTE( "mpr-14726.c10", 0x000001, 0x100000, CRC(7213d1d3) SHA1(b70346a1dd3aa112bc696a7f4dd9ca908c3e5afa) )
2188	2186	ROM_LOAD16_BYTE( "mpr-14732.a10", 0x000000, 0x100000, CRC(04ced549) SHA1(59fd6510f0e14613d830ac6527f12ccc0b9351a5) )
2189	2187	ROM_LOAD16_BYTE( "mpr-14727.c11", 0x200001, 0x100000, CRC(3b74e0f0) SHA1(40432dbbbf75dae1e5e32b7cc2c4884f5e9e3bf5) )
r17593	r17594
2216	2214	ROM_LOAD( "mpr-14720.c2", 0x040000, 0x40000, CRC(f96d19f4) SHA1(e350b551db8d01062397cd9a0c952a7b5dbf3fe6) )
2217	2215	ROM_LOAD( "mpr-14721.c3", 0x080000, 0x40000, CRC(c4ced91d) SHA1(4c8a070959ca10e2dddf407ddbba212415d78727) )
2218	2216
2219		ROM_REGION16_BE( 0x500000, "gfx2", 0 ) // sprites
	2217	ROM_REGION16_BE( 0x500000, "sprites", 0 ) // sprites
2220	2218	ROM_LOAD16_BYTE( "mpr-14726.c10", 0x000001, 0x100000, CRC(7213d1d3) SHA1(b70346a1dd3aa112bc696a7f4dd9ca908c3e5afa) )
2221	2219	ROM_LOAD16_BYTE( "mpr-14732.a10", 0x000000, 0x100000, CRC(04ced549) SHA1(59fd6510f0e14613d830ac6527f12ccc0b9351a5) )
2222	2220	ROM_LOAD16_BYTE( "mpr-14727.c11", 0x200001, 0x100000, CRC(3b74e0f0) SHA1(40432dbbbf75dae1e5e32b7cc2c4884f5e9e3bf5) )

trunk/src/mame/drivers/segaorun.c

r17593	r17594
428	428	break;
429	429
430	430	case 3:
431		mapper.map_as_ram(0x00000, 0x01000, 0xfff000, "spriteram", write16_delegate());
	431	mapper.map_as_ram(0x00000, 0x01000, 0xfff000, "sprites", write16_delegate());
432	432	break;
433	433
434	434	case 2:
435		mapper.map_as_ram(0x00000, 0x02000, 0xffe000, "paletteram", write16_delegate(FUNC(segaorun_state::legacy_wrapper<segaic16_paletteram_w>), this));
	435	mapper.map_as_ram(0x00000, 0x02000, 0xffe000, "paletteram", write16_delegate(FUNC(segaorun_state::paletteram_w), this));
436	436	break;
437	437
438	438	case 1:
r17593	r17594
484	484	if (!m_custom_io_r.isnull())
485	485	return m_custom_io_r(space, offset, mem_mask);
486	486	logerror("%06X:misc_io_r - unknown read access to address %04X\n", cpu_get_pc(&space.device()), offset * 2);
487		return segaic16_open_bus_r(&space, 0, mem_mask);
	487	return open_bus_r(space, 0, mem_mask);
488	488	}
489	489
490	490
r17593	r17594
657	657	}
658	658
659	659	logerror("%06X:outrun_custom_io_r - unknown read access to address %04X\n", cpu_get_pc(&space.device()), offset * 2);
660		return segaic16_open_bus_r(&space, 0, mem_mask);
	660	return open_bus_r(space, 0, mem_mask);
661	661	}
662	662
663	663
r17593	r17594
695	695	return;
696	696
697	697	case 0x70/2:
698		segaic16_sprites_draw_0_w(&space, offset, data, mem_mask);
	698	m_sprites->draw_write(space, offset, data, mem_mask);
699	699	return;
700	700	}
701	701	logerror("%06X:misc_io_w - unknown write access to address %04X = %04X & %04X\n", cpu_get_pc(&space.device()), offset * 2, data, mem_mask);
r17593	r17594
728	728	}
729	729	}
730	730	logerror("%06X:misc_io_r - unknown read access to address %04X\n", cpu_get_pc(&space.device()), offset * 2);
731		return segaic16_open_bus_r(&space,0,mem_mask);
	731	return open_bus_r(space,0,mem_mask);
732	732	}
733	733
734	734
r17593	r17594
814	814
815	815	// these get overwritten by the memory mapper above, but we put them here
816	816	// so they are properly allocated and tracked for saving
817		AM_RANGE(0x100000, 0x100fff) AM_RAM AM_SHARE("spriteram")
	817	AM_RANGE(0x100000, 0x100fff) AM_RAM AM_SHARE("sprites")
818	818	AM_RANGE(0x200000, 0x201fff) AM_RAM AM_SHARE("paletteram")
819	819	AM_RANGE(0x300000, 0x30ffff) AM_RAM AM_SHARE("tileram")
820	820	AM_RANGE(0x400000, 0x400fff) AM_RAM AM_SHARE("textram")
r17593	r17594
1111	1111	//**************************************************************************
1112	1112
1113	1113	static MACHINE_CONFIG_DERIVED( outrundx, outrun_base )
1114		MCFG_SEGA16SP_ADD_OUTRUN("segaspr1")
	1114	MCFG_SEGA_OUTRUN_SPRITES_ADD("sprites")
1115	1115	MACHINE_CONFIG_END
1116	1116
1117	1117	static MACHINE_CONFIG_DERIVED( outrun, outrun_base )
1118	1118	MCFG_NVRAM_ADD_0FILL("nvram")
1119	1119
1120		MCFG_SEGA16SP_ADD_OUTRUN("segaspr1")
	1120	MCFG_SEGA_OUTRUN_SPRITES_ADD("sprites")
1121	1121	MACHINE_CONFIG_END
1122	1122
1123	1123	static MACHINE_CONFIG_DERIVED( outrun_fd1094, outrun )
r17593	r17594
1133	1133	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK_25MHz/4, 400, 0, 321, 262, 0, 224)
1134	1134	MCFG_SCREEN_UPDATE_DRIVER(segaorun_state, screen_update_shangon)
1135	1135
1136		MCFG_SEGA16SP_ADD_16B("segaspr1")
	1136	MCFG_SEGA_SYS16B_SPRITES_ADD("sprites")
1137	1137	MACHINE_CONFIG_END
1138	1138
1139	1139	static MACHINE_CONFIG_DERIVED( shangon_fd1089b, shangon )
r17593	r17594
1184	1184	ROM_LOAD( "opr-10266.101", 0x20000, 0x08000, CRC(9f6f1a74) SHA1(09164e858ebeedcff4d389524ddf89e7c216dcae) )
1185	1185	ROM_LOAD( "opr-10230.104", 0x28000, 0x08000, CRC(686f5e50) SHA1(03697b892f911177968aa40de6c5f464eb0258e7) )
1186	1186
1187		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1187	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1188	1188	// VIDEO BD 837-6064-02 uses mask roms four times the size of those used on VIDEO BD 837-6064-01, same data
1189	1189	ROM_LOAD32_BYTE( "mpr-10371.9",  0x00000, 0x20000, CRC(7cc86208) SHA1(21320f945f7c8e990c97c9b1232a0f4b6bd00f8f) )
1190	1190	ROM_LOAD32_BYTE( "mpr-10373.10", 0x00001, 0x20000, CRC(b0d26ac9) SHA1(3a9ce8547cd43b7b04abddf9a9ab5634e0bbfaba) )
r17593	r17594
1245	1245	ROM_LOAD( "opr-10266.101", 0x20000, 0x08000, CRC(9f6f1a74) SHA1(09164e858ebeedcff4d389524ddf89e7c216dcae) )
1246	1246	ROM_LOAD( "opr-10230.104", 0x28000, 0x08000, CRC(686f5e50) SHA1(03697b892f911177968aa40de6c5f464eb0258e7) )
1247	1247
1248		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1248	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1249	1249	// VIDEO BD 837-6064-02 uses mask roms four times the size of those used on VIDEO BD 837-6064-01, same data
1250	1250	ROM_LOAD32_BYTE( "mpr-10371.9",  0x00000, 0x20000, CRC(7cc86208) SHA1(21320f945f7c8e990c97c9b1232a0f4b6bd00f8f) )
1251	1251	ROM_LOAD32_BYTE( "mpr-10373.10", 0x00001, 0x20000, CRC(b0d26ac9) SHA1(3a9ce8547cd43b7b04abddf9a9ab5634e0bbfaba) )
r17593	r17594
1306	1306	ROM_LOAD( "opr-10266.101", 0x20000, 0x08000, CRC(9f6f1a74) SHA1(09164e858ebeedcff4d389524ddf89e7c216dcae) )
1307	1307	ROM_LOAD( "opr-10230.104", 0x28000, 0x08000, CRC(686f5e50) SHA1(03697b892f911177968aa40de6c5f464eb0258e7) )
1308	1308
1309		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1309	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1310	1310	// VIDEO BD 837-6064-01 uses eproms a fourth of the size of those used on VIDEO BD 837-6064-02, same data
1311	1311	ROM_LOAD32_BYTE( "epr-10194.26", 0x00000, 0x08000, CRC(f0eda3bd) SHA1(173e10a10372d42da81e6eb48c3e23a117638c0c) )
1312	1312	ROM_LOAD32_BYTE( "epr-10203.38", 0x00001, 0x08000, CRC(8445a622) SHA1(1187dee7db09a42446fc75872d49936310141eb8) )
r17593	r17594
1400	1400	ROM_LOAD( "opr-10266.101", 0x20000, 0x08000, CRC(9f6f1a74) SHA1(09164e858ebeedcff4d389524ddf89e7c216dcae) )
1401	1401	ROM_LOAD( "opr-10230.104", 0x28000, 0x08000, CRC(686f5e50) SHA1(03697b892f911177968aa40de6c5f464eb0258e7) )
1402	1402
1403		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1403	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1404	1404	// VIDEO BD 837-6064-01 uses eproms a fourth of the size of those used on VIDEO BD 837-6064-02, same data
1405	1405	ROM_LOAD32_BYTE( "epr-10194.26", 0x00000, 0x08000, CRC(f0eda3bd) SHA1(173e10a10372d42da81e6eb48c3e23a117638c0c) )
1406	1406	ROM_LOAD32_BYTE( "epr-10203.38", 0x00001, 0x08000, CRC(8445a622) SHA1(1187dee7db09a42446fc75872d49936310141eb8) )
r17593	r17594
1507	1507	ROM_LOAD( "a-17.bin",   0x10000, 0x10000, CRC(899c781d) SHA1(4f759c316a57a1e42838375525290425d25b53e1) )
1508	1508	ROM_LOAD( "a-16.bin",   0x20000, 0x10000, CRC(98dd4d15) SHA1(914ebcb330455ab35968b4add4d94be123a185a5) )
1509	1509
1510		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1510	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1511	1511	ROM_LOAD32_BYTE( "a-18.bin",   0x00000, 0x10000, CRC(77377e00) SHA1(4f376b05692f33d529f4c058dac989136c808ca1) )
1512	1512	ROM_LOAD32_BYTE( "a-20.bin",   0x00001, 0x10000, CRC(69ecc975) SHA1(3560e9a31fc71e263a6ff61224b8db2b17836075) )
1513	1513	ROM_LOAD32_BYTE( "a-22.bin",   0x00002, 0x10000, CRC(b6a8d0e2) SHA1(6184700dbe2c8c9c91f220e246501b7a865e4a05) )
r17593	r17594
1569	1569	ROM_LOAD( "epr-10651.55", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1570	1570	ROM_LOAD( "epr-10650.56", 0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1571	1571
1572		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	1572	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
1573	1573	// Super Hang-On Video board 837-6279-01 (mask rom type), same data but mask roms twice the size as "EPR" counterparts
1574	1574	ROM_LOAD16_BYTE( "mpr-10794.8",    0x000001, 0x020000, CRC(7c958e63) SHA1(ef79614e94280607a6cdf6e13db051accfd2add0) )
1575	1575	ROM_LOAD16_BYTE( "mpr-10798.16", 0x000000, 0x020000, CRC(7d58f807) SHA1(783c9929d27a0270b3f7d5eb799cee6b2e5b7ae5) )
r17593	r17594
1628	1628	ROM_LOAD( "epr-10651.55", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1629	1629	ROM_LOAD( "epr-10650.56", 0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1630	1630
1631		ROM_REGION16_BE( 0x0e0000, "gfx2", 0 ) // sprites
	1631	ROM_REGION16_BE( 0x0e0000, "sprites", 0 ) // sprites
1632	1632	ROM_LOAD16_BYTE( "epr-10675.8",    0x000001, 0x010000, CRC(d6ac012b) SHA1(305023b1a0a9d84cfc081ffc2ad7578b53d562f2) )
1633	1633	ROM_LOAD16_BYTE( "epr-10682.16", 0x000000, 0x010000, CRC(d9d83250) SHA1(f8ca3197edcdf53643a5b335c3c044ddc1310cd4) )
1634	1634	ROM_LOAD16_BYTE( "epr-10676.7",  0x020001, 0x010000, CRC(25ebf2c5) SHA1(abcf673ae4e280417dd9f46d18c0ec7c0e4802ae) )
r17593	r17594
1689	1689	ROM_LOAD( "epr-10651.55", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1690	1690	ROM_LOAD( "epr-10650.56", 0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1691	1691
1692		ROM_REGION16_BE( 0x0e0000, "gfx2", 0 ) // sprites
	1692	ROM_REGION16_BE( 0x0e0000, "sprites", 0 ) // sprites
1693	1693	ROM_LOAD16_BYTE( "epr-10675.8",    0x000001, 0x010000, CRC(d6ac012b) SHA1(305023b1a0a9d84cfc081ffc2ad7578b53d562f2) )
1694	1694	ROM_LOAD16_BYTE( "epr-10682.16", 0x000000, 0x010000, CRC(d9d83250) SHA1(f8ca3197edcdf53643a5b335c3c044ddc1310cd4) )
1695	1695	ROM_LOAD16_BYTE( "epr-10676.7",  0x020001, 0x010000, CRC(25ebf2c5) SHA1(abcf673ae4e280417dd9f46d18c0ec7c0e4802ae) )
r17593	r17594
1750	1750	ROM_LOAD( "epr-10651.55", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1751	1751	ROM_LOAD( "epr-10650.56", 0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1752	1752
1753		ROM_REGION16_BE( 0x0e0000, "gfx2", 0 ) // sprites
	1753	ROM_REGION16_BE( 0x0e0000, "sprites", 0 ) // sprites
1754	1754	ROM_LOAD16_BYTE( "epr-10675.8",    0x000001, 0x010000, CRC(d6ac012b) SHA1(305023b1a0a9d84cfc081ffc2ad7578b53d562f2) )
1755	1755	ROM_LOAD16_BYTE( "epr-10682.16", 0x000000, 0x010000, CRC(d9d83250) SHA1(f8ca3197edcdf53643a5b335c3c044ddc1310cd4) )
1756	1756	ROM_LOAD16_BYTE( "epr-10676.7",  0x020001, 0x010000, CRC(25ebf2c5) SHA1(abcf673ae4e280417dd9f46d18c0ec7c0e4802ae) )
r17593	r17594
1811	1811	ROM_LOAD( "epr-10651.55", 0x08000, 0x08000, CRC(c609ee7b) SHA1(c6dacf81cbfe7e5df1f9a967cf571be1dcf1c429) )
1812	1812	ROM_LOAD( "epr-10650.56", 0x10000, 0x08000, CRC(b236a403) SHA1(af02b8122794c083a66f2ab35d2c73b84b2df0be) )
1813	1813
1814		ROM_REGION16_BE( 0x0e0000, "gfx2", 0 ) // sprites
	1814	ROM_REGION16_BE( 0x0e0000, "sprites", 0 ) // sprites
1815	1815	ROM_LOAD16_BYTE( "epr-10675.8",    0x000001, 0x010000, CRC(d6ac012b) SHA1(305023b1a0a9d84cfc081ffc2ad7578b53d562f2) )
1816	1816	ROM_LOAD16_BYTE( "epr-10682.16", 0x000000, 0x010000, CRC(d9d83250) SHA1(f8ca3197edcdf53643a5b335c3c044ddc1310cd4) )
1817	1817	ROM_LOAD16_BYTE( "epr-13945.7",  0x020001, 0x010000, CRC(fbb1eef9) SHA1(2798df2f25706e0d3be01d945274f478d7e5a2ae) )
r17593	r17594
1878	1878	ROM_LOAD( "opr-12324.103", 0x10000, 0x10000, CRC(24607a55) SHA1(69033f2281cd42e88233c23d809b73607fe54853) )
1879	1879	ROM_LOAD( "opr-12325.104", 0x20000, 0x10000, CRC(1405137a) SHA1(367db88d36852e35c5e839f692be5ea8c8e072d2) )
1880	1880
1881		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1881	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1882	1882	// Video BD 837-6906-2, Mask Roms twice the size as EPR/OPR counterparts
1883	1883	ROM_LOAD32_BYTE( "mpr-12336.9",   0x00000, 0x20000, CRC(dda465c7) SHA1(83acc12a387b004986f084f25964c15a9f88a41a) )
1884	1884	ROM_LOAD32_BYTE( "mpr-12337.10",  0x00001, 0x20000, CRC(828233d1) SHA1(d73a200af4245d590e1fd3ac436723f99cc50452) )
r17593	r17594
1938	1938	ROM_LOAD( "opr-12324.103", 0x10000, 0x10000, CRC(24607a55) SHA1(69033f2281cd42e88233c23d809b73607fe54853) )
1939	1939	ROM_LOAD( "opr-12325.104", 0x20000, 0x10000, CRC(1405137a) SHA1(367db88d36852e35c5e839f692be5ea8c8e072d2) )
1940	1940
1941		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	1941	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
1942	1942	ROM_LOAD32_BYTE( "opr-12307.9",  0x00000, 0x10000, CRC(437dcf09) SHA1(0022ee4d1c3698f77271e570cef98a8a1e5c5d6a) )
1943	1943	ROM_LOAD32_BYTE( "opr-12308.10", 0x00001, 0x10000, CRC(0de70cc2) SHA1(c03f8f8cda72daf64af2878bf254840ac6dd17eb) )
1944	1944	ROM_LOAD32_BYTE( "opr-12309.11", 0x00002, 0x10000, CRC(deb8c242) SHA1(c05d8ced4eafae52c4795fb1471cd66f5903d1aa) )
r17593	r17594
2005	2005	ROM_LOAD( "opr-12324.103", 0x10000, 0x10000, CRC(24607a55) SHA1(69033f2281cd42e88233c23d809b73607fe54853) )
2006	2006	ROM_LOAD( "opr-12325.104", 0x20000, 0x10000, CRC(1405137a) SHA1(367db88d36852e35c5e839f692be5ea8c8e072d2) )
2007	2007
2008		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	2008	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
2009	2009	ROM_LOAD32_BYTE( "opr-12307.9",  0x00000, 0x10000, CRC(437dcf09) SHA1(0022ee4d1c3698f77271e570cef98a8a1e5c5d6a) )
2010	2010	ROM_LOAD32_BYTE( "opr-12308.10", 0x00001, 0x10000, CRC(0de70cc2) SHA1(c03f8f8cda72daf64af2878bf254840ac6dd17eb) )
2011	2011	ROM_LOAD32_BYTE( "opr-12309.11", 0x00002, 0x10000, CRC(deb8c242) SHA1(c05d8ced4eafae52c4795fb1471cd66f5903d1aa) )
r17593	r17594
2066	2066	ROM_LOAD( "opr-12324.103", 0x10000, 0x10000, CRC(24607a55) SHA1(69033f2281cd42e88233c23d809b73607fe54853) )
2067	2067	ROM_LOAD( "opr-12325.104", 0x20000, 0x10000, CRC(1405137a) SHA1(367db88d36852e35c5e839f692be5ea8c8e072d2) )
2068	2068
2069		ROM_REGION32_LE( 0x100000, "gfx2", 0 ) // sprites
	2069	ROM_REGION32_LE( 0x100000, "sprites", 0 ) // sprites
2070	2070	ROM_LOAD32_BYTE( "opr-12307.9",  0x00000, 0x10000, CRC(437dcf09) SHA1(0022ee4d1c3698f77271e570cef98a8a1e5c5d6a) )
2071	2071	ROM_LOAD32_BYTE( "opr-12308.10", 0x00001, 0x10000, CRC(0de70cc2) SHA1(c03f8f8cda72daf64af2878bf254840ac6dd17eb) )
2072	2072	ROM_LOAD32_BYTE( "opr-12309.11", 0x00002, 0x10000, CRC(deb8c242) SHA1(c05d8ced4eafae52c4795fb1471cd66f5903d1aa) )
r17593	r17594
2120	2120	m_nvram->set_base(m_workram, m_workram.bytes());
2121	2121
2122	2122	// point globals to allocated memory regions
2123		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
2124		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
2125	2123	segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
2126	2124	segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
2127	2125	segaic16_roadram_0 = reinterpret_cast<UINT16 *>(memshare("roadram")->ptr());

trunk/src/mame/drivers/system16.c

r17593	r17594
125	125	AM_RANGE(0x410000, 0x410fff) AM_RAM AM_SHARE("textram")
126	126	AM_RANGE(0x411000, 0x411fff) AM_RAM AM_SHARE("bg0_tileram")
127	127	AM_RANGE(0x412000, 0x412fff) AM_RAM AM_SHARE("bg1_tileram")
128		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
129		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
	128	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	129	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
130	130	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sound_command_nmi_w)
131	131	AM_RANGE(0xc41000, 0xc41001) AM_READ_PORT("SERVICE")
132	132	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
r17593	r17594
181	181	AM_RANGE(0x40a000, 0x40afff) AM_RAM AM_SHARE("bg1_tileram")
182	182	AM_RANGE(0x410000, 0x410fff) AM_RAM AM_SHARE("textram")
183	183
184		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
185		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	184	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	185	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
186	186	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sys16_coinctrl_w)
187	187	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
188	188	AM_RANGE(0xc41004, 0xc41005) AM_READ_PORT("P2")
r17593	r17594
259	259	AM_RANGE(0x409000, 0x40afff) AM_RAM AM_SHARE("bg0_tileram")
260	260	AM_RANGE(0x40a000, 0x40bfff) AM_RAM AM_SHARE("bg1_tileram")
261	261	AM_RANGE(0x410000, 0x410fff) AM_RAM AM_SHARE("textram")
262		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
263		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
	262	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	263	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
264	264	AM_RANGE(0xc41000, 0xc41001) AM_READ(passht4b_service_r)
265	265	AM_RANGE(0xc41002, 0xc41003) AM_READ(passht4b_io1_r)
266	266	AM_RANGE(0xc41004, 0xc41005) AM_READ(passht4b_io2_r)
r17593	r17594
308	308	AM_RANGE(0x409000, 0x40afff) AM_RAM AM_SHARE("bg0_tileram")
309	309	AM_RANGE(0x40a000, 0x40bfff) AM_RAM AM_SHARE("bg1_tileram")
310	310	AM_RANGE(0x410000, 0x410fff) AM_RAM AM_SHARE("textram")
311		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
312		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	311	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	312	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
313	313	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sys16_coinctrl_w)
314	314	AM_RANGE(0xc41000, 0xc41001) AM_READ_PORT("SERVICE")
315	315	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
r17593	r17594
510	510	AM_RANGE(0x000000, 0x0bffff) AM_ROM
511	511	AM_RANGE(0x100000, 0x100003) AM_WRITENOP // tilebank control?
512	512	AM_RANGE(0x500000, 0x503fff) AM_RAM // work ram
513		AM_RANGE(0x600000, 0x600fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	513	AM_RANGE(0x600000, 0x600fff) AM_RAM AM_SHARE("sprites")
514	514	AM_RANGE(0x700000, 0x70ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
515	515	AM_RANGE(0x710000, 0x710fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
516		AM_RANGE(0x800000, 0x800fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	516	AM_RANGE(0x800000, 0x800fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
517	517	AM_RANGE(0x900000, 0x900001) AM_WRITE(sys16_coinctrl_w)
518	518	AM_RANGE(0x901002, 0x901003) AM_READ_PORT("P1")
519	519	AM_RANGE(0x901006, 0x901007) AM_READ_PORT("P2")
r17593	r17594
606	606	AM_RANGE(0x118018, 0x118019) AM_WRITE(s16bl_bgscrollx_w)
607	607	AM_RANGE(0x118020, 0x118021) AM_WRITE(s16bl_fgpage_w)
608	608	AM_RANGE(0x118028, 0x118029) AM_WRITE(s16bl_bgpage_w)
609		AM_RANGE(0x140000, 0x143fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
610		AM_RANGE(0x200000, 0x200fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	609	AM_RANGE(0x140000, 0x143fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
	610	AM_RANGE(0x200000, 0x200fff) AM_RAM AM_SHARE("sprites")
611	611	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sys16_coinctrl_w)
612	612	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
613	613	AM_RANGE(0xc41006, 0xc41007) AM_READ_PORT("P2")
r17593	r17594
624	624	static ADDRESS_MAP_START( bayrouteb1_map, AS_PROGRAM, 16, segas1x_bootleg_state )
625	625	AM_RANGE(0x000000, 0x0bffff) AM_ROM
626	626	AM_RANGE(0x500000, 0x503fff) AM_RAM // work ram
627		AM_RANGE(0x600000, 0x600fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	627	AM_RANGE(0x600000, 0x600fff) AM_RAM AM_SHARE("sprites")
628	628	AM_RANGE(0x700000, 0x70ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
629	629	AM_RANGE(0x710000, 0x710fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
630	630	AM_RANGE(0x718000, 0x718001) AM_WRITE(s16bl_fgscrolly_w)
r17593	r17594
633	633	AM_RANGE(0x718018, 0x718019) AM_WRITE(s16bl_bgscrollx_w)
634	634	AM_RANGE(0x718020, 0x718021) AM_WRITE(s16bl_fgpage_w)
635	635	AM_RANGE(0x718028, 0x718029) AM_WRITE(s16bl_bgpage_w)
636		AM_RANGE(0x800000, 0x800fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	636	AM_RANGE(0x800000, 0x800fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
637	637	AM_RANGE(0x901000, 0x901001) AM_READ_PORT("SERVICE") AM_WRITE(sys16_coinctrl_w)
638	638	AM_RANGE(0x901002, 0x901003) AM_READ_PORT("P1")
639	639	AM_RANGE(0x901006, 0x901007) AM_READ_PORT("P2")
r17593	r17594
693	693	static ADDRESS_MAP_START( bayrouteb2_map, AS_PROGRAM, 16, segas1x_bootleg_state )
694	694	AM_RANGE(0x000000, 0x0bffff) AM_ROM
695	695	AM_RANGE(0x500000, 0x503fff) AM_RAM // work ram
696		AM_RANGE(0x600000, 0x600fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	696	AM_RANGE(0x600000, 0x600fff) AM_RAM AM_SHARE("sprites")
697	697	AM_RANGE(0x700000, 0x70ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
698	698	AM_RANGE(0x710000, 0x710fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
699	699	AM_RANGE(0x718000, 0x718001) AM_WRITE(s16bl_fgscrolly_w)
r17593	r17594
705	705	AM_RANGE(0x718024, 0x718025) AM_WRITE(datsu_page2_w)
706	706	AM_RANGE(0x718026, 0x718027) AM_WRITE(datsu_page3_w)
707	707
708		AM_RANGE(0x800000, 0x800fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	708	AM_RANGE(0x800000, 0x800fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
709	709	AM_RANGE(0x900000, 0x900001) AM_READ_PORT("DSW1")
710	710	AM_RANGE(0x900002, 0x900003) AM_READ_PORT("DSW2")
711	711	AM_RANGE(0x900006, 0x900007) AM_WRITE(sound_command_w)
r17593	r17594
719	719	AM_RANGE(0x3f0000, 0x3fffff) AM_WRITE(sys16_tilebank_w)
720	720	AM_RANGE(0x400000, 0x40ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
721	721	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
722		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
723		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
	722	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	723	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
724	724	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sys16_coinctrl_w)
725	725	AM_RANGE(0xc40006, 0xc40007) AM_WRITE(sound_command_w)
726	726	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
r17593	r17594
811	811	AM_RANGE(0x000000, 0x0bffff) AM_ROM
812	812	AM_RANGE(0x100000, 0x10ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
813	813	AM_RANGE(0x110000, 0x110fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
814		AM_RANGE(0x140000, 0x143fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
815		AM_RANGE(0x200000, 0x200fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	814	AM_RANGE(0x140000, 0x143fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
	815	AM_RANGE(0x200000, 0x200fff) AM_RAM AM_SHARE("sprites")
816	816	AM_RANGE(0xc40000, 0xc40001) AM_READ_PORT("DSW2") AM_WRITENOP
817	817	AM_RANGE(0xc40002, 0xc40003) AM_READ_PORT("DSW1")
818	818	AM_RANGE(0xc41000, 0xc41001) AM_READ_PORT("SERVICE")
r17593	r17594
840	840
841	841	AM_RANGE(0x400000, 0x40ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
842	842	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
843		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	843	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
844	844
845	845	AM_RANGE(0x600006, 0x600007) AM_WRITE(sound_command_w)
846	846	AM_RANGE(0x601000, 0x601001) AM_READ_PORT("SERVICE")
r17593	r17594
849	849	AM_RANGE(0x600000, 0x600001) AM_READ_PORT("DSW2")
850	850	AM_RANGE(0x600002, 0x600003) AM_READ_PORT("DSW1")
851	851
852		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	852	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
853	853	AM_RANGE(0x843000, 0x843001) AM_WRITENOP
854	854
855	855	AM_RANGE(0xC46000, 0xC46001) AM_WRITE(s16bl_fgscrolly_w)
r17593	r17594
889	889	AM_RANGE(0x418020, 0x418021) AM_WRITE(s16bl_bgpage_w)
890	890	AM_RANGE(0x418028, 0x418029) AM_WRITE(s16bl_fgpage_w)
891	891
892		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
893		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
	892	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	893	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
894	894	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sys16_coinctrl_w)
895	895	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
896	896	AM_RANGE(0xc41006, 0xc41007) AM_READ_PORT("P2")
r17593	r17594
916	916	AM_RANGE(0x418020, 0x418021) AM_WRITE(s16bl_fgpage_w)
917	917	AM_RANGE(0x418028, 0x418029) AM_WRITE(s16bl_bgpage_w)
918	918
919		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
920		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
	919	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	920	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
921	921	AM_RANGE(0xc40000, 0xc40001) AM_WRITE(sys16_coinctrl_w)
922	922	AM_RANGE(0xc41000, 0xc41001) AM_READ_PORT("SERVICE")
923	923	AM_RANGE(0xc41002, 0xc41003) AM_READ_PORT("P1")
r17593	r17594
956	956	AM_RANGE(0x418020, 0x418021) AM_WRITE(s16bl_bgpage_w)
957	957	AM_RANGE(0x418028, 0x418029) AM_WRITE(s16bl_fgpage_w)
958	958
959		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
960		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w)  AM_BASE_LEGACY(&segaic16_paletteram)
	959	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	960	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
961	961
962	962	AM_RANGE(0xC41000, 0xC41001) AM_READ(beautyb_unkx_r )
963	963	AM_RANGE(0xC41002, 0xC41003) AM_READ(beautyb_unkx_r )
r17593	r17594
973	973	static ADDRESS_MAP_START( tturfbl_map, AS_PROGRAM, 16, segas1x_bootleg_state )
974	974	AM_RANGE(0x000000, 0x03ffff) AM_ROM
975	975	AM_RANGE(0x200000, 0x203fff) AM_RAM // work ram
976		AM_RANGE(0x300000, 0x300fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	976	AM_RANGE(0x300000, 0x300fff) AM_RAM AM_SHARE("sprites")
977	977	AM_RANGE(0x400000, 0x40ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
978	978	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
979		AM_RANGE(0x500000, 0x500fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	979	AM_RANGE(0x500000, 0x500fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
980	980	AM_RANGE(0x600000, 0x600001) AM_WRITE(sys16_coinctrl_w)
981	981	AM_RANGE(0x600000, 0x600001) AM_READ_PORT("DSW2")
982	982	AM_RANGE(0x600002, 0x600003) AM_READ_PORT("DSW1")
r17593	r17594
1117	1117	AM_RANGE(0x000000, 0x07ffff) AM_ROM
1118	1118	AM_RANGE(0x400000, 0x40ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
1119	1119	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
1120		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
1121		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	1120	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	1121	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
1122	1122	AM_RANGE(0xc00000, 0xc0ffff) AM_NOP
1123	1123	AM_RANGE(0xc40000, 0xc40001) AM_READ_PORT("COINAGE")
1124	1124	AM_RANGE(0xc40002, 0xc40003) AM_READ_PORT("DSW1")
r17593	r17594
1258	1258	AM_RANGE(0x000000, 0x07ffff) AM_ROM
1259	1259	AM_RANGE(0x400000, 0x40ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
1260	1260	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
1261		AM_RANGE(0x440000, 0x440fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
1262		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
	1261	AM_RANGE(0x440000, 0x440fff) AM_RAM AM_SHARE("sprites")
	1262	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
1263	1263
1264	1264	/* bootleg video regs */
1265	1265	/*AM_RANGE(0xc00000, 0xc00001) AM_NOP
r17593	r17594
1300	1300	AM_RANGE(0x000000, 0x07ffff) AM_ROM
1301	1301	AM_RANGE(0x100000, 0x10ffff) AM_RAM_WRITE(sys16_tileram_w) AM_SHARE("tileram")
1302	1302	AM_RANGE(0x110000, 0x110fff) AM_RAM_WRITE(sys16_textram_w) AM_SHARE("textram")
1303		AM_RANGE(0x140000, 0x140fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_BASE_LEGACY(&segaic16_paletteram)
1304		AM_RANGE(0x200000, 0x200fff) AM_RAM AM_BASE_LEGACY(&segaic16_spriteram_0)
	1303	AM_RANGE(0x140000, 0x140fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
	1304	AM_RANGE(0x200000, 0x200fff) AM_RAM AM_SHARE("sprites")
1305	1305	AM_RANGE(0xa00000, 0xa00001) AM_READ_PORT("COINAGE")
1306	1306	AM_RANGE(0xa00002, 0xa00003) AM_READ_PORT("DSW1")
1307	1307	AM_RANGE(0xa00006, 0xa00007) AM_WRITE(sound_command_nmi_w)
r17593	r17594
2097	2097	MACHINE_CONFIG_END
2098	2098
2099	2099
2100		static const sega16sp_interface shinobld_sega16sp_intf =
2101		{
2102		0,      // which spriteram
2103		1024,  // colorbase
2104		0x800, // ramsize
2105		117,     // xoffs
2106		segaic16_sprites_16a_bootleg_shinobld_draw, // draw function
2107		0, // use buffer
2108		};
2109
2110	2100	static MACHINE_CONFIG_DERIVED( shinobib, system16 )
2111	2101
2112	2102	/* basic machine hardware */
2113	2103	MCFG_CPU_MODIFY("maincpu")
2114	2104	MCFG_CPU_PROGRAM_MAP(shinobib_map)
2115	2105
2116		MCFG_SEGA16SP_ADD("segaspr1", shinobld_sega16sp_intf)
	2106	MCFG_BOOTLEG_SYS16A_SPRITES_ADD("sprites")
	2107	MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(189-117)
2117	2108
2118	2109	MCFG_VIDEO_START( s16a_bootleg_shinobi )
2119	2110	MCFG_SCREEN_MODIFY("screen")
2120	2111	MCFG_SCREEN_UPDATE_STATIC( s16a_bootleg )
2121	2112	MACHINE_CONFIG_END
2122	2113
2123		static const sega16sp_interface passshtb_sega16sp_intf =
2124		{
2125		0,      // which spriteram
2126		1024,  // colorbase
2127		0x800, // ramsize
2128		117,     // xoffs
2129		segaic16_sprites_16a_bootleg_passhtb_draw, // draw function
2130		0, // use buffer
2131		};
2132
2133	2114	static MACHINE_CONFIG_DERIVED( passshtb, system16_7759 )
2134	2115
2135	2116	/* basic machine hardware */
2136	2117	MCFG_CPU_MODIFY("maincpu")
2137	2118	MCFG_CPU_PROGRAM_MAP(passshtb_map)
2138	2119
2139		MCFG_SEGA16SP_ADD("segaspr1", passshtb_sega16sp_intf)
	2120	MCFG_BOOTLEG_SYS16A_SPRITES_ADD("sprites")
	2121	MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(189-117)
	2122	MCFG_BOOTLEG_SYS16A_SPRITES_REMAP(1,0,3,2,5,4,7,6)
2140	2123
2141	2124	MCFG_VIDEO_START( s16a_bootleg_passsht )
2142	2125	MCFG_SCREEN_MODIFY("screen")
r17593	r17594
2151	2134	MCFG_CPU_PROGRAM_MAP(passht4b_map)
2152	2135
2153	2136	// wrong
2154		MCFG_SEGA16SP_ADD("segaspr1", passshtb_sega16sp_intf)
	2137	MCFG_BOOTLEG_SYS16A_SPRITES_ADD("sprites")
	2138	MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(189-117)
	2139	MCFG_BOOTLEG_SYS16A_SPRITES_REMAP(1,0,3,2,5,4,7,6)
2155	2140
2156	2141	MCFG_VIDEO_START( s16a_bootleg_passsht )
2157	2142	MCFG_SCREEN_MODIFY("screen")
2158	2143	MCFG_SCREEN_UPDATE_STATIC( s16a_bootleg_passht4b )
2159	2144	MACHINE_CONFIG_END
2160	2145
2161		static const sega16sp_interface wb3bbl_sega16sp_intf =
2162		{
2163		0,      // which spriteram
2164		1024,  // colorbase
2165		0x800, // ramsize
2166		117,     // xoffs
2167		segaic16_sprites_16a_bootleg_wb3bl_draw, // draw function
2168		0, // use buffer
2169		};
2170
2171	2146	static MACHINE_CONFIG_DERIVED( wb3bb, system16 )
2172	2147
2173	2148	/* basic machine hardware */
2174	2149	MCFG_CPU_MODIFY("maincpu")
2175	2150	MCFG_CPU_PROGRAM_MAP(wb3bbl_map)
2176	2151
2177		MCFG_SEGA16SP_ADD("segaspr1", wb3bbl_sega16sp_intf)
	2152	MCFG_BOOTLEG_SYS16A_SPRITES_ADD("sprites")
	2153	MCFG_BOOTLEG_SYS16A_SPRITES_XORIGIN(189-117)
	2154	MCFG_BOOTLEG_SYS16A_SPRITES_REMAP(4,0,5,1,6,2,7,3)
	2155	MCFG_BOOTLEG_SYS16A_SPRITES_YORIGIN(0)
2178	2156
2179	2157	MCFG_VIDEO_START( s16a_bootleg_wb3bl )
2180	2158	MCFG_SCREEN_MODIFY("screen")
r17593	r17594
2182	2160	MACHINE_CONFIG_END
2183	2161
2184	2162
2185		static const sega16sp_interface s16bbl_x121_sega16sp_intf =
2186		{
2187		0,      // which spriteram
2188		1024,  // colorbase
2189		0x800, // ramsize
2190		121,     // xoffs
2191		segaic16_sprites_16b_draw, // draw function
2192		0, // use buffer
2193		};
2194
2195	2163	static MACHINE_CONFIG_START( goldnaxeb1, segas1x_bootleg_state )
2196	2164
2197	2165	/* basic machine hardware */
r17593	r17594
2211	2179	MCFG_GFXDECODE(sys16)
2212	2180	MCFG_PALETTE_LENGTH(2048*SHADOW_COLORS_MULTIPLIER)
2213	2181
2214		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x121_sega16sp_intf)
	2182	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2183	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-121)
2215	2184
2216	2185	MCFG_PALETTE_INIT( all_black )
2217	2186	MCFG_VIDEO_START(system16)
r17593	r17594
2233	2202	MCFG_CPU_PROGRAM_MAP(bayrouteb1_map)
2234	2203	MACHINE_CONFIG_END
2235	2204
2236		static const sega16sp_interface s16bbl_x107_sega16sp_intf =
2237		{
2238		0,      // which spriteram
2239		1024,  // colorbase
2240		0x800, // ramsize
2241		107,     // xoffs
2242		segaic16_sprites_16b_draw, // draw function
2243		0, // use buffer
2244		};
2245
2246	2205	static MACHINE_CONFIG_DERIVED( bayrouteb2, goldnaxeb1 )
2247	2206
2248	2207	/* basic machine hardware */
r17593	r17594
2251	2210
2252	2211	MCFG_FRAGMENT_ADD(system16_datsu_sound)
2253	2212
2254		MCFG_DEVICE_REMOVE("segaspr1")
2255		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x107_sega16sp_intf)
	2213	MCFG_DEVICE_MODIFY("sprites")
	2214	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-107)
	2215
2256	2216	MACHINE_CONFIG_END
2257	2217
2258	2218	static MACHINE_CONFIG_DERIVED( tturfbl, system16_7759 )
r17593	r17594
2271	2231	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.80)
2272	2232	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.80)
2273	2233
2274		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x107_sega16sp_intf)
	2234	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2235	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-107)
2275	2236	MACHINE_CONFIG_END
2276	2237
2277		static const sega16sp_interface s16bbl_x112_sega16sp_intf =
2278		{
2279		0,      // which spriteram
2280		1024,  // colorbase
2281		0x800, // ramsize
2282		112,     // xoffs
2283		segaic16_sprites_16b_draw, // draw function
2284		0, // use buffer
2285		};
2286
2287	2238	static MACHINE_CONFIG_DERIVED( dduxbl, system16 )
2288	2239
2289	2240	/* basic machine hardware */
2290	2241	MCFG_CPU_MODIFY("maincpu")
2291	2242	MCFG_CPU_PROGRAM_MAP(dduxbl_map)
2292	2243
2293		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x112_sega16sp_intf)
	2244	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2245	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
2294	2246	MACHINE_CONFIG_END
2295	2247
2296		static const sega16sp_interface s16bbl_x124_sega16sp_intf =
2297		{
2298		0,      // which spriteram
2299		1024,  // colorbase
2300		0x800, // ramsize
2301		124,     // xoffs
2302		segaic16_sprites_16b_draw, // draw function
2303		0, // use buffer
2304		};
2305
2306	2248	static MACHINE_CONFIG_DERIVED( eswatbl, system16_7759 )
2307	2249
2308	2250	/* basic machine hardware */
2309	2251	MCFG_CPU_MODIFY("maincpu")
2310	2252	MCFG_CPU_PROGRAM_MAP(eswatbl_map)
2311	2253
2312		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x124_sega16sp_intf)
	2254	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2255	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-124)
2313	2256	MACHINE_CONFIG_END
2314	2257
2315	2258	static MACHINE_CONFIG_DERIVED( fpointbl, system16 )
r17593	r17594
2321	2264	MCFG_CPU_MODIFY("soundcpu")
2322	2265	MCFG_CPU_PROGRAM_MAP(fpointbl_sound_map)
2323	2266
2324		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x107_sega16sp_intf)
	2267	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2268	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-107)
2325	2269	MACHINE_CONFIG_END
2326	2270
2327	2271	static MACHINE_CONFIG_DERIVED( tetrisbl, system16 )
r17593	r17594
2330	2274	MCFG_CPU_MODIFY("maincpu")
2331	2275	MCFG_CPU_PROGRAM_MAP(tetrisbl_map)
2332	2276
2333		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x112_sega16sp_intf)
	2277	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2278	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
2334	2279	MACHINE_CONFIG_END
2335	2280
2336	2281
r17593	r17594
2340	2285	MCFG_CPU_MODIFY("maincpu")
2341	2286	MCFG_CPU_PROGRAM_MAP(beautyb_map)
2342	2287
2343		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x112_sega16sp_intf)
	2288	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2289	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-112)
2344	2290	MACHINE_CONFIG_END
2345	2291
2346	2292
r17593	r17594
2368	2314
2369	2315	MCFG_VIDEO_START(system18old)
2370	2316
2371		MCFG_SEGA16SP_ADD("segaspr1", s16bbl_x107_sega16sp_intf)
	2317	MCFG_BOOTLEG_SYS16B_SPRITES_ADD("sprites")
	2318	MCFG_BOOTLEG_SYS16B_SPRITES_XORIGIN(189-107)
2372	2319
2373	2320	/* sound hardware */
2374	2321	MCFG_SPEAKER_STANDARD_STEREO("lspeaker", "rspeaker")
r17593	r17594
2448	2395	ROM_LOAD( "10.bin", 0x10000, 0x10000, CRC(7cc40b6c) SHA1(ffad7eef7ab2ff9a2e49a8d71b5785a61fa3c675) )
2449	2396	ROM_LOAD( "11.bin", 0x20000, 0x10000, CRC(0f6c7b1c) SHA1(defc76592c285b3396e89a3cff7a73f3a948117f) )
2450	2397
2451		ROM_REGION16_BE( 0x080000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2398	ROM_REGION16_BE( 0x080000, "sprites", ROMREGION_ERASEFF ) /* sprites */
2452	2399	ROM_LOAD16_BYTE( "5.bin", 0x00001, 0x10000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
2453	2400	ROM_LOAD16_BYTE( "3.bin", 0x00000, 0x10000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
2454	2401	ROM_LOAD16_BYTE( "8.bin", 0x20001, 0x10000, CRC(3c0797c0) SHA1(df18c7987281bd9379026c6cf7f96f6ae49fd7f9) )
r17593	r17594
2473	2420	ROM_LOAD( "opr11855.b10", 0x10000, 0x10000, CRC(b78762b4) SHA1(d594ef846bd7fed8da91a89906b39c1a2867a1fe) )
2474	2421	ROM_LOAD( "opr11856.b11", 0x20000, 0x10000, CRC(ea49f666) SHA1(36ccd32cdcbb7fcc300628bb59c220ec3c324d82) )
2475	2422
2476		ROM_REGION16_BE( 0x80000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2423	ROM_REGION16_BE( 0x80000, "sprites", ROMREGION_ERASEFF ) /* sprites */
2477	2424	ROM_LOAD16_BYTE( "opr11862.b1",  0x00001, 0x10000, CRC(b6e94727) SHA1(0838e034f1f10d9cd1312c8c94b5c57387c0c271) )
2478	2425	ROM_LOAD16_BYTE( "opr11865.b5",  0x00000, 0x10000, CRC(17e8d5d5) SHA1(ac1074b0a705be13c6e3391441e6cfec1d2b3f8a) )
2479	2426	ROM_LOAD16_BYTE( "opr11863.b2",  0x20001, 0x10000, CRC(3e670098) SHA1(2cfc83f4294be30cd868738886ac546bd8489962) )
r17593	r17594
2499	2446	ROM_LOAD( "pas4p.12", 0x10000, 0x10000, CRC(bebb9211) SHA1(4f56048f6f70b63f74a4c0d64456213d36ce5b26) )
2500	2447	ROM_LOAD( "pas4p.13", 0x20000, 0x10000, CRC(e37506c3) SHA1(e6fbf15d58f321a3d052fefbe5a1901e4a1734ae) )
2501	2448
2502		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) /* sprites */
	2449	ROM_REGION16_BE( 0x60000, "sprites", 0 ) /* sprites */
2503	2450	ROM_LOAD16_BYTE( "opr11862.b1",  0x00001, 0x10000, CRC(b6e94727) SHA1(0838e034f1f10d9cd1312c8c94b5c57387c0c271) )
2504	2451	ROM_LOAD16_BYTE( "opr11865.b5",  0x00000, 0x10000, CRC(17e8d5d5) SHA1(ac1074b0a705be13c6e3391441e6cfec1d2b3f8a) )
2505	2452	ROM_LOAD16_BYTE( "opr11863.b2",  0x20001, 0x10000, CRC(3e670098) SHA1(2cfc83f4294be30cd868738886ac546bd8489962) )
r17593	r17594
2524	2471	ROM_LOAD( "wb3_15", 0x10000, 0x10000, CRC(96ff9d52) SHA1(791a9da4860e0d42fba98f80a3c6725ad8c73e33) )
2525	2472	ROM_LOAD( "wb3_16", 0x20000, 0x10000, CRC(afaf0d31) SHA1(d4309329a0a543250788146b63b27ff058c02fc3) )
2526	2473
2527		ROM_REGION16_BE( 0x100000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2474	ROM_REGION16_BE( 0x100000, "sprites", ROMREGION_ERASEFF ) /* sprites */
2528	2475	ROM_LOAD16_BYTE( "epr12090.b1", 0x00001, 0x010000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
2529	2476	ROM_LOAD16_BYTE( "epr12094.b5", 0x00000, 0x010000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
2530	2477	ROM_LOAD16_BYTE( "epr12091.b2", 0x20001, 0x010000, CRC(8409a243) SHA1(bcbb9510a6499d8147543d6befa5a49f4ac055d9) )
r17593	r17594
2570	2517	ROM_LOAD( "bs14.bin", 0x10000, 0x10000, CRC(6bc4d0a8) SHA1(90b9a61c7a140291d72554857ce26d54ebf03fc2) )
2571	2518	ROM_LOAD( "bs12.bin", 0x20000, 0x10000, CRC(c1f967a6) SHA1(8eb6bbd9e17dc531830bc798b8485c8ea999e56e) )
2572	2519
2573		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) /* sprites */
	2520	ROM_REGION16_BE( 0x80000, "sprites", 0 ) /* sprites */
2574	2521	ROM_LOAD16_BYTE( "br_obj0o.1b", 0x00001, 0x10000, CRC(098a5e82) SHA1(c5922f418773bc3629071e584457839d67a370e9) )
2575	2522	ROM_LOAD16_BYTE( "br_obj0e.5b", 0x00000, 0x10000, CRC(85238af9) SHA1(39989a8d9b60c6d55272b5e2c213341a563dd993) )
2576	2523	ROM_LOAD16_BYTE( "br_obj1o.2b", 0x20001, 0x10000, CRC(cc641da1) SHA1(28f8a6502702cb9e2cc7f3e98f6c5d201f462fa3) )
r17593	r17594
2606	2553	ROM_LOAD( "bs12.bin", 0x20000, 0x10000, CRC(c1f967a6) SHA1(8eb6bbd9e17dc531830bc798b8485c8ea999e56e) )
2607	2554
2608	2555	#if 0 // these look bad
2609		ROM_REGION16_BE( 0x080000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2556	ROM_REGION16_BE( 0x080000, "sprites", ROMREGION_ERASEFF ) /* sprites */
2610	2557	ROM_LOAD16_BYTE( "br_11",       0x00001, 0x10000, CRC(65232905) SHA1(cb195a0ce8bff9d1d3e31678060b3aaccfefcd2d) )
2611	2558	ROM_LOAD16_BYTE( "br_obj0e.5b", 0x00000, 0x10000, CRC(85238af9) SHA1(39989a8d9b60c6d55272b5e2c213341a563dd993) )
2612	2559	ROM_LOAD16_BYTE( "br_obj1o.2b", 0x20001, 0x10000, CRC(cc641da1) SHA1(28f8a6502702cb9e2cc7f3e98f6c5d201f462fa3) )
r17593	r17594
2618	2565	#endif
2619	2566
2620	2567	// use the roms from the first bootleg set
2621		ROM_REGION16_BE( 0x080000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2568	ROM_REGION16_BE( 0x080000, "sprites", ROMREGION_ERASEFF ) /* sprites */
2622	2569	ROM_LOAD16_BYTE( "br_obj0o.1b", 0x00001, 0x10000, CRC(098a5e82) SHA1(c5922f418773bc3629071e584457839d67a370e9) )
2623	2570	ROM_LOAD16_BYTE( "br_obj0e.5b", 0x00000, 0x10000, CRC(85238af9) SHA1(39989a8d9b60c6d55272b5e2c213341a563dd993) )
2624	2571	ROM_LOAD16_BYTE( "br_obj1o.2b", 0x20001, 0x10000, CRC(cc641da1) SHA1(28f8a6502702cb9e2cc7f3e98f6c5d201f462fa3) )
r17593	r17594
2718	2665	ROM_LOAD( "28.12",  0x40000, 0x10000, CRC(22f0667e) SHA1(2d11b2ce105a3db9c914942cace85aff17deded9) )
2719	2666	ROM_LOAD( "27.11", 0x50000, 0x10000, CRC(afb1a7e4) SHA1(726fded9db72a881128b43f449d2baf450131f63) )
2720	2667
2721		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) /* sprites */
	2668	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) /* sprites */
2722	2669	ROM_LOAD16_BYTE( "33.17",      0x000001, 0x10000, CRC(28ba70c8) SHA1(a6f33e1404928b6d1006943494646d6cfbd60a4b) )
2723	2670	ROM_LOAD16_BYTE( "34.18",      0x020001, 0x10000, CRC(2ed96a26) SHA1(edcf915243e6f92d31cdfc53965438f6b6bff51d) )
2724	2671	ROM_LOAD16_BYTE( "37.bin",      0x100001, 0x10000, CRC(84dccc5b) SHA1(10263d98d663f1170c3203066f391075a1d64ff5) )
r17593	r17594
2804	2751	ROM_LOAD( "ic2.37",  0x40000, 0x10000, CRC(22f0667e) SHA1(2d11b2ce105a3db9c914942cace85aff17deded9) )
2805	2752	ROM_LOAD( "ic16.40", 0x50000, 0x10000, CRC(afb1a7e4) SHA1(726fded9db72a881128b43f449d2baf450131f63) )
2806	2753
2807		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) /* sprites */
	2754	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) /* sprites */
2808	2755	ROM_LOAD16_BYTE( "ic73.34",       0x000001, 0x10000, CRC(28ba70c8) SHA1(a6f33e1404928b6d1006943494646d6cfbd60a4b) ) // mpr12378.b1  [1/4]      IDENTICAL
2809	2756	ROM_LOAD16_BYTE( "ic74.33",       0x020001, 0x10000, CRC(2ed96a26) SHA1(edcf915243e6f92d31cdfc53965438f6b6bff51d) ) // mpr12378.b1  [2/4]      IDENTICAL
2810	2757	ROM_LOAD16_BYTE( "ic79.28",       0x100001, 0x10000, CRC(84dccc5b) SHA1(10263d98d663f1170c3203066f391075a1d64ff5) ) // mpr12378.b1  [3/4]      IDENTICAL
r17593	r17594
2847	2794	ROM_LOAD( "tt16cf44.rom", 0x10000, 0x10000, CRC(4c467735) SHA1(8338b6605cbe2e076da0b3e3a47630409a79f002) )
2848	2795	ROM_LOAD( "tt17d59e.rom", 0x20000, 0x10000, CRC(60c0f2fe) SHA1(3fea4ed757d47628f59ff940e40cb86b3b5b443b) )
2849	2796
2850		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) /* sprites */
	2797	ROM_REGION16_BE( 0x80000, "sprites", 0 ) /* sprites */
2851	2798	ROM_LOAD16_BYTE( "12279.1b", 0x00001, 0x10000, CRC(7a169fb1) SHA1(1ec6da0d2cfcf727e61f61c847fd8b975b64f944) )
2852	2799	ROM_LOAD16_BYTE( "12283.5b", 0x00000, 0x10000, CRC(ae0fa085) SHA1(ae9af92d4dd0c8a0f064d24e647522b588fbd7f7) )
2853	2800	ROM_LOAD16_BYTE( "12278.2b", 0x20001, 0x10000, CRC(961d06b7) SHA1(b1a9dea63785bfa2c0e7b931387b91dfcd27d79b) )
r17593	r17594
2875	2822	ROM_LOAD( "dduxb15.bin", 0x10000, 0x10000, CRC(ce0d2b30) SHA1(e60521c46f1650c9bdc76f2ceb91a6d61aaa0a09) )
2876	2823	ROM_LOAD( "dduxb16.bin", 0x20000, 0x10000, CRC(6de95434) SHA1(7bed2a0261cf6c2fbb3756633f05f0bb2173977c) )
2877	2824
2878		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) //* sprites */
	2825	ROM_REGION16_BE( 0x100000, "sprites", 0 ) //* sprites */
2879	2826	ROM_LOAD16_BYTE( "dduxb06.bin", 0x00000, 0x010000, CRC(b0079e99) SHA1(9bb4d3fa804a3d05a6e06b45a1280d7064e96ac6) )
2880	2827	ROM_LOAD16_BYTE( "dduxb10.bin", 0x00001, 0x010000, CRC(0be3aee5) SHA1(48fc779b7398abbb82cd0d0d28705ece75b3c4e3) )
2881	2828	ROM_LOAD16_BYTE( "dduxb07.bin", 0x20000, 0x010000, CRC(0217369c) SHA1(b6ec2fa1279a27a602d79e1073c54193745ea816) )
r17593	r17594
2903	2850	ROM_LOAD( "mpr12625.b12", 0x40000, 0x40000, CRC(3b8c757e) SHA1(0b66e8446d059a12e47e2a6fe8f0a333245bb95c) ) // ic20
2904	2851	ROM_LOAD( "mpr12626.b13", 0x80000, 0x40000, CRC(3efca25c) SHA1(0d866bf53a16b52719f73081e933f4db27d72ece) ) // ic21
2905	2852
2906		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) /* sprites */
	2853	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) /* sprites */
2907	2854	ROM_LOAD16_BYTE( "ic9",  0x000001, 0x20000, CRC(0d1530bf) SHA1(bb8626cd98761c1c20cee117d00315c85621ba6a) )
2908	2855	ROM_CONTINUE(            0x100001, 0x20000 )
2909	2856	ROM_LOAD16_BYTE( "ic12", 0x000000, 0x20000, CRC(18ff0799) SHA1(5417223378aef16ee2b4f438d1f8f11a23fe7265) )
r17593	r17594
2932	2879	ROM_LOAD( "flpoint.005", 0x10000, 0x10000, CRC(82c0b8b0) SHA1(e1e2e721cb8ad53df33065582dc90edeba9c3cab) )
2933	2880	ROM_LOAD( "flpoint.004", 0x20000, 0x10000, CRC(522426ae) SHA1(90fd0a19b30a8a61dc4cfa66a64115596333dcc6) )
2934	2881
2935		ROM_REGION16_BE( 0x20000, "gfx2", 0 ) /* sprites */
	2882	ROM_REGION16_BE( 0x20000, "sprites", 0 ) /* sprites */
2936	2883	ROM_LOAD16_BYTE( "12596.bin", 0x00001, 0x010000, CRC(4a4041f3) SHA1(4c52b30223d8aa80ccdbb196098cb17e64ad6583) )
2937	2884	ROM_LOAD16_BYTE( "12597.bin", 0x00000, 0x010000, CRC(6961e676) SHA1(7639d2da086b57a9a8d6100fdacf40d97d7c4772) )
2938	2885
r17593	r17594
2950	2897	ROM_LOAD( "flpoint.005", 0x10000, 0x10000, CRC(82c0b8b0) SHA1(e1e2e721cb8ad53df33065582dc90edeba9c3cab) )
2951	2898	ROM_LOAD( "flpoint.004", 0x20000, 0x10000, CRC(522426ae) SHA1(90fd0a19b30a8a61dc4cfa66a64115596333dcc6) )
2952	2899
2953		ROM_REGION16_BE( 0x20000, "gfx2", 0 ) /* sprites */
	2900	ROM_REGION16_BE( 0x20000, "sprites", 0 ) /* sprites */
2954	2901	ROM_LOAD16_BYTE( "12596.bin", 0x00001, 0x010000, CRC(4a4041f3) SHA1(4c52b30223d8aa80ccdbb196098cb17e64ad6583) )
2955	2902	ROM_LOAD16_BYTE( "12597.bin", 0x00000, 0x010000, CRC(6961e676) SHA1(7639d2da086b57a9a8d6100fdacf40d97d7c4772) )
2956	2903
r17593	r17594
2978	2925	ROM_LOAD( "epr12166.b10", 0x10000, 0x10000, CRC(9abd183b) SHA1(621b017cb34973f9227be383e26b5cd41aea9422) )
2979	2926	ROM_LOAD( "epr12167.b11", 0x20000, 0x10000, CRC(2495fd4e) SHA1(2db94ead9223a67238a97e724668076fc43e5534) )
2980	2927
2981		ROM_REGION16_BE( 0x020000, "gfx2", 0 ) /* sprites */
	2928	ROM_REGION16_BE( 0x020000, "sprites", 0 ) /* sprites */
2982	2929	ROM_LOAD16_BYTE( "obj0-o.rom", 0x00001, 0x10000, CRC(2fb38880) SHA1(0e1b601bbda78d1887951c1f7e752531c281bc83) )
2983	2930	ROM_LOAD16_BYTE( "obj0-e.rom", 0x00000, 0x10000, CRC(d6a02cba) SHA1(d80000f92e754e89c6ca7b7273feab448fc9a061) )
2984	2931
r17593	r17594
3009	2956	ROM_LOAD( "b53.bin", 0x10000, 0x10000, CRC(aca8e330) SHA1(912e636e3c1e238682ea29620e8e2c6089c77209) )
3010	2957	ROM_LOAD( "b63.bin", 0x00000, 0x10000, CRC(f2af2fd5) SHA1(0a95ebb5eae7cdc6535533d73d06419c23d01ac3) )
3011	2958
3012		ROM_REGION( 0x020000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2959	ROM_REGION( 0x020000, "sprites", ROMREGION_ERASEFF ) /* sprites */
3013	2960	/* no sprites on this */
3014	2961
3015	2962	ROM_REGION( 0x40000, "soundcpu", 0 ) /* sound CPU */
r17593	r17594
3036	2983	ROM_LOAD( "iqpipe.5", 0x10000, 0x10000, CRC(dfaedd39) SHA1(498f1c34fecd8de497fdce41bb683d00047a868a) )
3037	2984	ROM_LOAD( "iqpipe.6", 0x00000, 0x10000, CRC(8e554f8d) SHA1(4b3b0e47c36f37947422f1c31063f11975108cd0) )
3038	2985
3039		ROM_REGION( 0x020000, "gfx2", ROMREGION_ERASEFF ) /* sprites */
	2986	ROM_REGION( 0x020000, "sprites", ROMREGION_ERASEFF ) /* sprites */
3040	2987	/* no sprites on this */
3041	2988
3042	2989	ROM_REGION( 0x40000, "soundcpu", 0 ) /* sound CPU */
r17593	r17594
3068	3015	ROM_LOAD( "epr13074.bin", 0x40000, 0x40000, CRC(787afab8) SHA1(a119042bb2dad54e9733bfba4eaab0ac5fc0f9e7) )
3069	3016	ROM_LOAD( "epr13075.bin", 0x80000, 0x40000, CRC(4e01b477) SHA1(4178ce4a87ea427c3b0195e64acef6cddfb3485f) )
3070	3017
3071		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) /* sprites */
	3018	ROM_REGION16_BE( 0x200000, "sprites", 0 ) /* sprites */
3072	3019	ROM_LOAD16_BYTE( "mpr13082.bin", 0x000001, 0x40000, CRC(a782b704) SHA1(ba15bdfbc267b8d86f03e5310ce60846ff846de3) )
3073	3020	ROM_LOAD16_BYTE( "astorm.a11",   0x000000, 0x40000, CRC(7829c4f3) SHA1(3adb7aa7f70163d3848c98316e18b9783c41d663) )
3074	3021	ROM_LOAD16_BYTE( "mpr13081.bin", 0x080001, 0x40000, CRC(eb510228) SHA1(4cd387b160ec7050e1300ebe708853742169e643) )
r17593	r17594
3130	3077	ROM_LOAD( "36.03",  0x80000, 0x20000, CRC(c0f9628d) SHA1(aeacf5e409adfa0b9c28c90d4e89eb1f56cd5f4d) ) // epr13075.bin [1/2]      IDENTICAL
3131	3078	ROM_LOAD( "37.031", 0xa0000, 0x20000, CRC(95af904e) SHA1(6574fa874c355c368109b417aab7d0b05c9d215d) ) // epr13075.bin [2/2]      IDENTICAL
3132	3079
3133		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) /* sprites */
	3080	ROM_REGION16_BE( 0x200000, "sprites", 0 ) /* sprites */
3134	3081	ROM_LOAD16_BYTE( "17.042", 0x000001, 0x20000, CRC(db08beb5) SHA1(c154d22c69b77637d6a9d0f2bffcfb47e6901ec8) ) // mpr13082.bin [1/2]      IDENTICAL
3135	3082	ROM_LOAD16_BYTE( "16.043", 0x040001, 0x20000, CRC(41f78977) SHA1(9cf9fcf96722d148c4b2cf7aa33425b6efcd0379) ) // mpr13082.bin [2/2]      IDENTICAL
3136	3083	ROM_LOAD16_BYTE( "29.012", 0x000000, 0x20000, CRC(22acf675) SHA1(80fd0d96017bf36d964a79f7e13e73fee7ed370a) ) // mpr13089.bin [1/2]      99.941254%
r17593	r17594
3185	3132	ROM_LOAD( "mpr13217.b2", 0x40000, 0x40000, CRC(7d1ac3ec) SHA1(8495357304f1df135bba77ef3b96e79a883b8ff0) )
3186	3133	ROM_LOAD( "mpr13218.b3", 0x80000, 0x40000, CRC(56d3393c) SHA1(50a2d065060692c9ecaa56046a781cb21d93e554) )
3187	3134
3188		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) /* sprites */
	3135	ROM_REGION16_BE( 0x200000, "sprites", 0 ) /* sprites */
3189	3136	ROM_LOAD16_BYTE( "mpr13224.b11", 0x000001, 0x40000, CRC(c59f107b) SHA1(10fa60fca6e34eda277c483bb1c0e81bb88c8a47) )
3190	3137	ROM_LOAD16_BYTE( "mpr13231.a11", 0x000000, 0x40000, CRC(a5e96346) SHA1(a854f4dd5dc16975373255110fdb8ab3d121b1af) )
3191	3138	ROM_LOAD16_BYTE( "mpr13223.b10", 0x080001, 0x40000, CRC(364f60ff) SHA1(9ac887ec0b2e32b504b7c6a5f3bb1ce3fe41a15a) )
r17593	r17594
3223	3170	ROM_LOAD( "ic2",  0x80000, 0x20000, CRC(60095070) SHA1(913c2ee51fb6f838f3c6cbd27032bdf754fbadf1) )
3224	3171	ROM_LOAD( "ic16", 0xa0000, 0x20000, CRC(0f0d5dd3) SHA1(76812e2f831256a8b6598257dd84a7f07443642e) )
3225	3172
3226		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) /* sprites */
	3173	ROM_REGION16_BE( 0x200000, "sprites", 0 ) /* sprites */
3227	3174
3228	3175	// 12719
3229	3176	ROM_LOAD16_BYTE( "ic73", 0x000001, 0x10000, CRC(59e77c96) SHA1(08da058529ac83352a4528d3792a21edda348f7a) )

trunk/src/mame/drivers/segas16b.c

r17593	r17594
933	933	break;
934	934
935	935	case 6:   // 4k of paletteram
936		mapper.map_as_ram(0x00000, 0x01000, 0xfff000, "paletteram", write16_delegate(FUNC(segas16b_state::legacy_wrapper<segaic16_paletteram_w>), this));
	936	mapper.map_as_ram(0x00000, 0x01000, 0xfff000, "paletteram", write16_delegate(FUNC(segas16b_state::paletteram_w), this));
937	937	break;
938	938
939	939	case 5:   // 64k of tileram + 4k of textram
r17593	r17594
942	942	break;
943	943
944	944	case 4:   // 2k of spriteram
945		mapper.map_as_ram(0x00000, 0x00800, 0xfff800, "spriteram", write16_delegate());
	945	mapper.map_as_ram(0x00000, 0x00800, 0xfff800, "sprites", write16_delegate());
946	946	break;
947	947
948	948	case 3:   // 16k or 256k of work RAM
r17593	r17594
1050	1050	// compare registers
1051	1051	return m_cmptimer_1->read(space, offset, mem_mask);
1052	1052	}
1053		return segaic16_open_bus_r(&space, 0, mem_mask);
	1053	return open_bus_r(space, 0, mem_mask);
1054	1054	}
1055	1055
1056	1056
r17593	r17594
1125	1125	return ioport((offset & 1) ? "DSW1" : "DSW2")->read();
1126	1126	}
1127	1127	logerror("%06X:standard_io_r - unknown read access to address %04X\n", cpu_get_pc(&space.device()), offset * 2);
1128		return segaic16_open_bus_r(&space, 0, mem_mask);
	1128	return open_bus_r(space, 0, mem_mask);
1129	1129	}
1130	1130
1131	1131
r17593	r17594
1150	1150	//  D0 : Output to coin counter 1
1151	1151	//
1152	1152	segaic16_tilemap_set_flip(machine(), 0, data & 0x40);
1153		segaic16_sprites_set_flip(machine(), 0, data & 0x40);
	1153	m_sprites->set_flip(data & 0x40);
1154	1154	if (!m_disable_screen_blanking)
1155	1155	segaic16_set_display_enable(machine(), data & 0x20);
1156	1156	set_led_status(machine(), 1, data & 0x08);
r17593	r17594
1321	1321	static const UINT8 alternate_banklist[] = { 0,255,255,255, 255,255,255,3, 255,255,255,2, 255,1,0,255 };
1322	1322	const UINT8 *banklist = (m_romboard == ROM_BOARD_171_5358 || m_romboard == ROM_BOARD_171_5358_SMALL) ? alternate_banklist : default_banklist;
1323	1323	for (int banknum = 0; banknum < 16; banknum++)
1324		segaic16_sprites_set_bank(machine(), 0, banknum, banklist[banknum]);
	1324	m_sprites->set_bank(banknum, banklist[banknum]);
1325	1325	}
1326	1326
1327	1327
r17593	r17594
1730	1730
1731	1731	// these get overwritten by the memory mapper above, but we put them here
1732	1732	// so they are properly allocated and tracked for saving
1733		AM_RANGE(0x100000, 0x1007ff) AM_RAM AM_SHARE("spriteram")
	1733	AM_RANGE(0x100000, 0x1007ff) AM_RAM AM_SHARE("sprites")
1734	1734	AM_RANGE(0x200000, 0x200fff) AM_RAM AM_SHARE("paletteram")
1735	1735	AM_RANGE(0x300000, 0x30ffff) AM_RAM AM_SHARE("tileram")
1736	1736	AM_RANGE(0x400000, 0x400fff) AM_RAM AM_SHARE("textram")
r17593	r17594
1744	1744
1745	1745	// these get overwritten by the memory mapper above, but we put them here
1746	1746	// so they are properly allocated and tracked for saving
1747		AM_RANGE(0x100000, 0x1007ff) AM_RAM AM_SHARE("spriteram")
	1747	AM_RANGE(0x100000, 0x1007ff) AM_RAM AM_SHARE("sprites")
1748	1748	AM_RANGE(0x200000, 0x200fff) AM_RAM AM_SHARE("paletteram")
1749	1749	AM_RANGE(0x300000, 0x30ffff) AM_RAM AM_SHARE("tileram")
1750	1750	AM_RANGE(0x400000, 0x400fff) AM_RAM AM_SHARE("textram")
r17593	r17594
3304	3304	MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK_25MHz/4, 400, 0, 320, 262, 0, 224)
3305	3305	MCFG_SCREEN_UPDATE_DRIVER(segas16b_state, screen_update)
3306	3306
3307		MCFG_SEGA16SP_ADD_16B("segaspr1")
	3307	MCFG_SEGA_SYS16B_SPRITES_ADD("sprites")
3308	3308
3309	3309	// sound hardware
3310	3310	MCFG_SPEAKER_STANDARD_MONO("mono")
r17593	r17594
3420	3420	ROM_LOAD( "epr-11494.b10", 0x10000, 0x10000, CRC(b67971ab) SHA1(95cb6927baf425bcc290832ea9741b19852c7a1b) )
3421	3421	ROM_LOAD( "epr-11495.b11", 0x20000, 0x10000, CRC(b687ab61) SHA1(b08130a9d777c918972895136b1bf520d7117114) )
3422	3422
3423		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	3423	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
3424	3424	ROM_LOAD16_BYTE( "epr-11501.b1", 0x00001, 0x10000, CRC(09179ead) SHA1(3e6bf04e1e9ea867d087a47ff04ad0a064a8e299) )
3425	3425	ROM_LOAD16_BYTE( "epr-11505.b5", 0x00000, 0x10000, CRC(b67f1ecf) SHA1(3a26cdf91e5a1a11c1a8857e713a9e00cc1bfce0) )
3426	3426	ROM_LOAD16_BYTE( "epr-11502.b2", 0x20001, 0x10000, CRC(a3ee36b8) SHA1(bc946ad67b8ad09d947465ab73160885a4a57be5) )
r17593	r17594
3460	3460	ROM_LOAD( "epr-10703.b10", 0x10000, 0x10000, CRC(6b6dd9f5) SHA1(964409c6630caa13caf7d644d0c6fb071860b61b) )
3461	3461	ROM_LOAD( "epr-10704.b11", 0x20000, 0x10000, CRC(911e7ebc) SHA1(f03d3d3a09d19f7b705f9cb29f73140a3073463f) )
3462	3462
3463		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	3463	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
3464	3464	ROM_LOAD16_BYTE( "epr-10709.b1", 0x00001, 0x10000, CRC(addf0a90) SHA1(a92c9531f1817763773471ce63f566b9e88360a0) )
3465	3465	ROM_LOAD16_BYTE( "epr-10713.b5", 0x00000, 0x10000, CRC(ececde3a) SHA1(9c12d4665179bf433c42f5ddc8a043ad592aa90e) )
3466	3466	ROM_LOAD16_BYTE( "epr-10710.b2", 0x20001, 0x10000, CRC(992369eb) SHA1(c6796acf6807e9ba4c3d241903653f91adf4764e) )
r17593	r17594
3499	3499	ROM_LOAD( "epr-10703.b10", 0x10000, 0x10000, CRC(6b6dd9f5) SHA1(964409c6630caa13caf7d644d0c6fb071860b61b) )
3500	3500	ROM_LOAD( "epr-10704.b11", 0x20000, 0x10000, CRC(911e7ebc) SHA1(f03d3d3a09d19f7b705f9cb29f73140a3073463f) )
3501	3501
3502		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	3502	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
3503	3503	ROM_LOAD16_BYTE( "epr-10709.b1", 0x00001, 0x10000, CRC(addf0a90) SHA1(a92c9531f1817763773471ce63f566b9e88360a0) )
3504	3504	ROM_LOAD16_BYTE( "epr-10713.b5", 0x00000, 0x10000, CRC(ececde3a) SHA1(9c12d4665179bf433c42f5ddc8a043ad592aa90e) )
3505	3505	ROM_LOAD16_BYTE( "epr-10710.b2", 0x20001, 0x10000, CRC(992369eb) SHA1(c6796acf6807e9ba4c3d241903653f91adf4764e) )
r17593	r17594
3542	3542	ROM_LOAD( "epr-10703.b10", 0x10000, 0x10000, CRC(6b6dd9f5) SHA1(964409c6630caa13caf7d644d0c6fb071860b61b) )
3543	3543	ROM_LOAD( "epr-10704.b11", 0x20000, 0x10000, CRC(911e7ebc) SHA1(f03d3d3a09d19f7b705f9cb29f73140a3073463f) )
3544	3544
3545		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	3545	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
3546	3546	ROM_LOAD16_BYTE( "epr-10709.b1", 0x00001, 0x10000, CRC(addf0a90) SHA1(a92c9531f1817763773471ce63f566b9e88360a0) )
3547	3547	ROM_LOAD16_BYTE( "epr-10713.b5", 0x00000, 0x10000, CRC(ececde3a) SHA1(9c12d4665179bf433c42f5ddc8a043ad592aa90e) )
3548	3548	ROM_LOAD16_BYTE( "epr-10710.b2", 0x20001, 0x10000, CRC(992369eb) SHA1(c6796acf6807e9ba4c3d241903653f91adf4764e) )
r17593	r17594
3581	3581	ROM_LOAD( "opr-11675.a15", 0x20000, 0x20000, CRC(2ef2f144) SHA1(38d22d609db2d9b6067b5d12f6499436de4605cb) )
3582	3582	ROM_LOAD( "opr-11676.a16", 0x40000, 0x20000, CRC(0c04acac) SHA1(87fe2a0dd9913f9550e9b4cbc7e7465b61640e07) )
3583	3583
3584		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	3584	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
3585	3585	ROM_LOAD16_BYTE( "epr-11677.b1", 0x00001, 0x20000, CRC(a01425cd) SHA1(72be5ec29e476601f9bf6aaedef9b73cedeb42f0) )
3586	3586	ROM_LOAD16_BYTE( "epr-11681.b5", 0x00000, 0x20000, CRC(d9e03363) SHA1(995a7c6a8f0c61468b57a3bb407461a2a3ae8adc) )
3587	3587	ROM_LOAD16_BYTE( "epr-11678.b2", 0x40001, 0x20000, CRC(17a9fc53) SHA1(85a9a605742ae5aab86db37189b9ee4d54c70e56) )
r17593	r17594
3618	3618	ROM_LOAD( "epr-11724.a16", 0x80000, 0x10000,  CRC(6f2ed50a) SHA1(55d0c4299e7240b0ef5316b48db7a158145c76ab) ) // plane 3
3619	3619	ROM_LOAD( "epr-11738.b16", 0xa0000, 0x10000,  CRC(de3d6d02) SHA1(428811f21c68761022521a17fc4716f6e7214b20) )
3620	3620
3621		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	3621	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
3622	3622	ROM_LOAD16_BYTE( "epr-11725.b1",  0x000001, 0x010000, CRC(f8b3684e) SHA1(3de2685cae5fb3c954b8440fafce313072747469) )
3623	3623	ROM_LOAD16_BYTE( "epr-11729.b5",  0x000000, 0x010000, CRC(ae3c2793) SHA1(c4f46861ea63ffa3c038a1ef931479b94e5382df) )
3624	3624	ROM_LOAD16_BYTE( "epr-11726.b2",  0x040001, 0x010000, CRC(3cce5419) SHA1(fccdbd6d05f5927272e7d6e5f997418d4fa2baf5) )
r17593	r17594
3661	3661	ROM_LOAD( "epr-11724.a16", 0x80000, 0x10000,  CRC(6f2ed50a) SHA1(55d0c4299e7240b0ef5316b48db7a158145c76ab) ) // plane 3
3662	3662	ROM_LOAD( "epr-11738.b16", 0xa0000, 0x10000,  CRC(de3d6d02) SHA1(428811f21c68761022521a17fc4716f6e7214b20) )
3663	3663
3664		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	3664	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
3665	3665	ROM_LOAD16_BYTE( "epr-11725.b1",  0x000001, 0x010000, CRC(f8b3684e) SHA1(3de2685cae5fb3c954b8440fafce313072747469) )
3666	3666	ROM_LOAD16_BYTE( "epr-11729.b5",  0x000000, 0x010000, CRC(ae3c2793) SHA1(c4f46861ea63ffa3c038a1ef931479b94e5382df) )
3667	3667	ROM_LOAD16_BYTE( "epr-11726.b2",  0x040001, 0x010000, CRC(3cce5419) SHA1(fccdbd6d05f5927272e7d6e5f997418d4fa2baf5) )
r17593	r17594
3710	3710	ROM_LOAD( "epr-11724.a16", 0x80000, 0x10000,  CRC(6f2ed50a) SHA1(55d0c4299e7240b0ef5316b48db7a158145c76ab) ) // plane 3
3711	3711	ROM_LOAD( "epr-11738.b16", 0xa0000, 0x10000,  CRC(de3d6d02) SHA1(428811f21c68761022521a17fc4716f6e7214b20) )
3712	3712
3713		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	3713	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
3714	3714	ROM_LOAD16_BYTE( "epr-11725.b1",  0x000001, 0x010000, CRC(f8b3684e) SHA1(3de2685cae5fb3c954b8440fafce313072747469) )
3715	3715	ROM_LOAD16_BYTE( "epr-11729.b5",  0x000000, 0x010000, CRC(ae3c2793) SHA1(c4f46861ea63ffa3c038a1ef931479b94e5382df) )
3716	3716	ROM_LOAD16_BYTE( "epr-11726.b2",  0x040001, 0x010000, CRC(3cce5419) SHA1(fccdbd6d05f5927272e7d6e5f997418d4fa2baf5) )
r17593	r17594
3751	3751	ROM_LOAD( "epr-11724.a16", 0x80000, 0x10000,  CRC(6f2ed50a) SHA1(55d0c4299e7240b0ef5316b48db7a158145c76ab) ) // plane 3
3752	3752	ROM_LOAD( "epr-11738.b16", 0xa0000, 0x10000,  CRC(de3d6d02) SHA1(428811f21c68761022521a17fc4716f6e7214b20) )
3753	3753
3754		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	3754	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
3755	3755	ROM_LOAD16_BYTE( "epr-11725.b1",  0x000001, 0x010000, CRC(f8b3684e) SHA1(3de2685cae5fb3c954b8440fafce313072747469) )
3756	3756	ROM_LOAD16_BYTE( "epr-11729.b5",  0x000000, 0x010000, CRC(ae3c2793) SHA1(c4f46861ea63ffa3c038a1ef931479b94e5382df) )
3757	3757	ROM_LOAD16_BYTE( "epr-11726.b2",  0x040001, 0x010000, CRC(3cce5419) SHA1(fccdbd6d05f5927272e7d6e5f997418d4fa2baf5) )
r17593	r17594
3797	3797	ROM_LOAD( "epr-11724.a16", 0x80000, 0x10000,  CRC(6f2ed50a) SHA1(55d0c4299e7240b0ef5316b48db7a158145c76ab) ) // plane 3
3798	3798	ROM_LOAD( "epr-11738.b16", 0xa0000, 0x10000,  CRC(de3d6d02) SHA1(428811f21c68761022521a17fc4716f6e7214b20) )
3799	3799
3800		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	3800	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
3801	3801	ROM_LOAD16_BYTE( "epr-11725.b1",  0x000001, 0x010000, CRC(f8b3684e) SHA1(3de2685cae5fb3c954b8440fafce313072747469) )
3802	3802	ROM_LOAD16_BYTE( "epr-11729.b5",  0x000000, 0x010000, CRC(ae3c2793) SHA1(c4f46861ea63ffa3c038a1ef931479b94e5382df) )
3803	3803	ROM_LOAD16_BYTE( "epr-11726.b2",  0x040001, 0x010000, CRC(3cce5419) SHA1(fccdbd6d05f5927272e7d6e5f997418d4fa2baf5) )
r17593	r17594
3835	3835	ROM_LOAD( "opr-11675.a15", 0x20000, 0x20000, CRC(2ef2f144) SHA1(38d22d609db2d9b6067b5d12f6499436de4605cb) )
3836	3836	ROM_LOAD( "opr-11676.a16", 0x40000, 0x20000, CRC(0c04acac) SHA1(87fe2a0dd9913f9550e9b4cbc7e7465b61640e07) )
3837	3837
3838		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	3838	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
3839	3839	ROM_LOAD16_BYTE( "epr-11677.b1", 0x00001, 0x20000, CRC(a01425cd) SHA1(72be5ec29e476601f9bf6aaedef9b73cedeb42f0) )
3840	3840	ROM_LOAD16_BYTE( "epr-11681.b5", 0x00000, 0x20000, CRC(d9e03363) SHA1(995a7c6a8f0c61468b57a3bb407461a2a3ae8adc) )
3841	3841	ROM_LOAD16_BYTE( "epr-11678.b2", 0x40001, 0x20000, CRC(17a9fc53) SHA1(85a9a605742ae5aab86db37189b9ee4d54c70e56) )
r17593	r17594
3872	3872	ROM_LOAD( "opr-11675.a15", 0x20000, 0x20000, CRC(2ef2f144) SHA1(38d22d609db2d9b6067b5d12f6499436de4605cb) )
3873	3873	ROM_LOAD( "opr-11676.a16", 0x40000, 0x20000, CRC(0c04acac) SHA1(87fe2a0dd9913f9550e9b4cbc7e7465b61640e07) )
3874	3874
3875		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	3875	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
3876	3876	ROM_LOAD16_BYTE( "epr-11677.b1", 0x00001, 0x20000, CRC(a01425cd) SHA1(72be5ec29e476601f9bf6aaedef9b73cedeb42f0) )
3877	3877	ROM_LOAD16_BYTE( "epr-11681.b5", 0x00000, 0x20000, CRC(d9e03363) SHA1(995a7c6a8f0c61468b57a3bb407461a2a3ae8adc) )
3878	3878	ROM_LOAD16_BYTE( "epr-11678.b2", 0x40001, 0x20000, CRC(17a9fc53) SHA1(85a9a605742ae5aab86db37189b9ee4d54c70e56) )
r17593	r17594
3956	3956	ROM_LOAD( "mpr-13452.a16", 0x80000, 0x20000, CRC(047bde5e) SHA1(e759baedcbb637a6c14af461b8a492554cadc9e4) ) // plane 3
3957	3957	ROM_LOAD( "mpr-13467.b16", 0xa0000, 0x20000, CRC(6309fec4) SHA1(f90c9679bade3cfbaa7949e412410c29d5bfa4d3) )
3958	3958
3959		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	3959	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
3960	3960	ROM_LOAD16_BYTE( "mpr-13453.b1",  0x000001, 0x020000, CRC(5fa0a9f8) SHA1(d9d67cc006a608d48e37aa89359f1a9403172b00) )
3961	3961	ROM_LOAD16_BYTE( "mpr-13457.b5",  0x000000, 0x020000, CRC(0d1b54da) SHA1(c7a6393f9e13adabe93b7a86aa7845c5f4d188f1) )
3962	3962	ROM_LOAD16_BYTE( "mpr-13454.b2",  0x040001, 0x020000, CRC(5f6b33b1) SHA1(5d397bdaa2c7a9ce82cc9134bfeb78418dc613b0) )
r17593	r17594
3999	3999	ROM_LOAD( "mpr-13452.a16", 0x80000, 0x20000, CRC(047bde5e) SHA1(e759baedcbb637a6c14af461b8a492554cadc9e4) ) // plane 3
4000	4000	ROM_LOAD( "mpr-13467.b16", 0xa0000, 0x20000, CRC(6309fec4) SHA1(f90c9679bade3cfbaa7949e412410c29d5bfa4d3) )
4001	4001
4002		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	4002	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
4003	4003	ROM_LOAD16_BYTE( "mpr-13453.b1",  0x000001, 0x020000, CRC(5fa0a9f8) SHA1(d9d67cc006a608d48e37aa89359f1a9403172b00) )
4004	4004	ROM_LOAD16_BYTE( "mpr-13457.b5",  0x000000, 0x020000, CRC(0d1b54da) SHA1(c7a6393f9e13adabe93b7a86aa7845c5f4d188f1) )
4005	4005	ROM_LOAD16_BYTE( "mpr-13454.b2",  0x040001, 0x020000, CRC(5f6b33b1) SHA1(5d397bdaa2c7a9ce82cc9134bfeb78418dc613b0) )
r17593	r17594
4066	4066	ROM_LOAD( "mpr-13452.a16", 0x80000, 0x20000, CRC(047bde5e) SHA1(e759baedcbb637a6c14af461b8a492554cadc9e4) ) // plane 3
4067	4067	ROM_LOAD( "mpr-13467.b16", 0xa0000, 0x20000, CRC(6309fec4) SHA1(f90c9679bade3cfbaa7949e412410c29d5bfa4d3) )
4068	4068
4069		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	4069	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
4070	4070	ROM_LOAD16_BYTE( "mpr-13453.b1",  0x000001, 0x020000, CRC(5fa0a9f8) SHA1(d9d67cc006a608d48e37aa89359f1a9403172b00) )
4071	4071	ROM_LOAD16_BYTE( "mpr-13457.b5",  0x000000, 0x020000, CRC(0d1b54da) SHA1(c7a6393f9e13adabe93b7a86aa7845c5f4d188f1) )
4072	4072	ROM_LOAD16_BYTE( "mpr-13454.b2",  0x040001, 0x020000, CRC(5f6b33b1) SHA1(5d397bdaa2c7a9ce82cc9134bfeb78418dc613b0) )
r17593	r17594
4116	4116	ROM_LOAD( "opr-12463.a15", 0x10000, 0x10000, CRC(62f8200d) SHA1(a5a0035249f339396b33f8a908d393777e8951c4) )
4117	4117	ROM_LOAD( "opr-12464.a16", 0x20000, 0x10000, CRC(c8c59703) SHA1(3a4f45b88990d27c55ddfde5fc93496954868200) )
4118	4118
4119		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	4119	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
4120	4120	ROM_LOAD16_BYTE( "mpr-12465.b1", 0x00001, 0x20000, CRC(11d61b45) SHA1(01678e07ffcafb8c161b52763f2183dc281c7578) )
4121	4121	ROM_LOAD16_BYTE( "mpr-12467.b5", 0x00000, 0x20000, CRC(c3b4e4c0) SHA1(2d8dbea5278b3fac03c7ad8749f931d36cc8f341) )
4122	4122	ROM_LOAD16_BYTE( "mpr-12466.b2", 0x40001, 0x20000, CRC(a57f236f) SHA1(c83219cdfcee10a4fdffcbf410808f161a2b1aef) )
r17593	r17594
4148	4148	ROM_LOAD( "opr-12463.a15", 0x10000, 0x10000, CRC(62f8200d) SHA1(a5a0035249f339396b33f8a908d393777e8951c4) )
4149	4149	ROM_LOAD( "opr-12464.a16", 0x20000, 0x10000, CRC(c8c59703) SHA1(3a4f45b88990d27c55ddfde5fc93496954868200) )
4150	4150
4151		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	4151	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
4152	4152	ROM_LOAD16_BYTE( "mpr-12465.b1", 0x00001, 0x20000, CRC(11d61b45) SHA1(01678e07ffcafb8c161b52763f2183dc281c7578) )
4153	4153	ROM_LOAD16_BYTE( "mpr-12467.b5", 0x00000, 0x20000, CRC(c3b4e4c0) SHA1(2d8dbea5278b3fac03c7ad8749f931d36cc8f341) )
4154	4154	ROM_LOAD16_BYTE( "mpr-12466.b2", 0x40001, 0x20000, CRC(a57f236f) SHA1(c83219cdfcee10a4fdffcbf410808f161a2b1aef) )
r17593	r17594
4179	4179	ROM_LOAD( "opr-12463.a15", 0x10000, 0x10000, CRC(62f8200d) SHA1(a5a0035249f339396b33f8a908d393777e8951c4) )
4180	4180	ROM_LOAD( "opr-12464.a16", 0x20000, 0x10000, CRC(c8c59703) SHA1(3a4f45b88990d27c55ddfde5fc93496954868200) )
4181	4181
4182		ROM_REGION16_BE( 0x080000, "gfx2", 0 ) // sprites
	4182	ROM_REGION16_BE( 0x080000, "sprites", 0 ) // sprites
4183	4183	ROM_LOAD16_BYTE( "br_obj0o.b1", 0x00001, 0x10000, CRC(098a5e82) SHA1(c5922f418773bc3629071e584457839d67a370e9) )
4184	4184	ROM_LOAD16_BYTE( "br_obj0e.b5", 0x00000, 0x10000, CRC(85238af9) SHA1(39989a8d9b60c6d55272b5e2c213341a563dd993) )
4185	4185	ROM_LOAD16_BYTE( "br_obj1o.b2", 0x20001, 0x10000, CRC(cc641da1) SHA1(28f8a6502702cb9e2cc7f3e98f6c5d201f462fa3) )
r17593	r17594
4231	4231	ROM_LOAD( "epr-10995.b10", 0x10000, 0x10000, CRC(6b97aff1) SHA1(323bafe43a703476f6f4e68b46ec86bb9152f88e) )
4232	4232	ROM_LOAD( "epr-10996.b11", 0x20000, 0x10000, CRC(501bddd6) SHA1(545273b1b874b3e68d23b0dcae81c8531bd98756) )
4233	4233
4234		ROM_REGION16_BE( 0x80000, "gfx2", ROMREGION_ERASE00 ) // sprites
	4234	ROM_REGION16_BE( 0x80000, "sprites", ROMREGION_ERASE00 ) // sprites
4235	4235	ROM_LOAD16_BYTE( "epr-10999.b1", 0x00001, 0x010000, CRC(119f0008) SHA1(6a39b537bb58ea19ed3b0322ebca37e6574289fd) )
4236	4236	ROM_LOAD16_BYTE( "epr-11003.b5", 0x00000, 0x010000, CRC(2f429089) SHA1(08bf9d9c15fafbcb26604ff30be367ecf25404b2) )
4237	4237	ROM_LOAD16_BYTE( "epr-11000.b2", 0x20001, 0x010000, CRC(f5482bbe) SHA1(d8482ba73622798b15e78ab2c123d0fd4c33480a) )
r17593	r17594
4272	4272	ROM_LOAD( "opr-13864.a16", 0x80000, 0x20000, CRC(d2b175bf) SHA1(897b7c794d0e7229ea5e9a682f64266a947a818f) )
4273	4273	ROM_LOAD( "opr-13879.b16", 0xa0000, 0x20000, CRC(b9d62531) SHA1(e8c5e7b93339c00f75a3b66ce18f7838255577be) )
4274	4274
4275		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	4275	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
4276	4276	ROM_LOAD16_BYTE( "opr-13869.b5", 0x000000, 0x20000, CRC(ab4b3468) SHA1(3071654a295152d609d2c2c1d4153b5ba3f174d5) )
4277	4277	ROM_LOAD16_BYTE( "opr-13865.b1", 0x000001, 0x20000, CRC(7024f404) SHA1(4b2f9cdfdd97218797a3e386106e53f713b8650d) )
4278	4278	ROM_LOAD16_BYTE( "opr-13870.b6", 0x040000, 0x20000, CRC(69b41ac3) SHA1(4c5a85e5a5ca9f8260557d4e97eb091dd857d63a) )
r17593	r17594
4318	4318	ROM_LOAD( "opr-13864.a16", 0x80000, 0x20000, CRC(d2b175bf) SHA1(897b7c794d0e7229ea5e9a682f64266a947a818f) )
4319	4319	ROM_LOAD( "opr-13879.b16", 0xa0000, 0x20000, CRC(b9d62531) SHA1(e8c5e7b93339c00f75a3b66ce18f7838255577be) )
4320	4320
4321		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	4321	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
4322	4322	ROM_LOAD16_BYTE( "opr-13869.b5", 0x000000, 0x20000, CRC(ab4b3468) SHA1(3071654a295152d609d2c2c1d4153b5ba3f174d5) )
4323	4323	ROM_LOAD16_BYTE( "opr-13865.b1", 0x000001, 0x20000, CRC(7024f404) SHA1(4b2f9cdfdd97218797a3e386106e53f713b8650d) )
4324	4324	ROM_LOAD16_BYTE( "opr-13870.b6", 0x040000, 0x20000, CRC(69b41ac3) SHA1(4c5a85e5a5ca9f8260557d4e97eb091dd857d63a) )
r17593	r17594
4365	4365	ROM_LOAD( "opr-13864.a16", 0x80000, 0x20000, CRC(d2b175bf) SHA1(897b7c794d0e7229ea5e9a682f64266a947a818f) )
4366	4366	ROM_LOAD( "opr-13879.b16", 0xa0000, 0x20000, CRC(b9d62531) SHA1(e8c5e7b93339c00f75a3b66ce18f7838255577be) )
4367	4367
4368		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	4368	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
4369	4369	ROM_LOAD16_BYTE( "opr-13869.b5", 0x000000, 0x20000, CRC(ab4b3468) SHA1(3071654a295152d609d2c2c1d4153b5ba3f174d5) )
4370	4370	ROM_LOAD16_BYTE( "opr-13865.b1", 0x000001, 0x20000, CRC(7024f404) SHA1(4b2f9cdfdd97218797a3e386106e53f713b8650d) )
4371	4371	ROM_LOAD16_BYTE( "opr-13870.b6", 0x040000, 0x20000, CRC(69b41ac3) SHA1(4c5a85e5a5ca9f8260557d4e97eb091dd857d63a) )
r17593	r17594
4410	4410	ROM_LOAD( "epr-10486.b10", 0x08000, 0x8000, CRC(311d973c) SHA1(c4765917ba788ed45a801499f3d873a86c418eb8) )
4411	4411	ROM_LOAD( "epr-10487.b11", 0x10000, 0x8000, CRC(a8fb179f) SHA1(8a748d537b3d327c41d6dac17342de9be068e53b) )
4412	4412
4413		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	4413	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
4414	4414	ROM_LOAD16_BYTE( "epr-10481.b5", 0x00000, 0x8000, CRC(feb04bc9) SHA1(233dc8e3b887a88ac114723d58a909a58f0ae771) )
4415	4415	ROM_RELOAD(                      0x10000, 0x8000 )
4416	4416	ROM_LOAD16_BYTE( "epr-10477.b1", 0x00001, 0x8000, CRC(f9d3b2cb) SHA1(b530fe16882c718122bfd1de098f39e54993de28) )
r17593	r17594
4479	4479	ROM_LOAD( "mpr-11918.a15", 0x10000, 0x10000, CRC(c731db95) SHA1(b3b9cbd772f7bfd35355bcb2a7c0801b61eaf19f) )
4480	4480	ROM_LOAD( "mpr-11919.a16", 0x20000, 0x10000, CRC(64d5a491) SHA1(686151c9a58f524f786f52c03f086cdaa5728233) )
4481	4481
4482		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	4482	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
4483	4483	ROM_LOAD16_BYTE( "mpr-11920.b1", 0x00001, 0x020000, CRC(e5d1e3cd) SHA1(d8c0f40dab00f1b09f6d018597fd45147f9ca3f6) )
4484	4484	ROM_LOAD16_BYTE( "mpr-11922.b5", 0x00000, 0x020000, CRC(70b0c4dd) SHA1(b67acab0c6a0f5051fc3fcda2476b8834f65b376) )
4485	4485	ROM_LOAD16_BYTE( "mpr-11921.b2", 0x40001, 0x020000, CRC(61d2358c) SHA1(216fd295ff9d56976f9b1c465a48806be843dd04) )
r17593	r17594
4509	4509	ROM_LOAD( "mpr-11918.a15", 0x10000, 0x10000, CRC(c731db95) SHA1(b3b9cbd772f7bfd35355bcb2a7c0801b61eaf19f) )
4510	4510	ROM_LOAD( "mpr-11919.a16", 0x20000, 0x10000, CRC(64d5a491) SHA1(686151c9a58f524f786f52c03f086cdaa5728233) )
4511	4511
4512		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	4512	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
4513	4513	ROM_LOAD16_BYTE( "mpr-11920.b1", 0x00001, 0x020000, CRC(e5d1e3cd) SHA1(d8c0f40dab00f1b09f6d018597fd45147f9ca3f6) )
4514	4514	ROM_LOAD16_BYTE( "mpr-11922.b5", 0x00000, 0x020000, CRC(70b0c4dd) SHA1(b67acab0c6a0f5051fc3fcda2476b8834f65b376) )
4515	4515	ROM_LOAD16_BYTE( "mpr-11921.b2", 0x40001, 0x020000, CRC(61d2358c) SHA1(216fd295ff9d56976f9b1c465a48806be843dd04) )
r17593	r17594
4543	4543	ROM_LOAD( "mpr-12625.b12", 0x40000, 0x40000, CRC(3b8c757e) SHA1(0b66e8446d059a12e47e2a6fe8f0a333245bb95c) )
4544	4544	ROM_LOAD( "mpr-12626.b13", 0x80000, 0x40000, CRC(3efca25c) SHA1(0d866bf53a16b52719f73081e933f4db27d72ece) )
4545	4545
4546		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4546	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4547	4547	ROM_LOAD16_BYTE( "mpr-12618.b1", 0x000001, 0x20000, CRC(0d1530bf) SHA1(bb8626cd98761c1c20cee117d00315c85621ba6a) )
4548	4548	ROM_CONTINUE(                    0x100001, 0x20000 )
4549	4549	ROM_LOAD16_BYTE( "mpr-12621.b4", 0x000000, 0x20000, CRC(18ff0799) SHA1(5417223378aef16ee2b4f438d1f8f11a23fe7265) )
r17593	r17594
4581	4581	ROM_LOAD( "mpr-12625.b12", 0x40000, 0x40000, CRC(3b8c757e) SHA1(0b66e8446d059a12e47e2a6fe8f0a333245bb95c) )
4582	4582	ROM_LOAD( "mpr-12626.b13", 0x80000, 0x40000, CRC(3efca25c) SHA1(0d866bf53a16b52719f73081e933f4db27d72ece) )
4583	4583
4584		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4584	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4585	4585	ROM_LOAD16_BYTE( "mpr-12618.b1", 0x000001, 0x20000, CRC(0d1530bf) SHA1(bb8626cd98761c1c20cee117d00315c85621ba6a) )
4586	4586	ROM_CONTINUE(                    0x100001, 0x20000 )
4587	4587	ROM_LOAD16_BYTE( "mpr-12621.b4", 0x000000, 0x20000, CRC(18ff0799) SHA1(5417223378aef16ee2b4f438d1f8f11a23fe7265) )
r17593	r17594
4621	4621	ROM_LOAD( "mpr-12625.b12", 0x40000, 0x40000, CRC(3b8c757e) SHA1(0b66e8446d059a12e47e2a6fe8f0a333245bb95c) )
4622	4622	ROM_LOAD( "mpr-12626.b13", 0x80000, 0x40000, CRC(3efca25c) SHA1(0d866bf53a16b52719f73081e933f4db27d72ece) )
4623	4623
4624		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4624	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4625	4625	ROM_LOAD16_BYTE( "mpr-12618.b1", 0x000001, 0x20000, CRC(0d1530bf) SHA1(bb8626cd98761c1c20cee117d00315c85621ba6a) )
4626	4626	ROM_CONTINUE(                    0x100001, 0x20000 )
4627	4627	ROM_LOAD16_BYTE( "mpr-12621.b4", 0x000000, 0x20000, CRC(18ff0799) SHA1(5417223378aef16ee2b4f438d1f8f11a23fe7265) )
r17593	r17594
4665	4665	ROM_LOAD( "epr-11943.b10", 0x10000, 0x10000, CRC(d97c8982) SHA1(3e604af1771caba3aa213796c4a0812a5e352580) )
4666	4666	ROM_LOAD( "epr-11944.b11", 0x20000, 0x10000, CRC(a75cae80) SHA1(17c148a33b09b5403e68f5d96e506545c2ced206) )
4667	4667
4668		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	4668	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
4669	4669	ROM_LOAD16_BYTE( "epr-11950.b01", 0x00001, 0x10000, CRC(af497849) SHA1(c5fdca8d3b1d83e3d377a49ecdc0fc53714afc09) )
4670	4670	ROM_LOAD16_BYTE( "epr-11954.b05", 0x00000, 0x10000, CRC(5fa2106c) SHA1(2f2620fa52d07667dff4720fea32a6615d99e522) )
4671	4671	ROM_LOAD16_BYTE( "epr-11951.b02", 0x20001, 0x10000, CRC(c04fa974) SHA1(b1a4fb8522126113d7857d559f169f09c5f51a13) )
r17593	r17594
4730	4730	ROM_LOAD( "opr-12594.a15", 0x10000, 0x10000, CRC(8bfc4815) SHA1(08d28b65e5024c592a9a289b270774ef5c553cbf) )
4731	4731	ROM_LOAD( "opr-12595.a16", 0x20000, 0x10000, CRC(5b18d60b) SHA1(8e9c81635dcefa52d1cf53c2937ae560191b5202) )
4732	4732
4733		ROM_REGION16_BE( 0x20000, "gfx2", 0 ) // sprites
	4733	ROM_REGION16_BE( 0x20000, "sprites", 0 ) // sprites
4734	4734	ROM_LOAD16_BYTE( "opr-12596.b1", 0x00001, 0x10000, CRC(4a4041f3) SHA1(4c52b30223d8aa80ccdbb196098cb17e64ad6583) )
4735	4735	ROM_LOAD16_BYTE( "opr-12597.b5", 0x00000, 0x10000, CRC(6961e676) SHA1(7639d2da086b57a9a8d6100fdacf40d97d7c4772) )
4736	4736
r17593	r17594
4775	4775	ROM_LOAD( "opr-12594.a15", 0x10000, 0x10000, CRC(8bfc4815) SHA1(08d28b65e5024c592a9a289b270774ef5c553cbf) )
4776	4776	ROM_LOAD( "opr-12595.a16", 0x20000, 0x10000, CRC(5b18d60b) SHA1(8e9c81635dcefa52d1cf53c2937ae560191b5202) )
4777	4777
4778		ROM_REGION16_BE( 0x20000, "gfx2", 0 ) // sprites
	4778	ROM_REGION16_BE( 0x20000, "sprites", 0 ) // sprites
4779	4779	ROM_LOAD16_BYTE( "opr-12596.b1", 0x00001, 0x10000, CRC(4a4041f3) SHA1(4c52b30223d8aa80ccdbb196098cb17e64ad6583) )
4780	4780	ROM_LOAD16_BYTE( "opr-12597.b5", 0x00000, 0x10000, CRC(6961e676) SHA1(7639d2da086b57a9a8d6100fdacf40d97d7c4772) )
4781	4781
r17593	r17594
4802	4802	ROM_LOAD( "epr-12386.ic20", 0x20000, 0x20000, CRC(25d7d779) SHA1(2de14a76a5176d5abc7e7f7f723146c620927610) )
4803	4803	ROM_LOAD( "epr-12387.ic21", 0x40000, 0x20000, CRC(c7fcadf3) SHA1(5f0fd600a75a02749935af21e1e0d2c714c6417e) )
4804	4804
4805		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4805	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4806	4806	ROM_LOAD16_BYTE( "mpr-12378.ic9",  0x000001, 0x20000, CRC(119e5a82) SHA1(261ed2bc4ebac7142e2ecca9f03c91242e792a98) )
4807	4807	ROM_CONTINUE(                      0x100001, 0x20000 )
4808	4808	ROM_LOAD16_BYTE( "mpr-12379.ic12", 0x000000, 0x20000, CRC(1a0e8c57) SHA1(674f1ae7db632876fff346e76786801ae19d9799) )
r17593	r17594
4843	4843	ROM_LOAD( "epr-12386.ic20", 0x20000, 0x20000, CRC(25d7d779) SHA1(2de14a76a5176d5abc7e7f7f723146c620927610) )
4844	4844	ROM_LOAD( "epr-12387.ic21", 0x40000, 0x20000, CRC(c7fcadf3) SHA1(5f0fd600a75a02749935af21e1e0d2c714c6417e) )
4845	4845
4846		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4846	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4847	4847	ROM_LOAD16_BYTE( "mpr-12378.ic9",  0x000001, 0x20000, CRC(119e5a82) SHA1(261ed2bc4ebac7142e2ecca9f03c91242e792a98) )
4848	4848	ROM_CONTINUE(                      0x100001, 0x20000 )
4849	4849	ROM_LOAD16_BYTE( "mpr-12379.ic12", 0x000000, 0x20000, CRC(1a0e8c57) SHA1(674f1ae7db632876fff346e76786801ae19d9799) )
r17593	r17594
4884	4884	ROM_LOAD( "epr-12386.a15", 0x20000, 0x20000, CRC(25d7d779) SHA1(2de14a76a5176d5abc7e7f7f723146c620927610) )
4885	4885	ROM_LOAD( "epr-12387.a16", 0x40000, 0x20000, CRC(c7fcadf3) SHA1(5f0fd600a75a02749935af21e1e0d2c714c6417e) )
4886	4886
4887		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4887	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4888	4888	ROM_LOAD16_BYTE( "mpr-12378.b1", 0x000001, 0x20000, CRC(119e5a82) SHA1(261ed2bc4ebac7142e2ecca9f03c91242e792a98) )
4889	4889	ROM_CONTINUE(                    0x100001, 0x20000 )
4890	4890	ROM_LOAD16_BYTE( "mpr-12379.b5", 0x000000, 0x20000, CRC(1a0e8c57) SHA1(674f1ae7db632876fff346e76786801ae19d9799) )
r17593	r17594
4925	4925	ROM_LOAD( "epr-12386.a15", 0x20000, 0x20000, CRC(25d7d779) SHA1(2de14a76a5176d5abc7e7f7f723146c620927610) )
4926	4926	ROM_LOAD( "epr-12387.a16", 0x40000, 0x20000, CRC(c7fcadf3) SHA1(5f0fd600a75a02749935af21e1e0d2c714c6417e) )
4927	4927
4928		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4928	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4929	4929	ROM_LOAD16_BYTE( "mpr-12378.b1", 0x000001, 0x20000, CRC(119e5a82) SHA1(261ed2bc4ebac7142e2ecca9f03c91242e792a98) )
4930	4930	ROM_CONTINUE(                    0x100001, 0x20000 )
4931	4931	ROM_LOAD16_BYTE( "mpr-12379.b5", 0x000000, 0x20000, CRC(1a0e8c57) SHA1(674f1ae7db632876fff346e76786801ae19d9799) )
r17593	r17594
4962	4962	ROM_LOAD( "epr-12386.a15", 0x20000, 0x20000, CRC(25d7d779) SHA1(2de14a76a5176d5abc7e7f7f723146c620927610) )
4963	4963	ROM_LOAD( "epr-12387.a16", 0x40000, 0x20000, CRC(c7fcadf3) SHA1(5f0fd600a75a02749935af21e1e0d2c714c6417e) )
4964	4964
4965		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	4965	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
4966	4966	ROM_LOAD16_BYTE( "mpr-12378.b1", 0x000001, 0x20000, CRC(119e5a82) SHA1(261ed2bc4ebac7142e2ecca9f03c91242e792a98) )
4967	4967	ROM_CONTINUE(                    0x100001, 0x20000 )
4968	4968	ROM_LOAD16_BYTE( "mpr-12379.b5", 0x000000, 0x20000, CRC(1a0e8c57) SHA1(674f1ae7db632876fff346e76786801ae19d9799) )
r17593	r17594
5003	5003	ROM_LOAD( "epr-12386.ic20", 0x20000, 0x20000, CRC(25d7d779) SHA1(2de14a76a5176d5abc7e7f7f723146c620927610) )
5004	5004	ROM_LOAD( "epr-12387.ic21", 0x40000, 0x20000, CRC(c7fcadf3) SHA1(5f0fd600a75a02749935af21e1e0d2c714c6417e) )
5005	5005
5006		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	5006	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
5007	5007	ROM_LOAD16_BYTE( "mpr-12378.ic9",  0x000001, 0x20000, CRC(119e5a82) SHA1(261ed2bc4ebac7142e2ecca9f03c91242e792a98) )
5008	5008	ROM_CONTINUE(                      0x100001, 0x20000 )
5009	5009	ROM_LOAD16_BYTE( "mpr-12379.ic12", 0x000000, 0x20000, CRC(1a0e8c57) SHA1(674f1ae7db632876fff346e76786801ae19d9799) )
r17593	r17594
5045	5045	ROM_LOAD( "mpr-11243.a16", 0x80000, 0x20000, CRC(f30cd5fd) SHA1(df6118ca4b724c37b11e18d9f2ea18e9591ae7aa) )
5046	5046	ROM_LOAD( "mpr-11168.b16", 0xA0000, 0x20000, CRC(5b8494a8) SHA1(9e3f09f4037a007b6a188dd81ec8f9c635e87650) )
5047	5047
5048		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	5048	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
5049	5049	ROM_LOAD16_BYTE( "mpr-11158.b1", 0x000001, 0x010000, CRC(fc098a13) SHA1(b4a6e00d4765265bad170dabf0b2a4a58e063b16) ) // all MPR-111xx here are 28 pin Fujitsu MB831000 MASK roms
5050	5050	ROM_CONTINUE(                    0x020001, 0x010000 )
5051	5051	ROM_LOAD16_BYTE( "mpr-11162.b5", 0x000000, 0x010000, CRC(5db934a8) SHA1(ba7cc93025af71ad2674b1376b61afbb7ae910ff) )
r17593	r17594
5093	5093	ROM_LOAD( "epr-11204.a16", 0x80000, 0x20000, CRC(dfc4cd33) SHA1(880af38b6a3cb52220e7b4f0999cfafade0535f9) )
5094	5094	ROM_LOAD( "epr-11215.b16", 0xA0000, 0x20000, CRC(5b8494a8) SHA1(9e3f09f4037a007b6a188dd81ec8f9c635e87650) )
5095	5095
5096		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	5096	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
5097	5097	ROM_LOAD16_BYTE( "epr-11205.b1", 0x000001, 0x010000, CRC(fc098a13) SHA1(b4a6e00d4765265bad170dabf0b2a4a58e063b16) )
5098	5098	ROM_CONTINUE(                    0x020001, 0x010000 )
5099	5099	ROM_LOAD16_BYTE( "epr-11209.b5", 0x000000, 0x010000, CRC(5db934a8) SHA1(ba7cc93025af71ad2674b1376b61afbb7ae910ff) )
r17593	r17594
5141	5141	ROM_LOAD( "13012.rom", 0x40000, 0x40000, CRC(b75e6821) SHA1(a2b049995755d79a136a4b4b0dc78d902c5b9eed) )
5142	5142	ROM_LOAD( "13013.rom", 0x80000, 0x40000, CRC(f1944a3c) SHA1(db59cadb435c26f3a957bd4996a083fa30c8bbd0) )
5143	5143
5144		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	5144	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
5145	5145	ROM_LOAD16_BYTE( "13003.rom", 0x000001, 0x20000, CRC(21424151) SHA1(156e15eee9ff7122c30a42bfec0b307073b7a375) )
5146	5146	ROM_CONTINUE(                 0x100001, 0x20000 )
5147	5147	ROM_LOAD16_BYTE( "13006.rom", 0x000000, 0x20000, CRC(2e9afd2f) SHA1(7fe0929e70e061878065fab2d26309066d14c038) )
r17593	r17594
5187	5187	ROM_LOAD( "epr-12973.a16", 0x80000, 0x20000, CRC(8dc9b9ea) SHA1(048e129874c6ee9f34c5ee1722b8dffa6db8841c) )
5188	5188	ROM_LOAD( "epr-12985.b16", 0xa0000, 0x20000, CRC(e3f33a8a) SHA1(e7bcc882dcfa926040d0e3e0df54ed924a6b146a) )
5189	5189
5190		ROM_REGION16_BE( 0x200000, "gfx2", 0 ) // sprites
	5190	ROM_REGION16_BE( 0x200000, "sprites", 0 ) // sprites
5191	5191	ROM_LOAD16_BYTE( "epr-12977.b5", 0x000000, 0x20000, CRC(b9eb9762) SHA1(dfcf607b2bc3c742770936a5476335506d778a2d) )
5192	5192	ROM_LOAD16_BYTE( "epr-12974.b1", 0x000001, 0x20000, CRC(e1da5597) SHA1(55e1e0948896f2afbb3b967847a341ee5afac751) )
5193	5193	ROM_LOAD16_BYTE( "epr-12978.b6", 0x040000, 0x20000, CRC(014b5442) SHA1(ab6273bd5107c837f33d31ba5e7efce752ee3649) )
r17593	r17594
5235	5235	ROM_LOAD( "opr-11855.b10", 0x10000, 0x10000, CRC(b78762b4) SHA1(d594ef846bd7fed8da91a89906b39c1a2867a1fe) )
5236	5236	ROM_LOAD( "opr-11856.b11", 0x20000, 0x10000, CRC(ea49f666) SHA1(36ccd32cdcbb7fcc300628bb59c220ec3c324d82) )
5237	5237
5238		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) // sprites
	5238	ROM_REGION16_BE( 0x60000, "sprites", 0 ) // sprites
5239	5239	ROM_LOAD16_BYTE( "opr-11862.b1",  0x00001, 0x10000, CRC(b6e94727) SHA1(0838e034f1f10d9cd1312c8c94b5c57387c0c271) )
5240	5240	ROM_LOAD16_BYTE( "opr-11865.b5",  0x00000, 0x10000, CRC(17e8d5d5) SHA1(ac1074b0a705be13c6e3391441e6cfec1d2b3f8a) )
5241	5241	ROM_LOAD16_BYTE( "opr-11863.b2",  0x20001, 0x10000, CRC(3e670098) SHA1(2cfc83f4294be30cd868738886ac546bd8489962) )
r17593	r17594
5269	5269	ROM_LOAD( "opr-11855.b10", 0x10000, 0x10000, CRC(b78762b4) SHA1(d594ef846bd7fed8da91a89906b39c1a2867a1fe) )
5270	5270	ROM_LOAD( "opr-11856.b11", 0x20000, 0x10000, CRC(ea49f666) SHA1(36ccd32cdcbb7fcc300628bb59c220ec3c324d82) )
5271	5271
5272		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) // sprites
	5272	ROM_REGION16_BE( 0x60000, "sprites", 0 ) // sprites
5273	5273	ROM_LOAD16_BYTE( "opr-11862.b1",  0x00001, 0x10000, CRC(b6e94727) SHA1(0838e034f1f10d9cd1312c8c94b5c57387c0c271) )
5274	5274	ROM_LOAD16_BYTE( "opr-11865.b5",  0x00000, 0x10000, CRC(17e8d5d5) SHA1(ac1074b0a705be13c6e3391441e6cfec1d2b3f8a) )
5275	5275	ROM_LOAD16_BYTE( "opr-11863.b2",  0x20001, 0x10000, CRC(3e670098) SHA1(2cfc83f4294be30cd868738886ac546bd8489962) )
r17593	r17594
5310	5310	ROM_LOAD( "opr-11855.b10", 0x10000, 0x10000, CRC(b78762b4) SHA1(d594ef846bd7fed8da91a89906b39c1a2867a1fe) )
5311	5311	ROM_LOAD( "opr-11856.b11", 0x20000, 0x10000, CRC(ea49f666) SHA1(36ccd32cdcbb7fcc300628bb59c220ec3c324d82) )
5312	5312
5313		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) // sprites
	5313	ROM_REGION16_BE( 0x60000, "sprites", 0 ) // sprites
5314	5314	ROM_LOAD16_BYTE( "opr-11862.b1",  0x00001, 0x10000, CRC(b6e94727) SHA1(0838e034f1f10d9cd1312c8c94b5c57387c0c271) )
5315	5315	ROM_LOAD16_BYTE( "opr-11865.b5",  0x00000, 0x10000, CRC(17e8d5d5) SHA1(ac1074b0a705be13c6e3391441e6cfec1d2b3f8a) )
5316	5316	ROM_LOAD16_BYTE( "opr-11863.b2",  0x20001, 0x10000, CRC(3e670098) SHA1(2cfc83f4294be30cd868738886ac546bd8489962) )
r17593	r17594
5349	5349	ROM_LOAD( "epr-14618.bin", 0x80000, 0x20000, CRC(00eb260e) SHA1(f293180fb9a053c98022ef086bf4002563752f61) ) // plane 3
5350	5350	ROM_LOAD( "epr-14627.bin", 0xa0000, 0x20000, CRC(961e5f82) SHA1(dc88b511dff6cdebf96fe8bf388bf76098296b0f) )
5351	5351
5352		ROM_REGION16_BE( 0x1c0000, "gfx2", 0 ) // sprites
	5352	ROM_REGION16_BE( 0x1c0000, "sprites", 0 ) // sprites
5353	5353	ROM_LOAD16_BYTE( "epr-14619.bin",  0x000001, 0x020000, CRC(6f2b5ef7) SHA1(a0186fcc5b12c31b65b84355f88bcb10b1434135) )
5354	5354	ROM_CONTINUE(                      0x100001, 0x020000 )
5355	5355	ROM_LOAD16_BYTE( "epr-14622.bin",  0x000000, 0x020000, CRC(7ca7e40d) SHA1(57d26cc1b530cb867b2a4779bb5108ac457b2154) )
r17593	r17594
5389	5389	ROM_LOAD( "opr-13352.a15", 0x20000, 0x20000, CRC(5e5531e4) SHA1(e8e16b35f7985e6cdd77353ca5235db518914744) )
5390	5390	ROM_LOAD( "opr-13353.a16", 0x40000, 0x20000, CRC(6d23dfd8) SHA1(21266340290b9854cee0b62fc107cc2981519a80) )
5391	5391
5392		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5392	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5393	5393	ROM_LOAD16_BYTE( "opr-13354.b1", 0x00001, 0x20000, CRC(f07aad99) SHA1(71759525a5b7fe76d112cec93984f0f89cadbc00) )
5394	5394	ROM_LOAD16_BYTE( "opr-13356.b5", 0x00000, 0x20000, CRC(5498290b) SHA1(b3115b636d8cb6ecac22d5264b7961e3b807cf04) )
5395	5395	ROM_LOAD16_BYTE( "opr-13355.b2", 0x40001, 0x20000, CRC(67890019) SHA1(165c6a32f305273396ec0e9499e00329caadc484) )
r17593	r17594
5422	5422	ROM_LOAD( "10920.b10", 0x10000, 0x10000, CRC(22b1fb4c) SHA1(f4721796155f13d472d735c646bc52f20f04debd) )
5423	5423	ROM_LOAD( "10921.b11", 0x20000, 0x10000, CRC(7788f55d) SHA1(435273196a5e812f28a2224807e842ccadff9c10) )
5424	5424
5425		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) // sprites
	5425	ROM_REGION16_BE( 0x60000, "sprites", 0 ) // sprites
5426	5426	ROM_LOAD16_BYTE( "10760.b1", 0x00001, 0x010000, CRC(70de327b) SHA1(11dde9cefd993f5fb02baf5809fae6c1176a58a1) )
5427	5427	ROM_LOAD16_BYTE( "10763.b5", 0x00000, 0x010000, CRC(99ec5cb5) SHA1(933a2216a2c772fc82499c739457865b1c75cdb8) )
5428	5428	ROM_LOAD16_BYTE( "10761.b2", 0x20001, 0x010000, CRC(4e80f80d) SHA1(d168235bdf09317545c999676a4adf015df32366) )
r17593	r17594
5457	5457	ROM_LOAD( "epr-10773.b10", 0x10000, 0x10000, CRC(8f7129a2) SHA1(094a4065597d8d51fb2232546df1de9043fea731) )
5458	5458	ROM_LOAD( "epr-10774.b11", 0x20000, 0x10000, CRC(4409411f) SHA1(84fd7128e8440d96b0384ae3c391a59bd37ecf9d) )
5459	5459
5460		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) // sprites
	5460	ROM_REGION16_BE( 0x60000, "sprites", 0 ) // sprites
5461	5461	ROM_LOAD16_BYTE( "10760.b1", 0x00001, 0x010000, CRC(70de327b) SHA1(11dde9cefd993f5fb02baf5809fae6c1176a58a1) )
5462	5462	ROM_LOAD16_BYTE( "10763.b5", 0x00000, 0x010000, CRC(99ec5cb5) SHA1(933a2216a2c772fc82499c739457865b1c75cdb8) )
5463	5463	ROM_LOAD16_BYTE( "10761.b2", 0x20001, 0x010000, CRC(4e80f80d) SHA1(d168235bdf09317545c999676a4adf015df32366) )
r17593	r17594
5492	5492	ROM_LOAD( "epr-10773.b10", 0x10000, 0x10000, CRC(8f7129a2) SHA1(094a4065597d8d51fb2232546df1de9043fea731) )
5493	5493	ROM_LOAD( "epr-10774.b11", 0x20000, 0x10000, CRC(4409411f) SHA1(84fd7128e8440d96b0384ae3c391a59bd37ecf9d) )
5494	5494
5495		ROM_REGION16_BE( 0x60000, "gfx2", 0 ) // sprites
	5495	ROM_REGION16_BE( 0x60000, "sprites", 0 ) // sprites
5496	5496	ROM_LOAD16_BYTE( "b1.rom",   0x00001, 0x010000, CRC(30e2c50a) SHA1(1fb9e69d4cb97fdcb0f98c2a7ede246aaa4ac382) )
5497	5497	ROM_LOAD16_BYTE( "b5.rom",   0x00000, 0x010000, CRC(794e3e8b) SHA1(91ca1cb9aabf99adc8426feed4494a992afb8c4a) )
5498	5498	ROM_LOAD16_BYTE( "b2.rom",   0x20001, 0x010000, CRC(6a8b3fd0) SHA1(a122d3cb0b3263714f026e57d85b0dbf6cb110d7) )
r17593	r17594
5522	5522	ROM_LOAD( "epr-11364.a15", 0x20000, 0x20000, CRC(e63649a4) SHA1(042dded1ff964889571f63d2642b2b21b75f9763) )
5523	5523	ROM_LOAD( "epr-11365.a16", 0x40000, 0x20000, CRC(1ef55d20) SHA1(314590881a2f18339b7b9c16010e408aa0164e04) )
5524	5524
5525		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5525	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5526	5526	ROM_LOAD16_BYTE( "epr-11366.b1", 0x00001, 0x20000, CRC(319ede73) SHA1(c48ba4694ff677f30cc1ced3a3ad11c0feb1122d) )
5527	5527	ROM_LOAD16_BYTE( "epr-11368.b5", 0x00000, 0x20000, CRC(0377d7ce) SHA1(14f9674c142b78bf8b458beccfef93cc3e722c03) )
5528	5528	ROM_LOAD16_BYTE( "epr-11367.b2", 0x40001, 0x20000, CRC(1d06c5c7) SHA1(3a44f5a2058b96f212930c2e838eda1ce1036818) )
r17593	r17594
5550	5550	ROM_LOAD( "epr-11364.a15", 0x20000, 0x20000, CRC(e63649a4) SHA1(042dded1ff964889571f63d2642b2b21b75f9763) )
5551	5551	ROM_LOAD( "epr-11365.a16", 0x40000, 0x20000, CRC(1ef55d20) SHA1(314590881a2f18339b7b9c16010e408aa0164e04) )
5552	5552
5553		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5553	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5554	5554	ROM_LOAD16_BYTE( "epr-11366.b1", 0x00001, 0x20000, CRC(319ede73) SHA1(c48ba4694ff677f30cc1ced3a3ad11c0feb1122d) )
5555	5555	ROM_LOAD16_BYTE( "epr-11368.b5", 0x00000, 0x20000, CRC(0377d7ce) SHA1(14f9674c142b78bf8b458beccfef93cc3e722c03) )
5556	5556	ROM_LOAD16_BYTE( "epr-11367.b2", 0x40001, 0x20000, CRC(1d06c5c7) SHA1(3a44f5a2058b96f212930c2e838eda1ce1036818) )
r17593	r17594
5583	5583	ROM_LOAD( "epr-11285.b10", 0x10000, 0x10000, CRC(75f8fbc9) SHA1(29072edcd583af60ec66b4c8bb82b179a3751edf) )
5584	5584	ROM_LOAD( "epr-11286.b11", 0x20000, 0x10000, CRC(06508bb9) SHA1(57c9036123ec8e35d0275ab6eaff25a16aa203d4) )
5585	5585
5586		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5586	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5587	5587	ROM_LOAD16_BYTE( "epr-11290.b1", 0x00001, 0x10000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
5588	5588	ROM_LOAD16_BYTE( "epr-11294.b5", 0x00000, 0x10000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
5589	5589	ROM_LOAD16_BYTE( "epr-11291.b2", 0x20001, 0x10000, CRC(3c0797c0) SHA1(df18c7987281bd9379026c6cf7f96f6ae49fd7f9) )
r17593	r17594
5623	5623	ROM_LOAD( "epr-11285.b10", 0x10000, 0x10000, CRC(75f8fbc9) SHA1(29072edcd583af60ec66b4c8bb82b179a3751edf) )
5624	5624	ROM_LOAD( "epr-11286.b11", 0x20000, 0x10000, CRC(06508bb9) SHA1(57c9036123ec8e35d0275ab6eaff25a16aa203d4) )
5625	5625
5626		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5626	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5627	5627	ROM_LOAD16_BYTE( "epr-11290.b1", 0x00001, 0x10000, CRC(611f413a) SHA1(180f83216e2dfbfd77b0fb3be83c3042954d12df) )
5628	5628	ROM_LOAD16_BYTE( "epr-11294.b5", 0x00000, 0x10000, CRC(5eb00fc1) SHA1(97e02eee74f61fabcad2a9e24f1868cafaac1d51) )
5629	5629	ROM_LOAD16_BYTE( "epr-11291.b2", 0x20001, 0x10000, CRC(3c0797c0) SHA1(df18c7987281bd9379026c6cf7f96f6ae49fd7f9) )
r17593	r17594
5676	5676	ROM_LOAD( "opr-11345.b10", 0x10000, 0x10000, CRC(b44c068b) SHA1(05e875dc418aef12fc48d1df44f680249f6952de) )
5677	5677	ROM_LOAD( "opr-11346.b11", 0x20000, 0x10000, CRC(e5ada66c) SHA1(7e8e34ea909848d0d1b1fcccf628bf9ec169ae9b) )
5678	5678
5679		ROM_REGION16_BE( 0x80000, "gfx2", ROMREGION_ERASE00 ) // sprites
	5679	ROM_REGION16_BE( 0x80000, "sprites", ROMREGION_ERASE00 ) // sprites
5680	5680	ROM_LOAD16_BYTE( "opr-11350.b1", 0x00001, 0x010000, CRC(525ba1df) SHA1(e35487c8bf4009a767e54258d9a55056d13ba02a) )
5681	5681	ROM_LOAD16_BYTE( "opr-11354.b5", 0x00000, 0x010000, CRC(793fa3ac) SHA1(14d5a71667b4745d5b556cc15334dd9bff8de93f) )
5682	5682	ROM_LOAD16_BYTE( "opr-11351.b2", 0x20001, 0x010000, CRC(63b1f1ca) SHA1(1f19a3af099d4a6ad196968b0a3c17a11384e474) )
r17593	r17594
5720	5720	ROM_LOAD( "epr-12226-93.b11", 0x10000, 0x08000, CRC(210e6999) SHA1(5707cc613060b0070a822850b9afab8293f64dd7) )
5721	5721	//(epr xxxxx - S16a location . S16b location
5722	5722
5723		ROM_REGION16_BE( 0x80000, "gfx2", ROMREGION_ERASE00 ) // sprites
	5723	ROM_REGION16_BE( 0x80000, "sprites", ROMREGION_ERASE00 ) // sprites
5724	5724	ROM_LOAD16_BYTE( "epr-12232-10.b1", 0x00001, 0x010000, CRC(0adec62b) SHA1(cd798a7994cea73bffe78feac4e692d755074b1d) )
5725	5725	ROM_LOAD16_BYTE( "epr-12236-11.b5", 0x00000, 0x010000, CRC(286b9af8) SHA1(085251b8ce8b7fadf15b8ebd5872f0337adf142b) )
5726	5726	ROM_LOAD16_BYTE( "epr-12233-17.b2", 0x20001, 0x010000, CRC(3e45969c) SHA1(804f3714c97877c6f0caf458f8af38e8d8179d73) )
r17593	r17594
5767	5767	ROM_LOAD( "epr-11137.b10", 0x10000, 0x10000, CRC(92d96187) SHA1(45138795992b9842d5b0c86a96b300445bf12060) )
5768	5768	ROM_LOAD( "epr-11138.b11", 0x20000, 0x10000, CRC(c01dc773) SHA1(b27da906186e1272cdd6f8d5e5a979f6623255ac) )
5769	5769
5770		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5770	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5771	5771	ROM_LOAD16_BYTE( "epr-11144.b01", 0x00001, 0x10000, CRC(b31de51c) SHA1(011a79a37d32ab4545187e28e61f27aa0601f686) )
5772	5772	ROM_LOAD16_BYTE( "epr-11148.b05", 0x00000, 0x10000, CRC(126e1309) SHA1(7386ac5ac57325d8f661caf8cab0b19a42c0309d) )
5773	5773	ROM_LOAD16_BYTE( "epr-11145.b02", 0x20001, 0x10000, CRC(4223d2c3) SHA1(310d5c411eeaf69fe0dc9350e6bfe6dfe950b373) )
r17593	r17594
5806	5806	ROM_LOAD( "epr-12166.b10", 0x10000, 0x10000, CRC(9abd183b) SHA1(621b017cb34973f9227be383e26b5cd41aea9422) )
5807	5807	ROM_LOAD( "epr-12167.b11", 0x20000, 0x10000, CRC(2495fd4e) SHA1(2db94ead9223a67238a97e724668076fc43e5534) )
5808	5808
5809		ROM_REGION16_BE( 0x020000, "gfx2", 0 ) // sprites
	5809	ROM_REGION16_BE( 0x020000, "sprites", 0 ) // sprites
5810	5810	ROM_LOAD16_BYTE( "obj0-o.rom", 0x00001, 0x10000, CRC(2fb38880) SHA1(0e1b601bbda78d1887951c1f7e752531c281bc83) )
5811	5811	ROM_LOAD16_BYTE( "obj0-e.rom", 0x00000, 0x10000, CRC(d6a02cba) SHA1(d80000f92e754e89c6ca7b7273feab448fc9a061) )
5812	5812
r17593	r17594
5845	5845	ROM_LOAD( "epr-12166.b10", 0x10000, 0x10000, CRC(9abd183b) SHA1(621b017cb34973f9227be383e26b5cd41aea9422) )
5846	5846	ROM_LOAD( "epr-12167.b11", 0x20000, 0x10000, CRC(2495fd4e) SHA1(2db94ead9223a67238a97e724668076fc43e5534) )
5847	5847
5848		ROM_REGION16_BE( 0x10000, "gfx2", 0 ) // sprites
	5848	ROM_REGION16_BE( 0x10000, "sprites", 0 ) // sprites
5849	5849	ROM_LOAD16_BYTE( "epr-12169.b1", 0x0001, 0x8000, CRC(dacc6165) SHA1(87b1a7643e3630ff73b2b117752496e1ea5da23d) )
5850	5850	ROM_LOAD16_BYTE( "epr-12170.b5", 0x0000, 0x8000, CRC(87354e42) SHA1(e7fd55aee59b51d82cb9b619fbb815ad6839560c) )
5851	5851
r17593	r17594
5875	5875	ROM_LOAD( "epr-10544.b10", 0x08000, 0x8000, CRC(84fb9a3a) SHA1(efde54cc9582f68e58cae05f717a4fc8f620c0fc) )
5876	5876	ROM_LOAD( "epr-10545.b11", 0x10000, 0x8000, CRC(c8694bc0) SHA1(e48fc349ef454ded86141937f70b006e64da6b6b) )
5877	5877
5878		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5878	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5879	5879	ROM_LOAD16_BYTE( "epr-10548.b1", 0x00001, 0x8000, CRC(aa150735) SHA1(b6e6ff9229c641e196fc7a0a2cf7aa362f554676) )
5880	5880	ROM_LOAD16_BYTE( "epr-10552.b5", 0x00000, 0x8000, CRC(6fcbb9f7) SHA1(0a0fab930477d8b79e500263bbc80d3bf73778f8) )
5881	5881	ROM_LOAD16_BYTE( "epr-10549.b2", 0x20001, 0x8000, CRC(2f59f067) SHA1(1fb64cce2f98ddcb5ecb662e63ea636a8da08bcd) )
r17593	r17594
5908	5908	ROM_LOAD( "epr-17701.b12", 0x40000, 0x40000, CRC(6dfb025b) SHA1(502c16f650596a791fae1834f9bce6f3aa25c45f) )
5909	5909	ROM_LOAD( "epr-17702.b13", 0x80000, 0x40000, CRC(ae0b7eab) SHA1(403ca2b50913a744e2c5e1cd0d59c69df5464836) )
5910	5910
5911		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	5911	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
5912	5912	ROM_LOAD16_BYTE( "epr-17692.b1", 0x00001, 0x20000, CRC(543c4327) SHA1(9f40163aaf165f5e4f5aefd8ce083d5f72ded125) )
5913	5913	ROM_LOAD16_BYTE( "epr-17695.b4", 0x00000, 0x20000, CRC(ee60f244) SHA1(21b912e12f6a56ea6b9e5e0be117b447d1ecda43) )
5914	5914	ROM_LOAD16_BYTE( "epr-17693.b2", 0x40001, 0x20000, CRC(4a350b3e) SHA1(70181bf713106475cdf684f86d593ee323ded2ca) )
r17593	r17594
5941	5941	ROM_LOAD( "12269.a15", 0x10000, 0x10000, CRC(457a8790) SHA1(b701e1a1745cefb31083c8a3daa3b23181f89576) )
5942	5942	ROM_LOAD( "12270.a16", 0x20000, 0x10000, CRC(69fc025b) SHA1(20be1242de27f1b997d43890051cc5d5ac8a127a) )
5943	5943
5944		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	5944	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
5945	5945	ROM_LOAD16_BYTE( "12279.b1", 0x00001, 0x10000, CRC(7a169fb1) SHA1(1ec6da0d2cfcf727e61f61c847fd8b975b64f944) )
5946	5946	ROM_LOAD16_BYTE( "12283.b5", 0x00000, 0x10000, CRC(ae0fa085) SHA1(ae9af92d4dd0c8a0f064d24e647522b588fbd7f7) )
5947	5947	ROM_LOAD16_BYTE( "12278.b2", 0x40001, 0x10000, CRC(961d06b7) SHA1(b1a9dea63785bfa2c0e7b931387b91dfcd27d79b) )
r17593	r17594
5978	5978	ROM_LOAD( "12269.a15", 0x10000, 0x10000, CRC(457a8790) SHA1(b701e1a1745cefb31083c8a3daa3b23181f89576) )
5979	5979	ROM_LOAD( "12270.a16", 0x20000, 0x10000, CRC(69fc025b) SHA1(20be1242de27f1b997d43890051cc5d5ac8a127a) )
5980	5980
5981		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	5981	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
5982	5982	ROM_LOAD16_BYTE( "12276.b4", 0x00001, 0x10000, CRC(838bd71f) SHA1(82d9d127438f5e1906b1cf40bf3b4727f2ee5685) )
5983	5983	ROM_LOAD16_BYTE( "12280.b8", 0x00000, 0x10000, CRC(639a57cb) SHA1(84fd8b96758d38f9e1ba1a3c2cf8099ec0452784) )
5984	5984	ROM_LOAD16_BYTE( "12277.b3", 0x20001, 0x10000, CRC(f16b6ba2) SHA1(00cc04c7b5aad82d51d2d252e1e57bcdc5e2c9e3) )
r17593	r17594
6017	6017	ROM_LOAD( "epr-12125.a15", 0x10000, 0x10000, CRC(9fc36df7) SHA1(b39ccc687489e9781181197505fc78aa5cf7ea55) )
6018	6018	ROM_LOAD( "epr-12126.a16", 0x20000, 0x10000, CRC(a693fd94) SHA1(38e5446f41b6793a8e4134fdd92b02b86e3589f7) )
6019	6019
6020		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	6020	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
6021	6021	ROM_LOAD16_BYTE( "epr-12090.b1", 0x00001, 0x010000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
6022	6022	ROM_LOAD16_BYTE( "epr-12094.b5", 0x00000, 0x010000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
6023	6023	ROM_LOAD16_BYTE( "epr-12091.b2", 0x40001, 0x010000, CRC(8409a243) SHA1(bcbb9510a6499d8147543d6befa5a49f4ac055d9) )
r17593	r17594
6053	6053	ROM_LOAD( "epr-12125.a15", 0x10000, 0x10000, CRC(9fc36df7) SHA1(b39ccc687489e9781181197505fc78aa5cf7ea55) )
6054	6054	ROM_LOAD( "epr-12126.a16", 0x20000, 0x10000, CRC(a693fd94) SHA1(38e5446f41b6793a8e4134fdd92b02b86e3589f7) )
6055	6055
6056		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	6056	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
6057	6057	ROM_LOAD16_BYTE( "epr-12090.b1", 0x00001, 0x010000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
6058	6058	ROM_LOAD16_BYTE( "epr-12094.b5", 0x00000, 0x010000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
6059	6059	ROM_LOAD16_BYTE( "epr-12091.b2", 0x40001, 0x010000, CRC(8409a243) SHA1(bcbb9510a6499d8147543d6befa5a49f4ac055d9) )
r17593	r17594
6085	6085	ROM_LOAD( "epr-12125.a15", 0x10000, 0x10000, CRC(9fc36df7) SHA1(b39ccc687489e9781181197505fc78aa5cf7ea55) )
6086	6086	ROM_LOAD( "epr-12126.a16", 0x20000, 0x10000, CRC(a693fd94) SHA1(38e5446f41b6793a8e4134fdd92b02b86e3589f7) )
6087	6087
6088		ROM_REGION16_BE( 0x100000, "gfx2", 0 ) // sprites
	6088	ROM_REGION16_BE( 0x100000, "sprites", 0 ) // sprites
6089	6089	ROM_LOAD16_BYTE( "epr-12090.b1", 0x00001, 0x010000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
6090	6090	ROM_LOAD16_BYTE( "epr-12094.b5", 0x00000, 0x010000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
6091	6091	ROM_LOAD16_BYTE( "epr-12091.b2", 0x40001, 0x010000, CRC(8409a243) SHA1(bcbb9510a6499d8147543d6befa5a49f4ac055d9) )
r17593	r17594
6132	6132	ROM_LOAD( "epr-12125.b10", 0x10000, 0x10000, CRC(9fc36df7) SHA1(b39ccc687489e9781181197505fc78aa5cf7ea55) )
6133	6133	ROM_LOAD( "epr-12126.b11", 0x20000, 0x10000, CRC(a693fd94) SHA1(38e5446f41b6793a8e4134fdd92b02b86e3589f7) )
6134	6134
6135		ROM_REGION16_BE( 0x80000, "gfx2", 0 ) // sprites
	6135	ROM_REGION16_BE( 0x80000, "sprites", 0 ) // sprites
6136	6136	ROM_LOAD16_BYTE( "epr-12090.b1", 0x00001, 0x010000, CRC(aeeecfca) SHA1(496124b170a725ad863c741d4e021ab947511e4c) )
6137	6137	ROM_LOAD16_BYTE( "epr-12094.b5", 0x00000, 0x010000, CRC(615e4927) SHA1(d23f164973afa770714e284a77ddf10f18cc596b) )
6138	6138	ROM_LOAD16_BYTE( "epr-12091.b2", 0x20001, 0x010000, CRC(8409a243) SHA1(bcbb9510a6499d8147543d6befa5a49f4ac055d9) )
r17593	r17594
6185	6185	ROM_LOAD( "mpr-12151.a15", 0x20000, 0x20000, CRC(2b1a0751) SHA1(8cb1027ef3728f5bdfdb5e2df0f0421f743cdc0a) )
6186	6186	ROM_LOAD( "mpr-12152.a16", 0x40000, 0x20000, CRC(f6e190fe) SHA1(4c8b334fb22c449d8d00c8f49f5eccbe008e244f) )
6187	6187
6188		ROM_REGION16_BE( 0x180000, "gfx2", 0 ) // sprites
	6188	ROM_REGION16_BE( 0x180000, "sprites", 0 ) // sprites
6189	6189	ROM_LOAD16_BYTE( "mpr-12153.b1",  0x000001, 0x20000, CRC(ffa7d368) SHA1(e5663ef1cbe8ab27be0919a3cd78d9a7747bbac6) )
6190	6190	ROM_LOAD16_BYTE( "mpr-12157.b5",  0x000000, 0x20000, CRC(8d7794c1) SHA1(ace87970cfa02ab8200173622633d0d70ef7aa9e) )
6191	6191	ROM_LOAD16_BYTE( "mpr-12154.b2",  0x040001, 0x20000, CRC(0ed343f2) SHA1(951bd616e63c5fe0aa3f387c9c12153b4f29675f) )
r17593	r17594
6228	6228	ROM_LOAD( "mpr-12151.a15", 0x20000, 0x20000, CRC(2b1a0751) SHA1(8cb1027ef3728f5bdfdb5e2df0f0421f743cdc0a) )
6229	6229	ROM_LOAD( "mpr-12152.a16", 0x40000, 0x20000, CRC(f6e190fe) SHA1(4c8b334fb22c449d8d00c8f49f5eccbe008e244f) )
6230	6230
6231		ROM_REGION16_BE( 0x180000, "gfx2", 0 ) // sprites
	6231	ROM_REGION16_BE( 0x180000, "sprites", 0 ) // sprites
6232	6232	ROM_LOAD16_BYTE( "mpr-12153.b1",  0x000001, 0x20000, CRC(ffa7d368) SHA1(e5663ef1cbe8ab27be0919a3cd78d9a7747bbac6) )
6233	6233	ROM_LOAD16_BYTE( "mpr-12157.b5",  0x000000, 0x20000, CRC(8d7794c1) SHA1(ace87970cfa02ab8200173622633d0d70ef7aa9e) )
6234	6234	ROM_LOAD16_BYTE( "mpr-12154.b2",  0x040001, 0x20000, CRC(0ed343f2) SHA1(951bd616e63c5fe0aa3f387c9c12153b4f29675f) )
r17593	r17594
6268	6268	ROM_LOAD( "mpr-12151.a15", 0x20000, 0x20000, CRC(2b1a0751) SHA1(8cb1027ef3728f5bdfdb5e2df0f0421f743cdc0a) )
6269	6269	ROM_LOAD( "mpr-12152.a16", 0x40000, 0x20000, CRC(f6e190fe) SHA1(4c8b334fb22c449d8d00c8f49f5eccbe008e244f) )
6270	6270
6271		ROM_REGION16_BE( 0x180000, "gfx2", 0 ) // sprites
	6271	ROM_REGION16_BE( 0x180000, "sprites", 0 ) // sprites
6272	6272	ROM_LOAD16_BYTE( "mpr-12153.b1",  0x000001, 0x20000, CRC(ffa7d368) SHA1(e5663ef1cbe8ab27be0919a3cd78d9a7747bbac6) )
6273	6273	ROM_LOAD16_BYTE( "mpr-12157.b5",  0x000000, 0x20000, CRC(8d7794c1) SHA1(ace87970cfa02ab8200173622633d0d70ef7aa9e) )
6274	6274	ROM_LOAD16_BYTE( "mpr-12154.b2",  0x040001, 0x20000, CRC(0ed343f2) SHA1(951bd616e63c5fe0aa3f387c9c12153b4f29675f) )
r17593	r17594
6317	6317	ROM_LOAD( "fz2.a15", 0x20000, 0x20000, CRC(2b933344) SHA1(5b53ea8d58cc3d157aec6926db048359984e4276) )
6318	6318	ROM_LOAD( "fz2.a16", 0x40000, 0x20000, CRC(e63281a1) SHA1(72379c579484c1ef7784a9598d373446ef0a472b) )
6319	6319
6320		ROM_REGION16_BE( 0x180000, "gfx2", 0 ) // sprites
	6320	ROM_REGION16_BE( 0x180000, "sprites", 0 ) // sprites
6321	6321	ROM_LOAD16_BYTE( "fz2.b1",  0x000001, 0x20000, CRC(46bba615) SHA1(b291df4a83d7155eb7606f86ed733c24362a4db3) )
6322	6322	ROM_LOAD16_BYTE( "fz2.b5",  0x000000, 0x20000, CRC(bebeee5d) SHA1(9e57e62c6b9136667aa90d7d423fc33ac6df4352) )
6323	6323	ROM_LOAD16_BYTE( "fz2.b2",  0x040001, 0x20000, CRC(6681a7b6) SHA1(228df38601ba3895e9449921a64850941715b421) )
r17593	r17594
6349	6349	ROM_LOAD( "tileb.bin", 0x20000, 0x20000, CRC(59e181b7) SHA1(0d57d7b49b85baafa3038dc5b7551fea85f4f5c8) )
6350	6350	ROM_LOAD( "tilec.bin", 0x40000, 0x20000, CRC(375d354c) SHA1(2af5374777b13cb5aefb7fe90adea0b4d79e9202) )
6351	6351
6352		ROM_REGION16_BE( 0x140000, "gfx2", 0 ) // sprites
	6352	ROM_REGION16_BE( 0x140000, "sprites", 0 ) // sprites
6353	6353	ROM_LOAD16_BYTE( "obja.bin", 0x000001, 0x20000, CRC(9af87a4d) SHA1(b4f0f40f96c4081803742bc6576c37edff6eab16) )
6354	6354	ROM_LOAD16_BYTE( "objb.bin", 0x000000, 0x20000, CRC(2fdbca68) SHA1(bc0c96bba9e89f2711267b737ecd4bf2a177edda) )
6355	6355	ROM_LOAD16_BYTE( "objc.bin", 0x040001, 0x20000, CRC(2587487a) SHA1(eb04c03e918f1d98c36360f2b089018fe25f8dad) )
r17593	r17594
6389	6389	m_custom_io_w = write16_delegate(FUNC(segas16b_state::standard_io_w), this);
6390	6390
6391	6391	// point globals to allocated memory regions
6392		segaic16_spriteram_0 = reinterpret_cast<UINT16 *>(memshare("spriteram")->ptr());
6393		segaic16_paletteram = reinterpret_cast<UINT16 *>(memshare("paletteram")->ptr());
6394	6392	segaic16_tileram_0 = reinterpret_cast<UINT16 *>(memshare("tileram")->ptr());
6395	6393	segaic16_textram_0 = reinterpret_cast<UINT16 *>(memshare("textram")->ptr());
6396	6394
r17593	r17594
6753	6751
6754	6752	switch (m_data_type & 0x0f)
6755	6753	{
6756		case 0x0: dest = memregion("gfx2")->base();
	6754	case 0x0: dest = memregion("sprites")->base();
6757	6755	break;
6758	6756
6759	6757	case 0x1: dest = memregion("gfx1")->base();
r17593	r17594
6970	6968	AM_RANGE(0x3f0000, 0x3fffff) AM_WRITE(rom_5704_bank_w)
6971	6969	AM_RANGE(0x400000, 0x40ffff) AM_RAM_WRITE_LEGACY(segaic16_tileram_0_w) AM_SHARE("tileram")
6972	6970	AM_RANGE(0x410000, 0x410fff) AM_RAM_WRITE_LEGACY(segaic16_textram_0_w) AM_SHARE("textram")
6973		AM_RANGE(0x440000, 0x4407ff) AM_RAM AM_SHARE("spriteram")
6974		AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE_LEGACY(segaic16_paletteram_w) AM_SHARE("paletteram")
	6971	AM_RANGE(0x440000, 0x4407ff) AM_RAM AM_SHARE("sprites")
	6972	AM_RANGE(0x840000, 0x840fff) AM_RAM_WRITE(paletteram_w) AM_SHARE("paletteram")
6975	6973	AM_RANGE(0xc40000, 0xc43fff) AM_READWRITE(standard_io_r, standard_io_w)
6976	6974
6977	6975	AM_RANGE(0xe00000, 0xe00001) AM_WRITE(data_w) // writes decompressed data here (copied from RAM..)
r17593	r17594
7109	7107
7110	7108	// configure sprite banks
7111	7109	for (int i = 0; i < 16; i++)
7112		segaic16_sprites_set_bank(machine(), 0, i, i);
	7110	m_sprites->set_bank(i, i);
7113	7111
7114	7112	membank(ISGSM_MAIN_BANK)->set_base(memregion("bios")->base());
7115	7113	m_maincpu->reset();
r17593	r17594
7120	7118	// basic machine hardware
7121	7119
7122	7120	MCFG_DEVICE_REMOVE("maincpu")
	7121	MCFG_DEVICE_REMOVE("mapper")
7123	7122
7124	7123	MCFG_CPU_ADD("maincpu", M68000, 16000000) // no obvious CPU, but seems to be clocked faster than an original system16 based on the boot times
7125	7124	MCFG_CPU_PROGRAM_MAP(isgsm_map)
7126	7125	MCFG_CPU_VBLANK_INT("screen", irq4_line_hold)
	7126
7127	7127	MACHINE_CONFIG_END
7128	7128
7129	7129	DRIVER_INIT_MEMBER(isgsm_state,isgsm)
r17593	r17594
7173	7173	ROM_LOAD16_WORD_SWAP("ism2006v00.u1",0x00000,0x20000, CRC(2292585c) SHA1(97ba0e0f0be832a5114d95151e519bc027f6675b) ) \
7174	7174	ROM_REGION( 0x100000, "maincpu", ROMREGION_ERASE00 ) \
7175	7175	ROM_REGION( 0x60000, "gfx1", ROMREGION_ERASE00 ) \
7176		ROM_REGION16_BE( 0x200000, "gfx2", ROMREGION_ERASE00 ) \
	7176	ROM_REGION16_BE( 0x200000, "sprites", ROMREGION_ERASE00 ) \
7177	7177	ROM_REGION( 0x40000, "soundcpu", ROMREGION_ERASE00 ) \
7178	7178
7179	7179

trunk/src/emu/sprite.c

r0	r17594
	1	/***************************************************************************
	2
	3	General sprite handling helpers
	4
	5	****************************************************************************
	6
	7	Copyright Aaron Giles
	8	All rights reserved.
	9
	10	Redistribution and use in source and binary forms, with or without
	11	modification, are permitted provided that the following conditions are
	12	met:
	13
	14	* Redistributions of source code must retain the above copyright
	15	notice, this list of conditions and the following disclaimer.
	16	* Redistributions in binary form must reproduce the above copyright
	17	notice, this list of conditions and the following disclaimer in
	18	the documentation and/or other materials provided with the
	19	distribution.
	20	* Neither the name 'MAME' nor the names of its contributors may be
	21	used to endorse or promote products derived from this software
	22	without specific prior written permission.
	23
	24	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	25	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	26	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	27	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	28	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	29	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	30	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	32	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	33	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	POSSIBILITY OF SUCH DAMAGE.
	35
	36	***************************************************************************/
	37
	38	#include "emu.h"
	39	#include "sprite.h"
	40
	41
	42	//-------------------------------------------------
	43	//  sparse_dirty_bitmap -- constructor
	44	//-------------------------------------------------
	45
	46	sparse_dirty_bitmap::sparse_dirty_bitmap(int granularity)
	47	: m_width(0),
	48	m_height(0),
	49	m_granularity(granularity),
	50	m_rect_list_bounds(0, -1, 0, -1)
	51	{
	52	}
	53
	54	sparse_dirty_bitmap::sparse_dirty_bitmap(int width, int height, int granularity)
	55	: m_width(0),
	56	m_height(0),
	57	m_granularity(granularity),
	58	m_rect_list_bounds(0, -1, 0, -1)
	59	{
	60	// resize to the specified width/height
	61	resize(width, height);
	62	}
	63
	64
	65	//-------------------------------------------------
	66	//  dirty -- dirty a region
	67	//-------------------------------------------------
	68
	69	void sparse_dirty_bitmap::dirty(INT32 left, INT32 right, INT32 top, INT32 bottom)
	70	{
	71	// compute a rectangle in dirty space, and fill it with 1
	72	rectangle rect(left >> m_granularity, right >> m_granularity, top >> m_granularity, bottom >> m_granularity);
	73	m_bitmap.fill(1, rect);
	74
	75	// invalidate existing rect list
	76	invalidate_rect_list();
	77	}
	78
	79
	80	//-------------------------------------------------
	81	//  clean a region -- dirty a region
	82	//-------------------------------------------------
	83
	84	void sparse_dirty_bitmap::clean(INT32 left, INT32 right, INT32 top, INT32 bottom)
	85	{
	86	// if right or bottom intersect the edge of the bitmap, round up
	87	int round = (1 << m_granularity) - 1;
	88	if (right >= m_width - 1)
	89	right = m_width + round;
	90	if (bottom >= m_height - 1)
	91	bottom = m_height + round;
	92
	93	// compute a rectangle in dirty space, and fill it with 0
	94	rectangle rect((left + round) >> m_granularity, (right - round) >> m_granularity, (top + round) >> m_granularity, (bottom - round) >> m_granularity);
	95	m_bitmap.fill(0, rect);
	96
	97	// invalidate existing rect list
	98	invalidate_rect_list();
	99	}
	100
	101
	102	//-------------------------------------------------
	103	//  resize -- resize the bitmap
	104	//-------------------------------------------------
	105
	106	void sparse_dirty_bitmap::resize(int width, int height)
	107	{
	108	// set new size
	109	m_width = width;
	110	m_height = height;
	111
	112	// resize the bitmap
	113	int round = (1 << m_granularity) - 1;
	114	m_bitmap.resize((width + round) >> m_granularity, (height + round) >> m_granularity);
	115
	116	// reset everything
	117	dirty_all();
	118	}
	119
	120
	121	//-------------------------------------------------
	122	//  first_dirty_rect -- return the first dirty
	123	//   rectangle in the list
	124	//-------------------------------------------------
	125
	126	sparse_dirty_rect *sparse_dirty_bitmap::first_dirty_rect(const rectangle &cliprect)
	127	{
	128	// if what we have is valid, just return it again
	129	if (m_rect_list_bounds == cliprect)
	130	return m_rect_list.first();
	131
	132	// reclaim the dirty list and start over
	133	m_rect_allocator.reclaim_all(m_rect_list);
	134
	135	// compute dirty space rectangle coordinates
	136	int sx = cliprect.min_x >> m_granularity;
	137	int ex = cliprect.max_x >> m_granularity;
	138	int sy = cliprect.min_y >> m_granularity;
	139	int ey = cliprect.max_y >> m_granularity;
	140	int tilesize = 1 << m_granularity;
	141
	142	// loop over all grid rows that intersect our cliprect
	143	for (int y = sy; y <= ey; y++)
	144	{
	145	UINT8 *dirtybase = &m_bitmap.pix(y);
	146	sparse_dirty_rect *currect = NULL;
	147
	148	// loop over all grid columns that intersect our cliprect
	149	for (int x = sx; x <= ex; x++)
	150	{
	151	// if this tile is not dirty, end our current run and continue
	152	if (!*dirtybase++)
	153	{
	154	if (currect != NULL)
	155	*currect &= cliprect;
	156	currect = NULL;
	157	continue;
	158	}
	159
	160	// if we can't add to an existing rect, create a new one
	161	if (currect == NULL)
	162	{
	163	// allocate a new rect and add it to the list
	164	currect = &m_rect_list.append(*m_rect_allocator.alloc());
	165
	166	// make a rect describing this grid square
	167	currect->min_x = x << m_granularity;
	168	currect->max_x = currect->min_x + tilesize - 1;
	169	currect->min_y = y << m_granularity;
	170	currect->max_y = currect->min_y + tilesize - 1;
	171	}
	172
	173	// if we can add to the previous rect, just expand its width
	174	else
	175	currect->max_x += tilesize;
	176	}
	177
	178	// clip the last rect to the cliprect
	179	if (currect != NULL)
	180	*currect &= cliprect;
	181	}
	182
	183	// mark the list as valid
	184	m_rect_list_bounds = cliprect;
	185	return m_rect_list.first();
	186	}

trunk/src/emu/sprite.h

r0	r17594
	1	/***************************************************************************
	2
	3	General sprite handling helpers
	4
	5	****************************************************************************
	6
	7	Copyright Aaron Giles
	8	All rights reserved.
	9
	10	Redistribution and use in source and binary forms, with or without
	11	modification, are permitted provided that the following conditions are
	12	met:
	13
	14	* Redistributions of source code must retain the above copyright
	15	notice, this list of conditions and the following disclaimer.
	16	* Redistributions in binary form must reproduce the above copyright
	17	notice, this list of conditions and the following disclaimer in
	18	the documentation and/or other materials provided with the
	19	distribution.
	20	* Neither the name 'MAME' nor the names of its contributors may be
	21	used to endorse or promote products derived from this software
	22	without specific prior written permission.
	23
	24	THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
	25	IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	26	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	27	DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
	28	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	29	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	30	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	31	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	32	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	33	IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	POSSIBILITY OF SUCH DAMAGE.
	35
	36	***************************************************************************/
	37
	38	#pragma once
	39
	40	#ifndef __EMU_H__
	41	#error Dont include this file directly; include emu.h instead.
	42	#endif
	43
	44	#ifndef __SPRITE_H__
	45	#define __SPRITE_H__
	46
	47
	48	// ======================> sparse_dirty_rect
	49
	50	// class representing a single dirty region
	51	class sparse_dirty_rect : public rectangle
	52	{
	53	friend class simple_list<sparse_dirty_rect>;
	54
	55	public:
	56	// getters
	57	const sparse_dirty_rect *next() const { return m_next; }
	58
	59	private:
	60	// internal state
	61	sparse_dirty_rect *   m_next;
	62	};
	63
	64
	65	// ======================> sparse_dirty_bitmap
	66
	67	class sparse_dirty_bitmap
	68	{
	69	public:
	70	// construction/destruction
	71	sparse_dirty_bitmap(int granularity = 3);
	72	sparse_dirty_bitmap(int width, int height, int granularity = 3);
	73
	74	// dirtying operations - partially interecting tiles are dirtied
	75	void dirty(const rectangle &rect) { dirty(rect.left(), rect.right(), rect.top(), rect.bottom()); }
	76	void dirty(INT32 left, INT32 right, INT32 top, INT32 bottom);
	77	void dirty_all() { dirty(0, m_width - 1, 0, m_height - 1); }
	78
	79	// cleaning operations - partially intersecting tiles are NOT cleaned
	80	void clean(const rectangle &rect) { clean(rect.left(), rect.right(), rect.top(), rect.bottom()); }
	81	void clean(INT32 left, INT32 right, INT32 top, INT32 bottom);
	82	void clean_all() { clean(0, m_width - 1, 0, m_height - 1); }
	83
	84	// convert to rect list
	85	sparse_dirty_rect *first_dirty_rect() { rectangle fullrect(0, m_width - 1, 0, m_height - 1); return first_dirty_rect(fullrect); }
	86	sparse_dirty_rect *first_dirty_rect(const rectangle &cliprect);
	87
	88	// dynamic resizing
	89	void resize(int width, int height);
	90
	91	private:
	92	// invalidate cached rect list
	93	void invalidate_rect_list() { m_rect_list_bounds.set(0, -1, 0, -1); }
	94
	95	// internal state
	96	int                  m_width;
	97	int                  m_height;
	98	int                  m_granularity;
	99	bitmap_ind8            m_bitmap;
	100	rectangle            m_rect_list_bounds;
	101	fixed_allocator<sparse_dirty_rect>   m_rect_allocator;
	102	simple_list<sparse_dirty_rect> m_rect_list;
	103	};
	104
	105
	106	// ======================> sprite_device
	107
	108	template<typename _SpriteRAMType, class _BitmapType>
	109	class sprite_device : public device_t
	110	{
	111	// constants
	112	static const int BITMAP_SLOP = 16;
	113
	114	protected:
	115	// construction/destruction - only for subclasses
	116	sprite_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, int dirty_granularity = 3)
	117	: device_t(mconfig, type, name, tag, owner, 0),
	118	m_xorigin(0),
	119	m_yorigin(0),
	120	m_spriteram(NULL),
	121	m_spriteram_bytes(0),
	122	m_dirty(dirty_granularity)
	123	{
	124	force_clear();
	125	}
	126
	127	public:
	128	// getters
	129	INT32 xorigin() const { return m_xorigin; }
	130	INT32 yorigin() const { return m_yorigin; }
	131	_BitmapType &bitmap() { return m_bitmap; }
	132	sparse_dirty_rect *first_dirty_rect() { return m_dirty.first_dirty_rect(); }
	133	sparse_dirty_rect *first_dirty_rect(const rectangle &cliprect) { return m_dirty.first_dirty_rect(cliprect); }
	134	_SpriteRAMType *spriteram() const { return m_spriteram; }
	135	UINT32 spriteram_bytes() const { return m_spriteram_bytes; }
	136	UINT32 spriteram_elements() const { return m_spriteram_bytes / sizeof(_SpriteRAMType); }
	137	_SpriteRAMType *buffer() { return &m_buffer[0]; }
	138
	139	// static configuration
	140	static void static_set_xorigin(device_t &device, int origin) { downcast<sprite_device &>(device).m_xorigin = origin; }
	141	static void static_set_yorigin(device_t &device, int origin) { downcast<sprite_device &>(device).m_yorigin = origin; }
	142	static void static_set_origin(device_t &device, int xorigin, int yorigin) { static_set_xorigin(device, xorigin); static_set_yorigin(device, yorigin); }
	143
	144	// configuration
	145	void set_origin(INT32 xorigin = 0, INT32 yorigin = 0) { m_xorigin = xorigin; m_yorigin = yorigin; }
	146
	147	// buffering
	148	void copy_to_buffer() { memcpy(m_buffer, m_spriteram, m_spriteram_bytes); }
	149
	150	// clearing
	151	void clear() { clear(m_bitmap.cliprect()); }
	152	void clear(const rectangle &cliprect)
	153	{
	154	for (const sparse_dirty_rect *rect = m_dirty.first_dirty_rect(cliprect); rect != NULL; rect = rect->next())
	155	m_bitmap.fill(~0, *rect);
	156	m_dirty.clean(cliprect);
	157	}
	158
	159	// force clear (don't use dirty rects)
	160	void force_clear()
	161	{
	162	m_bitmap.fill(~0);
	163	m_dirty.clean_all();
	164	}
	165
	166	// drawing
	167	void draw_async(const rectangle &cliprect, bool clearit = true)
	168	{
	169	// if the cliprect exceeds our current bitmap dimensions, expand
	170	if (cliprect.right() >= m_bitmap.width() || cliprect.bottom() >= m_bitmap.height())
	171	{
	172	int new_width = MAX(cliprect.right() + 1, m_bitmap.width());
	173	int new_height = MAX(cliprect.bottom() + 1, m_bitmap.height());
	174	m_bitmap.resize(new_width, new_height, BITMAP_SLOP, BITMAP_SLOP);
	175	m_dirty.resize(new_width, new_height);
	176	}
	177
	178	// clear out the region
	179	if (clearit)
	180	clear(cliprect);
	181
	182	// wrap the bitmap, adjusting for x/y origins
	183	_BitmapType wrapped(&m_bitmap.pix(0) - m_xorigin - m_yorigin * m_bitmap.rowpixels(), m_xorigin + cliprect.right() + 1, m_yorigin + cliprect.bottom() + 1, m_bitmap.rowpixels());
	184
	185	// compute adjusted cliprect in source space
	186	rectangle adjusted = cliprect;
	187	adjusted.offset(m_xorigin, m_yorigin);
	188
	189	// render
	190	draw(wrapped, adjusted);
	191	}
	192
	193	protected:
	194	// device-level overrides
	195	virtual void device_start()
	196	{
	197	// find spriteram
	198	memory_share *spriteram = owner()->memshare(tag());
	199	if (spriteram == NULL)
	200	throw emu_fatalerror("Unable to find shared spriteram with tag '%s'\n", tag());
	201
	202	// set up pointers
	203	m_spriteram = reinterpret_cast<_SpriteRAMType *>(spriteram->ptr());
	204	m_spriteram_bytes = spriteram->bytes();
	205
	206	// allocate the double buffer to match the RAM size
	207	m_buffer.resize(m_spriteram_bytes / sizeof(_SpriteRAMType));
	208
	209	// save states
	210	save_item(NAME(m_buffer));
	211	}
	212
	213	// subclass overrides
	214	virtual void draw(_BitmapType &bitmap, const rectangle &cliprect) = 0;
	215
	216	// subclass helpers
	217	void mark_dirty(const rectangle &rect) { mark_dirty(rect.left(), rect.right(), rect.top(), rect.bottom()); }
	218	void mark_dirty(INT32 left, INT32 right, INT32 top, INT32 bottom) { m_dirty.dirty(left - m_xorigin, right - m_xorigin, top - m_yorigin, bottom - m_yorigin); }
	219
	220	private:
	221	// configuration
	222	INT32                     m_xorigin;            // X origin for drawing
	223	INT32                     m_yorigin;            // Y origin for drawing
	224
	225	// memory pointers and buffers
	226	_SpriteRAMType *            m_spriteram;         // pointer to spriteram pointer
	227	INT32                     m_spriteram_bytes;      // size of sprite RAM in bytes
	228	dynamic_array<_SpriteRAMType>   m_buffer;            // buffered spriteram for those that use it
	229
	230	// bitmaps
	231	_BitmapType                  m_bitmap;            // live bitmap
	232	sparse_dirty_bitmap            m_dirty;            // dirty bitmap
	233	};
	234
	235	typedef sprite_device<UINT8, bitmap_ind16> sprite8_device_ind16;
	236	typedef sprite_device<UINT16, bitmap_ind16> sprite16_device_ind16;
	237	typedef sprite_device<UINT32, bitmap_ind16> sprite32_device_ind16;
	238
	239	typedef sprite_device<UINT8, bitmap_ind32> sprite8_device_ind32;
	240	typedef sprite_device<UINT16, bitmap_ind32> sprite16_device_ind32;
	241	typedef sprite_device<UINT32, bitmap_ind32> sprite32_device_ind32;
	242
	243
	244	#endif   // __SPRITE_H__

trunk/src/emu/emu.mak

r17593	r17594
99	99	$(EMUOBJ)/softlist.o \
100	100	$(EMUOBJ)/sound.o \
101	101	$(EMUOBJ)/speaker.o \
	102	$(EMUOBJ)/sprite.o \
102	103	$(EMUOBJ)/tilemap.o \
103	104	$(EMUOBJ)/timer.o \
104	105	$(EMUOBJ)/ui.o \

trunk/src/lib/util/bitmap.h

r17593	r17594
76	76	rectangle() { }
77	77	rectangle(INT32 minx, INT32 maxx, INT32 miny, INT32 maxy)
78	78	: min_x(minx), max_x(maxx), min_y(miny), max_y(maxy) { }
	79
	80	// getters
	81	INT32 left() const { return min_x; }
	82	INT32 right() const { return max_x; }
	83	INT32 top() const { return min_y; }
	84	INT32 bottom() const { return max_y; }
79	85
80	86	// compute intersection with another rect
81	87	rectangle &operator&=(const rectangle &src)
r17593	r17594
96	102	if (src.max_y > max_y) max_y = src.max_y;
97	103	return *this;
98	104	}
	105
	106	// comparisons
	107	bool operator==(const rectangle &rhs) const { return min_x == rhs.min_x && max_x == rhs.max_x && min_y == rhs.min_y && max_y == rhs.max_y; }
	108	bool operator!=(const rectangle &rhs) const { return min_x != rhs.min_x || max_x != rhs.max_x || min_y != rhs.min_y || max_y != rhs.max_y; }
	109	bool operator>(const rectangle &rhs) const { return min_x < rhs.min_x && min_y < rhs.min_y && max_x > rhs.max_x && max_y > rhs.max_y; }
	110	bool operator>=(const rectangle &rhs) const { return min_x <= rhs.min_x && min_y <= rhs.min_y && max_x >= rhs.max_x && max_y >= rhs.max_y; }
	111	bool operator<(const rectangle &rhs) const { return min_x >= rhs.min_x || min_y >= rhs.min_y || max_x <= rhs.max_x || max_y <= rhs.max_y; }
	112	bool operator<=(const rectangle &rhs) const { return min_x > rhs.min_x || min_y > rhs.min_y || max_x < rhs.max_x || max_y < rhs.max_y; }
99	113
100	114	// other helpers
101	115	bool empty() const { return (min_x > max_x || min_y > max_y); }
r17593	r17594
114	128	void set_height(INT32 height) { max_y = min_y + height - 1; }
115	129	void set_origin(INT32 x, INT32 y) { max_x += x - min_x; max_y += y - min_y; min_x = x; min_y = y; }
116	130	void set_size(INT32 width, INT32 height) { set_width(width); set_height(height); }
	131
	132	// offset helpers
	133	void offset(INT32 xdelta, INT32 ydelta) { min_x += xdelta; max_x += xdelta; min_y += ydelta; max_y += ydelta; }
	134	void offsetx(INT32 delta) { min_x += delta; max_x += delta; }
	135	void offsety(INT32 delta) { min_y += delta; max_y += delta; }
117	136
118	137	// internal state
119	138	INT32         min_x;         // minimum X, or left coordinate

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team