summaryrefslogtreecommitdiffstatshomepage
path: root/src/mame/includes/astrocde.h
blob: 7daa25411eb9fbd77ed096daaa06c005ee9764b6 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
// license:BSD-3-Clause
// copyright-holders:Nicola Salmoria, Mike Coates, Frank Palazzolo, Aaron Giles
/***************************************************************************

    Bally Astrocade-based hardware

***************************************************************************/
#ifndef MAME_INCLUDES_ASTROCDE_H
#define MAME_INCLUDES_ASTROCDE_H

#pragma once

#include "cpu/z80/z80.h"
#include "machine/bankdev.h"
#include "machine/gen_latch.h"
#include "sound/astrocde.h"
#include "sound/samples.h"
#include "sound/votrax.h"
#include "emupal.h"
#include "screen.h"

#define ASTROCADE_CLOCK     (XTAL(14'318'181)/2)

#define AC_SOUND_PRESENT    (0x01)
#define AC_LIGHTPEN_INTS    (0x02)
#define AC_STARS            (0x04)
#define AC_MONITOR_BW       (0x08)


class astrocde_state : public driver_device
{
public:
	enum
	{
		TIMER_INTERRUPT_OFF,
		TIMER_SCANLINE
	};

	astrocde_state(const machine_config &mconfig, device_type type, const char *tag) :
		driver_device(mconfig, type, tag),
		m_maincpu(*this, "maincpu"),
		m_votrax(*this, "votrax"),
		m_astrocade_sound1(*this, "astrocade1"),
		m_videoram(*this, "videoram"),
		m_protected_ram(*this, "protected_ram"),
		m_screen(*this, "screen"),
		m_soundlatch(*this, "soundlatch"),
		m_bank4000(*this, "bank4000"),
		m_bank8000(*this, "bank8000"),
		m_handle(*this, "P%uHANDLE", 1U),
		m_interrupt_scanline(0xff)
	{ }

	required_device<cpu_device> m_maincpu;
	optional_device<votrax_sc01_device> m_votrax;
	optional_device<astrocade_io_device> m_astrocade_sound1;
	optional_shared_ptr<uint8_t> m_videoram;
	optional_shared_ptr<uint8_t> m_protected_ram;
	required_device<screen_device> m_screen;
	optional_device<generic_latch_8_device> m_soundlatch;
	optional_device<address_map_bank_device> m_bank4000;
	optional_memory_bank m_bank8000;
	optional_ioport_array<4> m_handle;

	uint8_t m_video_config;
	uint8_t m_sparkle[4];
	char m_totalword[256];
	char *m_totalword_ptr;
	char m_oldword[256];
	int m_plural;
	uint8_t m_ram_write_enable;
	uint8_t m_input_select;
	std::unique_ptr<uint8_t[]> m_sparklestar;
	uint8_t m_interrupt_enabl;
	uint8_t m_interrupt_vector;
	uint8_t m_interrupt_scanline;
	uint8_t m_vertical_feedback;
	uint8_t m_horizontal_feedback;
	emu_timer *m_scanline_timer;
	emu_timer *m_intoff_timer;
	uint8_t m_colors[8];
	uint8_t m_colorsplit;
	uint8_t m_bgdata;
	uint8_t m_vblank;
	uint8_t m_video_mode;
	uint8_t m_funcgen_expand_color[2];
	uint8_t m_funcgen_control;
	uint8_t m_funcgen_expand_count;
	uint8_t m_funcgen_rotate_count;
	uint8_t m_funcgen_rotate_data[4];
	uint8_t m_funcgen_shift_prev_data;
	uint8_t m_funcgen_intercept;
	uint16_t m_pattern_source;
	uint8_t m_pattern_mode;
	uint16_t m_pattern_dest;
	uint8_t m_pattern_skip;
	uint8_t m_pattern_width;
	uint8_t m_pattern_height;
	std::unique_ptr<uint16_t[]> m_profpac_videoram;
	uint16_t m_profpac_palette[16];
	uint8_t m_profpac_colormap[4];
	uint8_t m_profpac_intercept;
	uint8_t m_profpac_vispage;
	uint8_t m_profpac_readpage;
	uint8_t m_profpac_readshift;
	uint8_t m_profpac_writepage;
	uint8_t m_profpac_writemode;
	uint16_t m_profpac_writemask;
	uint8_t m_profpac_vw;
	DECLARE_WRITE8_MEMBER(protected_ram_enable_w);
	DECLARE_READ8_MEMBER(protected_ram_r);
	DECLARE_WRITE8_MEMBER(protected_ram_w);
	DECLARE_READ8_MEMBER(input_mux_r);
	template<int Coin> DECLARE_WRITE_LINE_MEMBER(coin_counter_w);
	template<int Bit> DECLARE_WRITE_LINE_MEMBER(sparkle_w);
	DECLARE_WRITE_LINE_MEMBER(gorf_sound_switch_w);
	DECLARE_WRITE8_MEMBER(profpac_banksw_w);
	DECLARE_WRITE8_MEMBER(demndrgn_banksw_w);
	DECLARE_READ8_MEMBER(video_register_r);
	DECLARE_WRITE8_MEMBER(video_register_w);
	DECLARE_WRITE8_MEMBER(astrocade_funcgen_w);
	DECLARE_WRITE8_MEMBER(expand_register_w);
	DECLARE_WRITE8_MEMBER(astrocade_pattern_board_w);
	DECLARE_WRITE8_MEMBER(profpac_page_select_w);
	DECLARE_READ8_MEMBER(profpac_intercept_r);
	DECLARE_WRITE8_MEMBER(profpac_screenram_ctrl_w);
	DECLARE_READ8_MEMBER(profpac_videoram_r);
	DECLARE_WRITE8_MEMBER(profpac_videoram_w);
	DECLARE_INPUT_CHANGED_MEMBER(spacezap_monitor);
	void init_profpac();
	void init_spacezap();
	void init_robby();
	void init_wow();
	void init_tenpindx();
	void init_seawolf2();
	void init_demndrgn();
	void init_ebases();
	void init_gorf();
	void init_astrocde();
	virtual void video_start() override;
	DECLARE_PALETTE_INIT(astrocde);
	DECLARE_VIDEO_START(profpac);
	DECLARE_PALETTE_INIT(profpac);
	uint32_t screen_update_astrocde(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	uint32_t screen_update_profpac(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
	TIMER_CALLBACK_MEMBER(scanline_callback);
	inline int mame_vpos_to_astrocade_vpos(int scanline);
	void init_savestate();
	void astrocade_trigger_lightpen(uint8_t vfeedback, uint8_t hfeedback);
	inline void increment_source(uint8_t curwidth, uint8_t *u13ff);
	inline void increment_dest(uint8_t curwidth);
	void execute_blit();
	void init_sparklestar();
	virtual void machine_start() override;

	DECLARE_WRITE8_MEMBER(votrax_speech_w);
	CUSTOM_INPUT_MEMBER( votrax_speech_status_r );

	void astrocade_base(machine_config &config);
	void astrocade_16color_base(machine_config &config);
	void astrocade_mono_sound(machine_config &config);
	void astrocade_stereo_sound(machine_config &config);
	void spacezap(machine_config &config);
	void gorf(machine_config &config);
	void profpac(machine_config &config);
	void robby(machine_config &config);
	void wow(machine_config &config);
	void bank4000_map(address_map &map);
	void demndrgn_map(address_map &map);
	void port_map(address_map &map);
	void port_map_16col_pattern(address_map &map);
	void port_map_16col_pattern_nosound(address_map &map);
	void port_map_mono_pattern(address_map &map);
	void port_map_stereo_pattern(address_map &map);
	void profpac_bank4000_map(address_map &map);
	void profpac_map(address_map &map);
	void robby_map(address_map &map);
	void seawolf2_map(address_map &map);
	void spacezap_map(address_map &map);
	void wow_map(address_map &map);
protected:
	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
};

class seawolf2_state : public astrocde_state
{
public:
	seawolf2_state(const machine_config &mconfig, device_type type, const char *tag) :
		astrocde_state(mconfig, type, tag),
		m_samples(*this, "samples")
	{ }

	void seawolf2(machine_config &config);
private:
	DECLARE_WRITE8_MEMBER(sound_1_w);
	DECLARE_WRITE8_MEMBER(sound_2_w);

	void port_map_discrete(address_map &map);

	virtual void machine_start() override;

	required_device<samples_device> m_samples;
	uint8_t m_port_1_last;
	uint8_t m_port_2_last;
};

class ebases_state : public astrocde_state
{
public:
	ebases_state(const machine_config &mconfig, device_type type, const char *tag) :
		astrocde_state(mconfig, type, tag),
		m_trackball(*this, {"TRACKX2", "TRACKY2", "TRACKX1", "TRACKY1"})
	{ }

	void ebases(machine_config &config);
	DECLARE_CUSTOM_INPUT_MEMBER(trackball_r);
private:
	DECLARE_WRITE8_MEMBER(trackball_select_w);
	DECLARE_WRITE8_MEMBER(coin_w);

	void ebases_map(address_map &map);
	void port_map_ebases(address_map &map);

	required_ioport_array<4> m_trackball;
};

class demndrgn_state : public astrocde_state
{
public:
	demndrgn_state(const machine_config &mconfig, device_type type, const char *tag)
		: astrocde_state(mconfig, type, tag)
		, m_joystick(*this, {"MOVEX", "MOVEY"})
	{ }

	void demndrgn(machine_config &config);
	DECLARE_CUSTOM_INPUT_MEMBER(joystick_r);
private:
	DECLARE_WRITE_LINE_MEMBER(input_select_w);
	DECLARE_WRITE8_MEMBER(sound_w);

	void port_map_16col_pattern_demndrgn(address_map &map);

	required_ioport_array<2> m_joystick;
};

class tenpindx_state : public astrocde_state
{
public:
	tenpindx_state(const machine_config &mconfig, device_type type, const char *tag) :
		astrocde_state(mconfig, type, tag),
		m_subcpu(*this, "sub"),
		m_lamps(*this, "lamp%u", 0U)
	{ }

	void tenpindx(machine_config &config);
private:
	DECLARE_WRITE8_MEMBER(lamp_w);
	DECLARE_WRITE8_MEMBER(counter_w);
	DECLARE_WRITE8_MEMBER(lights_w);

	virtual void machine_start() override;

	void port_map_16col_pattern_tenpindx(address_map &map);
	void sub_io_map(address_map &map);
	void sub_map(address_map &map);

	required_device<z80_device> m_subcpu;
	output_finder<19> m_lamps;
};

#endif // MAME_INCLUDES_ASTROCDE_H