Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-05 08:41:31 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

midas.cpp, neogeo.cpp, neopcb.cpp, neogeocd.cpp : Remove MCFGs

Browse Source 
midas.cpp : Fix namings, Reduce some runtime tag lookup, Add notes (MCUs in machine config, etc...), Sound output correction
neogeo_spr.cpp : Remove unnecessary device pointer, Convert pointer into region_ptr, Add device_video_interface for screen
bus/neogeo/slot.cpp, bus/neogeo_ctrl/ctrl.cpp : Remove MCFGs
This commit is contained in:
cam900 2019-01-04 18:27:00 +09:00 committed by Vas Crabb
parent 6784650038
commit 879d097198
8 changed files with 525 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/devices/bus/neogeo/slot.h
View File

@ -190,6 +190,15 @@ class neogeo_cart_slot_device : public device_t,
{
public:
// construction/destruction
template <typename T>
neogeo_cart_slot_device(machine_config const &mconfig, char const *tag, device_t *owner, T &&opts, char const *dflt)
: neogeo_cart_slot_device(mconfig, tag, owner, (uint16_t)0)
{
option_reset();
opts(*this);
set_default_option(dflt);
set_fixed(false);
}
neogeo_cart_slot_device(const machine_config &mconfig, const char *tag, device_t *owner, uint16_t clock);
virtual ~neogeo_cart_slot_device();
@ -338,15 +347,4 @@ private:
// device type definition
DECLARE_DEVICE_TYPE(NEOGEO_CART_SLOT, neogeo_cart_slot_device)
/***************************************************************************
DEVICE CONFIGURATION MACROS
***************************************************************************/
#define MCFG_NEOGEO_CARTRIDGE_ADD(_tag,_slot_intf,_def_slot) \
MCFG_DEVICE_ADD(_tag, NEOGEO_CART_SLOT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, false)
#endif // MAME_BUS_NEOGEO_SLOT_H

32
src/devices/bus/neogeo_ctrl/ctrl.h
View File

@ -42,6 +42,15 @@ class neogeo_control_port_device : public device_t, public device_slot_interface
{
public:
// construction/destruction
template <typename T>
neogeo_control_port_device(machine_config const &mconfig, char const *tag, device_t *owner, T &&opts, char const *dflt, bool const fixed)
: neogeo_control_port_device(mconfig, tag, owner, (uint32_t)0)
{
option_reset();
opts(*this);
set_default_option(dflt);
set_fixed(fixed);
}
neogeo_control_port_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual ~neogeo_control_port_device();
@ -83,6 +92,15 @@ class neogeo_ctrl_edge_port_device : public device_t, public device_slot_interfa
{
public:
// construction/destruction
template <typename T>
neogeo_ctrl_edge_port_device(machine_config const &mconfig, char const *tag, device_t *owner, T &&opts, char const *dflt, bool const fixed)
: neogeo_ctrl_edge_port_device(mconfig, tag, owner, (uint32_t)0)
{
option_reset();
opts(*this);
set_default_option(dflt);
set_fixed(fixed);
}
neogeo_ctrl_edge_port_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
virtual ~neogeo_ctrl_edge_port_device();
@ -104,20 +122,6 @@ DECLARE_DEVICE_TYPE(NEOGEO_CONTROL_PORT, neogeo_control_port_device)
DECLARE_DEVICE_TYPE(NEOGEO_CTRL_EDGE_CONNECTOR, neogeo_ctrl_edge_port_device)
//**************************************************************************
// INTERFACE CONFIGURATION MACROS
//**************************************************************************
#define MCFG_NEOGEO_CONTROL_PORT_ADD(_tag, _slot_intf, _def_slot, _fixed) \
MCFG_DEVICE_ADD(_tag, NEOGEO_CONTROL_PORT, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, _fixed)
#define MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD(_tag, _slot_intf, _def_slot, _fixed) \
MCFG_DEVICE_ADD(_tag, NEOGEO_CTRL_EDGE_CONNECTOR, 0) \
MCFG_DEVICE_SLOT_INTERFACE(_slot_intf, _def_slot, _fixed)
void neogeo_controls(device_slot_interface &device);
void neogeo_arc_edge(device_slot_interface &device);
void neogeo_arc_edge_fixed(device_slot_interface &device);

196
src/mame/drivers/midas.cpp
View File

@ -55,6 +55,8 @@
#include "includes/neogeo.h"
#include "cpu/m68000/m68000.h"
#include "cpu/mcs51/mcs51.h"
#include "cpu/pic16c5x/pic16c5x.h"
#include "sound/ymz280b.h"
#include "machine/eepromser.h"
#include "machine/ticket.h"
@ -75,7 +77,8 @@ public:
m_screen(*this, "screen"),
m_prize(*this, "prize%u", 1),
m_ticket(*this, "ticket"),
m_zoomram(*this, "zoomtable")
m_zoomram(*this, "zoomtable"),
m_zoomtable(*this, "spritegen:zoomy")
{ }
void hammer(machine_config &config);
@ -90,15 +93,15 @@ protected:
private:
DECLARE_READ16_MEMBER(ret_ffff);
DECLARE_WRITE16_MEMBER(midas_gfxregs_w);
DECLARE_WRITE16_MEMBER(livequiz_coin_w);
DECLARE_WRITE16_MEMBER(gfxregs_w);
DECLARE_WRITE8_MEMBER(livequiz_coin_w);
DECLARE_READ16_MEMBER(hammer_sensor_r);
DECLARE_WRITE16_MEMBER(hammer_coin_w);
DECLARE_WRITE16_MEMBER(hammer_motor_w);
DECLARE_WRITE16_MEMBER(midas_eeprom_w);
DECLARE_WRITE16_MEMBER(midas_zoomtable_w);
DECLARE_WRITE8_MEMBER(hammer_coin_w);
DECLARE_WRITE8_MEMBER(hammer_motor_w);
DECLARE_WRITE8_MEMBER(eeprom_w);
DECLARE_WRITE16_MEMBER(zoomtable_w);
uint32_t screen_update_midas(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
uint32_t screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
required_device<cpu_device> m_maincpu;
required_device<eeprom_serial_93cxx_device> m_eeprom;
required_device<gfxdecode_device> m_gfxdecode;
@ -108,8 +111,9 @@ private:
optional_device_array<ticket_dispenser_device, 2> m_prize;
optional_device<ticket_dispenser_device> m_ticket;
required_shared_ptr<uint16_t> m_zoomram;
required_region_ptr<uint8_t> m_zoomtable;
DECLARE_WRITE_LINE_MEMBER(screen_vblank_midas);
DECLARE_WRITE_LINE_MEMBER(screen_vblank);
void hammer_map(address_map &map);
void livequiz_map(address_map &map);
@ -122,7 +126,7 @@ void midas_state::video_start()
{
}
uint32_t midas_state::screen_update_midas(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
uint32_t midas_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
// fill with background color first
bitmap.fill(0x0, cliprect);
@ -134,19 +138,16 @@ uint32_t midas_state::screen_update_midas(screen_device &screen, bitmap_rgb32 &b
return 0;
}
WRITE16_MEMBER(midas_state::midas_eeprom_w)
WRITE8_MEMBER(midas_state::eeprom_w)
{
if (ACCESSING_BITS_0_7)
{
// latch the bit
m_eeprom->di_write((data & 0x04) >> 2);
// latch the bit
m_eeprom->di_write((data & 0x04) >> 2);
// reset line asserted: reset.
m_eeprom->cs_write((data & 0x01) ? ASSERT_LINE : CLEAR_LINE );
// reset line asserted: reset.
m_eeprom->cs_write((data & 0x01) ? ASSERT_LINE : CLEAR_LINE );
// clock line asserted: write latch or select next bit to read
m_eeprom->clk_write((data & 0x02) ? ASSERT_LINE : CLEAR_LINE );
}
// clock line asserted: write latch or select next bit to read
m_eeprom->clk_write((data & 0x02) ? ASSERT_LINE : CLEAR_LINE );
}
READ16_MEMBER(midas_state::ret_ffff)
@ -154,7 +155,7 @@ READ16_MEMBER(midas_state::ret_ffff)
return 0xffff;
}
WRITE16_MEMBER(midas_state::midas_gfxregs_w)
WRITE16_MEMBER(midas_state::gfxregs_w)
{
/* accessing the LSB only is not mapped */
if (mem_mask != 0x00ff)
@ -172,15 +173,14 @@ WRITE16_MEMBER(midas_state::midas_gfxregs_w)
}
}
WRITE16_MEMBER(midas_state::midas_zoomtable_w)
WRITE16_MEMBER(midas_state::zoomtable_w)
{
COMBINE_DATA(&m_zoomram[offset]);
uint8_t *rgn = memregion("zoomy")->base();
if (ACCESSING_BITS_0_7)
{
rgn[offset+0x00000] = data & 0xff;
rgn[offset+0x10000] = data & 0xff;
m_zoomtable[offset+0x00000] = data & 0xff;
m_zoomtable[offset+0x10000] = data & 0xff;
}
}
@ -188,12 +188,9 @@ WRITE16_MEMBER(midas_state::midas_zoomtable_w)
Live Quiz Show
***************************************************************************************/
WRITE16_MEMBER(midas_state::livequiz_coin_w)
WRITE8_MEMBER(midas_state::livequiz_coin_w)
{
if (ACCESSING_BITS_0_7)
{
machine().bookkeeping().coin_counter_w(0, data & 0x0001);
}
machine().bookkeeping().coin_counter_w(0, data & 0x0001);
#ifdef MAME_DEBUG
// popmessage("coin %04X", data);
#endif
@ -208,11 +205,11 @@ void midas_state::livequiz_map(address_map &map)
map(0x940000, 0x940001).portr("PLAYER2");
map(0x980000, 0x980001).portr("START");
map(0x980000, 0x980001).w(FUNC(midas_state::livequiz_coin_w));
map(0x980001, 0x980001).w(FUNC(midas_state::livequiz_coin_w));
map(0x9a0000, 0x9a0001).w(FUNC(midas_state::midas_eeprom_w));
map(0x9a0001, 0x9a0001).w(FUNC(midas_state::eeprom_w));
map(0x9c0000, 0x9c0005).w(FUNC(midas_state::midas_gfxregs_w));
map(0x9c0000, 0x9c0005).w(FUNC(midas_state::gfxregs_w));
map(0x9c000c, 0x9c000d).nopw(); // IRQ Ack, temporary
map(0xa00000, 0xa3ffff).ram().w(m_palette, FUNC(palette_device::write16)).share("palette");
@ -228,7 +225,7 @@ void midas_state::livequiz_map(address_map &map)
map(0xba0000, 0xba0001).portr("START3");
map(0xbc0000, 0xbc0001).portr("PLAYER3");
map(0xd00000, 0xd1ffff).ram().w(FUNC(midas_state::midas_zoomtable_w)).share("zoomtable"); // zoom table?
map(0xd00000, 0xd1ffff).ram().w(FUNC(midas_state::zoomtable_w)).share("zoomtable"); // zoom table?
map(0xe00000, 0xe3ffff).ram();
}
@ -245,27 +242,21 @@ READ16_MEMBER(midas_state::hammer_sensor_r)
return (ioport("SENSORY")->read() << 8) | ioport("SENSORX")->read();
}
WRITE16_MEMBER(midas_state::hammer_coin_w)
WRITE8_MEMBER(midas_state::hammer_coin_w)
{
if (ACCESSING_BITS_0_7)
{
machine().bookkeeping().coin_counter_w(0, BIT(data, 0));
machine().bookkeeping().coin_counter_w(1, BIT(data, 1));
}
machine().bookkeeping().coin_counter_w(0, BIT(data, 0));
machine().bookkeeping().coin_counter_w(1, BIT(data, 1));
#ifdef MAME_DEBUG
// popmessage("coin %04X", data);
#endif
}
WRITE16_MEMBER(midas_state::hammer_motor_w)
WRITE8_MEMBER(midas_state::hammer_motor_w)
{
if (ACCESSING_BITS_0_7)
{
m_prize[0]->motor_w(BIT(data, 0));
m_prize[1]->motor_w(BIT(data, 1));
m_ticket->motor_w(BIT(data, 4));
// data & 0x0080 ?
}
m_prize[0]->motor_w(BIT(data, 0));
m_prize[1]->motor_w(BIT(data, 1));
m_ticket->motor_w(BIT(data, 4));
// data & 0x0080 ?
#ifdef MAME_DEBUG
// popmessage("motor %04X", data);
#endif
@ -280,11 +271,11 @@ void midas_state::hammer_map(address_map &map)
map(0x940000, 0x940001).portr("IN0");
map(0x980000, 0x980001).portr("TILT");
map(0x980000, 0x980001).w(FUNC(midas_state::hammer_coin_w));
map(0x980001, 0x980001).w(FUNC(midas_state::hammer_coin_w));
map(0x9a0000, 0x9a0001).w(FUNC(midas_state::midas_eeprom_w));
map(0x9a0001, 0x9a0001).w(FUNC(midas_state::eeprom_w));
map(0x9c0000, 0x9c0005).w(FUNC(midas_state::midas_gfxregs_w));
map(0x9c0000, 0x9c0005).w(FUNC(midas_state::gfxregs_w));
map(0x9c000c, 0x9c000d).nopw(); // IRQ Ack, temporary
map(0xa00000, 0xa3ffff).ram().w(m_palette, FUNC(palette_device::write16)).share("palette");
@ -300,11 +291,11 @@ void midas_state::hammer_map(address_map &map)
map(0xba0000, 0xba0001).portr("IN1");
map(0xbc0000, 0xbc0001).portr("HAMMER");
map(0xbc0002, 0xbc0003).w(FUNC(midas_state::hammer_motor_w));
map(0xbc0003, 0xbc0003).w(FUNC(midas_state::hammer_motor_w));
map(0xbc0004, 0xbc0005).r(FUNC(midas_state::hammer_sensor_r));
map(0xd00000, 0xd1ffff).ram().w(FUNC(midas_state::midas_zoomtable_w)).share("zoomtable"); // zoom table?
map(0xd00000, 0xd1ffff).ram().w(FUNC(midas_state::zoomtable_w)).share("zoomtable"); // zoom table?
map(0xe00000, 0xe3ffff).ram();
}
@ -614,7 +605,6 @@ INPUT_PORTS_END
void midas_state::machine_start()
{
m_sprgen->set_pens(m_palette->pens());
m_sprgen->set_screen(m_screen);
m_sprgen->set_sprite_region(memregion("sprites")->base(), memregion("sprites")->bytes());
m_sprgen->set_fixed_regions(memregion("tiles")->base(), memregion("tiles")->bytes(), memregion("tiles"));
m_sprgen->neogeo_set_fixed_layer_source(0); // temporary: ensure banking is disabled
@ -624,29 +614,35 @@ void midas_state::machine_reset()
{
}
WRITE_LINE_MEMBER(midas_state::screen_vblank_midas)
WRITE_LINE_MEMBER(midas_state::screen_vblank)
{
if (state) m_sprgen->buffer_vram();
}
MACHINE_CONFIG_START(midas_state::livequiz)
void midas_state::livequiz(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", M68000, XTAL(24'000'000) / 2)
MCFG_DEVICE_PROGRAM_MAP(livequiz_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", midas_state, irq1_line_hold)
M68000(config, m_maincpu, XTAL(24'000'000) / 2);
m_maincpu->set_addrmap(AS_PROGRAM, &midas_state::livequiz_map);
m_maincpu->set_vblank_int("screen", FUNC(midas_state::irq1_line_hold));
EEPROM_93C46_16BIT(config, "eeprom");
pic16c56_device &pic1(PIC16C56(config, "pic1", XTAL(24'000'000) / 6)); // !! PIC12C508 !! unknown MHz
pic1.set_disable(); // Currently not hooked up
pic16c56_device &pic2(PIC16C56(config, "pic2", XTAL(24'000'000) / 6)); // !! PIC12C508 !! unknown MHz
pic2.set_disable(); // Currently not hooked up
EEPROM_93C46_16BIT(config, m_eeprom);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(NEOGEO_PIXEL_CLOCK, NEOGEO_HTOTAL, NEOGEO_HBEND, NEOGEO_HBSTART, NEOGEO_VTOTAL, NEOGEO_VBEND, NEOGEO_VBSTART)
MCFG_SCREEN_UPDATE_DRIVER(midas_state, screen_update_midas)
MCFG_SCREEN_VBLANK_CALLBACK(WRITELINE(*this, midas_state, screen_vblank_midas))
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(NEOGEO_PIXEL_CLOCK, NEOGEO_HTOTAL, NEOGEO_HBEND, NEOGEO_HBSTART, NEOGEO_VTOTAL, NEOGEO_VBEND, NEOGEO_VBSTART);
m_screen->set_screen_update(FUNC(midas_state::screen_update));
m_screen->screen_vblank().set(FUNC(midas_state::screen_vblank));
MCFG_DEVICE_ADD("spritegen", NEOGEO_SPRITE_MIDAS, 0)
NEOGEO_SPRITE_MIDAS(config, m_sprgen, 0).set_screen(m_screen);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_midas);
PALETTE(config, m_palette).set_format(palette_device::xRGB_888, 0x10000);
@ -654,42 +650,53 @@ MACHINE_CONFIG_START(midas_state::livequiz)
/* sound hardware */
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();
MCFG_DEVICE_ADD("ymz", YMZ280B, XTAL(16'934'400))
MCFG_SOUND_ROUTE(0, "lspeaker", 0.80)
MCFG_SOUND_ROUTE(1, "rspeaker", 0.80)
MACHINE_CONFIG_END
MACHINE_CONFIG_START(midas_state::hammer)
ymz280b_device &ymz(YMZ280B(config, "ymz", XTAL(16'934'400)));
ymz.add_route(0, "lspeaker", 0.80);
ymz.add_route(1, "rspeaker", 0.80);
}
void midas_state::hammer(machine_config &config)
{
/* basic machine hardware */
MCFG_DEVICE_ADD("maincpu", M68000, XTAL(28'000'000) / 2)
MCFG_DEVICE_PROGRAM_MAP(hammer_map)
MCFG_DEVICE_VBLANK_INT_DRIVER("screen", midas_state, irq1_line_hold)
M68000(config, m_maincpu, XTAL(28'000'000) / 2);
m_maincpu->set_addrmap(AS_PROGRAM, &midas_state::hammer_map);
m_maincpu->set_vblank_int("screen", FUNC(midas_state::irq1_line_hold));
EEPROM_93C46_16BIT(config, "eeprom");
at89c52_device &mcu(AT89C52(config, "mcu", XTAL(24'000'000) / 2)); // on top board, unknown MHz
mcu.set_disable(); // Currently not hooked up
MCFG_TICKET_DISPENSER_ADD("prize1", attotime::from_msec(1000*5), TICKET_MOTOR_ACTIVE_HIGH, TICKET_STATUS_ACTIVE_LOW )
MCFG_TICKET_DISPENSER_ADD("prize2", attotime::from_msec(1000*5), TICKET_MOTOR_ACTIVE_HIGH, TICKET_STATUS_ACTIVE_LOW )
MCFG_TICKET_DISPENSER_ADD("ticket", attotime::from_msec(200), TICKET_MOTOR_ACTIVE_HIGH, TICKET_STATUS_ACTIVE_LOW )
EEPROM_93C46_16BIT(config, m_eeprom);
TICKET_DISPENSER(config, m_prize[0], 0);
m_prize[0]->set_period(attotime::from_msec(1000*5));
m_prize[0]->set_senses(TICKET_MOTOR_ACTIVE_HIGH, TICKET_STATUS_ACTIVE_LOW, false);
TICKET_DISPENSER(config, m_prize[1], 0);
m_prize[1]->set_period(attotime::from_msec(1000*5));
m_prize[1]->set_senses(TICKET_MOTOR_ACTIVE_HIGH, TICKET_STATUS_ACTIVE_LOW, false);
TICKET_DISPENSER(config, m_ticket, 0);
m_ticket->set_period(attotime::from_msec(200));
m_ticket->set_senses(TICKET_MOTOR_ACTIVE_HIGH, TICKET_STATUS_ACTIVE_LOW, false);
/* video hardware */
MCFG_SCREEN_ADD("screen", RASTER)
MCFG_SCREEN_RAW_PARAMS(NEOGEO_PIXEL_CLOCK, NEOGEO_HTOTAL, NEOGEO_HBEND, NEOGEO_HBSTART, NEOGEO_VTOTAL, NEOGEO_VBEND, NEOGEO_VBSTART)
MCFG_SCREEN_UPDATE_DRIVER(midas_state, screen_update_midas)
MCFG_SCREEN_VBLANK_CALLBACK(WRITELINE(*this, midas_state, screen_vblank_midas))
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(NEOGEO_PIXEL_CLOCK, NEOGEO_HTOTAL, NEOGEO_HBEND, NEOGEO_HBSTART, NEOGEO_VTOTAL, NEOGEO_VBEND, NEOGEO_VBSTART);
m_screen->set_screen_update(FUNC(midas_state::screen_update));
m_screen->screen_vblank().set(FUNC(midas_state::screen_vblank));
MCFG_DEVICE_ADD("spritegen", NEOGEO_SPRITE_MIDAS, 0)
NEOGEO_SPRITE_MIDAS(config, m_sprgen, 0).set_screen(m_screen);
GFXDECODE(config, m_gfxdecode, m_palette, gfx_midas);
PALETTE(config, m_palette).set_format(palette_device::xRGB_888, 0x10000);
/* sound hardware */
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();
MCFG_DEVICE_ADD("ymz", YMZ280B, XTAL(16'934'400))
MCFG_SOUND_ROUTE(0, "lspeaker", 0.80)
MCFG_SOUND_ROUTE(1, "rspeaker", 0.80)
MACHINE_CONFIG_END
SPEAKER(config, "mono").front_center(); // stereo outputs aren't exists?
ymz280b_device &ymz(YMZ280B(config, "ymz", XTAL(16'934'400)));
ymz.add_route(ALL_OUTPUTS, "mono", 0.80);
}
/***************************************************************************************
@ -784,8 +791,10 @@ ROM_START( livequiz )
ROM_REGION( 0x200000, "maincpu", 0 )
ROM_LOAD16_WORD_SWAP( "flash.u1", 0x000000, 0x200000, CRC(8ec44493) SHA1(a987886cb87ac0a744f01f2e4a7cc6d12efeaa04) )
ROM_REGION( 0x200000, "pic", 0 )
ROM_REGION( 0x000800, "pic1", 0 )
ROM_LOAD( "main_pic12c508a.u27", 0x000000, 0x000400, CRC(a84f0a7e) SHA1(fb27c05fb27b98ca603697e1be214dc6c8d5f884) )
ROM_REGION( 0x000800, "pic2", 0 )
ROM_LOAD( "sub_pic12c508a.u4", 0x000000, 0x000400, CRC(e52ebdc4) SHA1(0f3af66b5ea184e49188e74a873699324a3930f1) )
ROM_REGION( 0x800000, "sprites", 0 )
@ -800,7 +809,7 @@ ROM_START( livequiz )
ROM_REGION( 0x200000, "ymz", 0 )
ROM_LOAD( "flash.u5", 0x000000, 0x200000, CRC(dc062792) SHA1(ec415c918c47ce9d181f014cde317af5717600e4) )
ROM_REGION( 0x20000, "zoomy", ROMREGION_ERASE00 )
ROM_REGION( 0x20000, "spritegen:zoomy", ROMREGION_ERASE00 )
/* uploaded */
ROM_END
@ -874,6 +883,9 @@ ROM_START( hammer )
ROM_REGION( 0x200000, "maincpu", 0 )
ROM_LOAD16_WORD_SWAP( "p.u22", 0x000000, 0x200000, CRC(687f1596) SHA1(3dc5fb0af1e8c4f3a42ce4aad39635b1111831d8) )
ROM_REGION( 0x002000, "mcu", 0 )
ROM_LOAD( "hammer_at89c52", 0x000000, 0x002000, NO_DUMP )
ROM_REGION( 0x1000000, "sprites", 0 )
ROM_LOAD64_WORD( "a0l.u44", 0x000000, 0x200000, CRC(b9cafd81) SHA1(24698970d1aea0907e2963c872ce61077f44c3af) )
ROM_LOAD64_WORD( "a0h.u46", 0x800000, 0x200000, CRC(f60f188b) SHA1(486f26c473b46efb402662b2f374e361cd7b4284) )
@ -895,7 +907,7 @@ ROM_START( hammer )
ROM_LOAD( "s0.u25", 0x000000, 0x200000, CRC(c049a3e0) SHA1(0c7016c3128c170a84ad3f92fad1165775210e3d) )
ROM_LOAD( "s1.u26", 0x200000, 0x200000, CRC(9cc4b3ec) SHA1(b91a8747074a1032eb7f70a015d394fe8e896d7e) )
ROM_REGION( 0x20000, "zoomy", ROMREGION_ERASE00 )
ROM_REGION( 0x20000, "spritegen:zoomy", ROMREGION_ERASE00 )
/* uploaded */
ROM_END

668
src/mame/drivers/neogeo.cpp
View File

@ -572,6 +572,8 @@ public:
}
// mainboard configurations
void cartslot_config(machine_config &config, int no);
void cartslot_fixed(machine_config &config, char const *dflt);
void mv1fz(machine_config &config);
// fixed software configurations
@ -1591,7 +1593,6 @@ void mvs_state::machine_start()
ngarcade_base_state::machine_start();
m_sprgen->m_fixed_layer_bank_type = 0;
m_sprgen->set_screen(m_screen);
m_curr_slot = -1;
set_slot_idx(0);
@ -1907,8 +1908,8 @@ INPUT_CHANGED_MEMBER(aes_base_state::aes_jp1)
*
*************************************/
MACHINE_CONFIG_START(neogeo_base_state::neogeo_base)
void neogeo_base_state::neogeo_base(machine_config &config)
{
/* basic machine hardware */
M68000(config, m_maincpu, NEOGEO_MAIN_CPU_CLOCK);
@ -1927,14 +1928,14 @@ MACHINE_CONFIG_START(neogeo_base_state::neogeo_base)
/* video hardware */
config.set_default_layout(layout_neogeo);
MCFG_SCREEN_ADD(m_screen, RASTER)
MCFG_SCREEN_RAW_PARAMS(NEOGEO_PIXEL_CLOCK, NEOGEO_HTOTAL, NEOGEO_HBEND, NEOGEO_HBSTART, NEOGEO_VTOTAL, NEOGEO_VBEND, NEOGEO_VBSTART)
MCFG_SCREEN_UPDATE_DRIVER(neogeo_base_state, screen_update)
SCREEN(config, m_screen, SCREEN_TYPE_RASTER);
m_screen->set_raw(NEOGEO_PIXEL_CLOCK, NEOGEO_HTOTAL, NEOGEO_HBEND, NEOGEO_HBSTART, NEOGEO_VTOTAL, NEOGEO_VBEND, NEOGEO_VBSTART);
m_screen->set_screen_update(FUNC(neogeo_base_state::screen_update));
/* 4096 colors * two banks * normal and shadow */
MCFG_DEVICE_ADD(m_palette, PALETTE, palette_device::BLACK, 4096*2*2)
PALETTE(config, m_palette, palette_device::BLACK, 4096*2*2);
MCFG_DEVICE_ADD(m_sprgen, NEOGEO_SPRITE_OPTIMZIED, 0)
NEOGEO_SPRITE_OPTIMZIED(config, m_sprgen, 0).set_screen(m_screen);
/* audio hardware */
INPUT_MERGER_ALL_HIGH(config, m_audionmi);
@ -1948,10 +1949,11 @@ MACHINE_CONFIG_START(neogeo_base_state::neogeo_base)
YM2610(config, m_ym, NEOGEO_YM2610_CLOCK);
m_ym->irq_handler().set_inputline(m_audiocpu, 0);
MACHINE_CONFIG_END
}
MACHINE_CONFIG_START(neogeo_base_state::neogeo_stereo)
void neogeo_base_state::neogeo_stereo(machine_config &config)
{
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();
@ -1959,7 +1961,7 @@ MACHINE_CONFIG_START(neogeo_base_state::neogeo_stereo)
m_ym->add_route(0, "rspeaker", 0.28);
m_ym->add_route(1, "lspeaker", 0.98);
m_ym->add_route(2, "rspeaker", 0.98);
MACHINE_CONFIG_END
}
void ngarcade_base_state::neogeo_arcade(machine_config &config)
@ -1979,134 +1981,131 @@ void ngarcade_base_state::neogeo_arcade(machine_config &config)
}
MACHINE_CONFIG_START(ngarcade_base_state::neogeo_mono)
void ngarcade_base_state::neogeo_mono(machine_config &config)
{
SPEAKER(config, "speaker").front_center();
m_ym->add_route(0, "speaker", 0.28);
m_ym->add_route(1, "speaker", 0.49);
m_ym->add_route(2, "speaker", 0.49);
MACHINE_CONFIG_END
}
// configurable slot
#define NEOGEO_CONFIG_CARTSLOT(_tag) \
MCFG_NEOGEO_CARTRIDGE_ADD(_tag, neogeo_cart, nullptr)
void mvs_state::cartslot_config(machine_config &config, int no)
{
for (int i = 0; i < no; i++)
{
NEOGEO_CART_SLOT(config, m_slots[i], neogeo_cart, nullptr);
}
}
// non-configurable slot (to be used for non-softlist sets, until we introduce some 'template' concept)
// a single cart in slot 1, with pre-defined cart type
#define NEOGEO_CONFIG_ONE_FIXED_CARTSLOT(_default) \
MCFG_NEOGEO_CARTRIDGE_ADD("cslot1", neogeo_cart, _default) \
MCFG_SET_IMAGE_LOADABLE(false)
MACHINE_CONFIG_START(mvs_led_state::mv1)
void mvs_led_state::mv1(machine_config &config)
{
neogeo_arcade(config);
neogeo_stereo(config);
NG_MEMCARD(config, m_memcard, 0);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", false)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", false);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", false);
NEOGEO_CONFIG_CARTSLOT("cslot1")
cartslot_config(config, 1);
MCFG_SOFTWARE_LIST_ADD("cart_list", "neogeo")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM);
}
MACHINE_CONFIG_START(mvs_led_state::mv1f)
void mvs_led_state::mv1f(machine_config &config)
{
neogeo_arcade(config);
neogeo_stereo(config);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", false)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", false);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", false);
NEOGEO_CONFIG_CARTSLOT("cslot1")
cartslot_config(config, 1);
MCFG_SOFTWARE_LIST_ADD("cart_list", "neogeo")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM);
}
MACHINE_CONFIG_START(mvs_state::mv1fz)
void mvs_state::mv1fz(machine_config &config)
{
neogeo_arcade(config);
neogeo_mono(config);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", false)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", false);
NEOGEO_CONFIG_CARTSLOT("cslot1")
cartslot_config(config, 1);
MCFG_SOFTWARE_LIST_ADD("cart_list", "neogeo")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM);
}
MACHINE_CONFIG_START(mvs_led_el_state::mv2f)
void mvs_led_el_state::mv2f(machine_config &config)
{
neogeo_arcade(config);
neogeo_stereo(config);
NG_MEMCARD(config, m_memcard, 0);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", false)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", false);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", false);
NEOGEO_CONFIG_CARTSLOT("cslot1")
NEOGEO_CONFIG_CARTSLOT("cslot2")
cartslot_config(config, 2);
MCFG_SOFTWARE_LIST_ADD("cart_list", "neogeo")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM);
}
MACHINE_CONFIG_START(mvs_led_el_state::mv4f)
void mvs_led_el_state::mv4f(machine_config &config)
{
neogeo_arcade(config);
neogeo_stereo(config);
NG_MEMCARD(config, m_memcard, 0);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", false)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", false);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", false);
NEOGEO_CONFIG_CARTSLOT("cslot1")
NEOGEO_CONFIG_CARTSLOT("cslot2")
NEOGEO_CONFIG_CARTSLOT("cslot3")
NEOGEO_CONFIG_CARTSLOT("cslot4")
cartslot_config(config, 4);
MCFG_SOFTWARE_LIST_ADD("cart_list", "neogeo")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM);
}
MACHINE_CONFIG_START(mvs_led_el_state::mv6f)
void mvs_led_el_state::mv6f(machine_config &config)
{
neogeo_arcade(config);
neogeo_stereo(config);
NG_MEMCARD(config, m_memcard, 0);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", false)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", false);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", false);
NEOGEO_CONFIG_CARTSLOT("cslot1")
NEOGEO_CONFIG_CARTSLOT("cslot2")
NEOGEO_CONFIG_CARTSLOT("cslot3")
NEOGEO_CONFIG_CARTSLOT("cslot4")
NEOGEO_CONFIG_CARTSLOT("cslot5")
NEOGEO_CONFIG_CARTSLOT("cslot6")
cartslot_config(config, 6);
MCFG_SOFTWARE_LIST_ADD("cart_list", "neogeo")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM);
}
MACHINE_CONFIG_START(mvs_led_state::mv1_fixed)
void mvs_led_state::mv1_fixed(machine_config &config)
{
neogeo_arcade(config);
neogeo_stereo(config);
NG_MEMCARD(config, m_memcard, 0);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", true)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", true);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "", true)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", true)
MACHINE_CONFIG_END
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "", true);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", true);
}
@ -2115,7 +2114,6 @@ void aes_base_state::machine_start()
neogeo_base_state::machine_start();
m_sprgen->m_fixed_layer_bank_type = 0;
m_sprgen->set_screen(m_screen);
}
void aes_state::machine_start()
@ -2138,7 +2136,8 @@ void aes_state::device_post_load()
}
MACHINE_CONFIG_START(aes_state::aes)
void aes_state::aes(machine_config &config)
{
neogeo_base(config);
neogeo_stereo(config);
@ -2146,14 +2145,13 @@ MACHINE_CONFIG_START(aes_state::aes)
NG_MEMCARD(config, m_memcard, 0);
MCFG_NEOGEO_CARTRIDGE_ADD("cslot1", neogeo_cart, nullptr)
NEOGEO_CART_SLOT(config, m_slots[0], neogeo_cart, nullptr);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_controls, "joy", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_controls, "joy", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_controls, "joy", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_controls, "joy", false);
MCFG_SOFTWARE_LIST_ADD("cart_list","neogeo")
MCFG_SOFTWARE_LIST_FILTER("cart_list","AES")
MACHINE_CONFIG_END
SOFTWARE_LIST(config, "cart_list").set_type("neogeo", SOFTWARE_LIST_ORIGINAL_SYSTEM).set_filter("AES");
}
@ -2353,7 +2351,7 @@ MACHINE_CONFIG_END
ROM_Y_ZOOM
#define ROM_Y_ZOOM \
ROM_REGION( 0x20000, "zoomy", 0 ) \
ROM_REGION( 0x20000, "spritegen:zoomy", 0 ) \
ROM_LOAD( "000-lo.lo", 0x00000, 0x20000, CRC(5a86cff2) SHA1(5992277debadeb64d1c1c64b0a92d9293eaf7e4a) )
@ -2400,7 +2398,7 @@ ROM_START( aes )
ROM_REGION( 0x90000, "audiocpu", ROMREGION_ERASEFF )
ROM_REGION( 0x20000, "zoomy", 0 )
ROM_REGION( 0x20000, "spritegen:zoomy", 0 )
ROM_LOAD( "000-lo.lo", 0x00000, 0x20000, CRC(5a86cff2) SHA1(5992277debadeb64d1c1c64b0a92d9293eaf7e4a) )
ROM_REGION( 0x20000, "fixed", ROMREGION_ERASEFF )
@ -2424,373 +2422,439 @@ CONS( 1990, aes, 0, 0, aes, aes, aes_state, e
// non-configurable slot (to be used for non-softlist sets, until we introduce some 'template' concept)
// a single cart in slot 1, with pre-defined cart type
#define NEOGEO_CONFIG_ONE_FIXED_CARTSLOT(_default) \
MCFG_NEOGEO_CARTRIDGE_ADD("cslot1", neogeo_cart, _default) \
MCFG_SET_IMAGE_LOADABLE(false)
void mvs_state::cartslot_fixed(machine_config &config, char const *dflt)
{
NEOGEO_CART_SLOT(config, m_slots[0], neogeo_cart, dflt).set_user_loadable(false);
}
// machine config for one-game fixed config, loaded without using softlists
MACHINE_CONFIG_START(mvs_led_state::neobase)
void mvs_led_state::neobase(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom");
}
// used by fatfury2 & ssideki
MACHINE_CONFIG_START(mvs_led_state::fatfur2)
void mvs_led_state::fatfur2(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom_fatfur2")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom_fatfur2");
}
MACHINE_CONFIG_START(mvs_state::kizuna4p)
void mvs_state::kizuna4p(machine_config &config)
{
neogeo_arcade(config);
neogeo_mono(config);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge_fixed, "kiz4p", true)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge_fixed, "kiz4p", true);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom");
}
MACHINE_CONFIG_START(mvs_led_state::kof97oro)
void mvs_led_state::kof97oro(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kof97oro")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kof97oro");
}
MACHINE_CONFIG_START(mvs_led_state::kog)
void mvs_led_state::kog(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kog")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kog");
}
MACHINE_CONFIG_START(mvs_state::irrmaze)
void mvs_state::irrmaze(machine_config &config)
{
neogeo_arcade(config);
neogeo_mono(config);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge_fixed, "irrmaze", true)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge_fixed, "irrmaze", true);
config.set_default_layout(layout_irrmaze);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom");
}
MACHINE_CONFIG_START(mvs_led_state::kof98)
void mvs_led_state::kof98(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom_kof98")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom_kof98");
}
MACHINE_CONFIG_START(mvs_led_state::mslugx)
void mvs_led_state::mslugx(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom_mslugx")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom_mslugx");
}
MACHINE_CONFIG_START(mvs_led_state::kof99)
void mvs_led_state::kof99(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("sma_kof99")
MACHINE_CONFIG_END
cartslot_fixed(config, "sma_kof99");
}
MACHINE_CONFIG_START(mvs_led_state::kof99k)
void mvs_led_state::kof99k(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_kof99k")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_kof99k");
}
MACHINE_CONFIG_START(mvs_led_state::garou)
void mvs_led_state::garou(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("sma_garou")
MACHINE_CONFIG_END
cartslot_fixed(config, "sma_garou");
}
MACHINE_CONFIG_START(mvs_led_state::garouh)
void mvs_led_state::garouh(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("sma_garouh")
MACHINE_CONFIG_END
cartslot_fixed(config, "sma_garouh");
}
MACHINE_CONFIG_START(mvs_led_state::garoubl)
void mvs_led_state::garoubl(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_garoubl")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_garoubl");
}
MACHINE_CONFIG_START(mvs_led_state::mslug3)
void mvs_led_state::mslug3(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("sma_mslug3")
MACHINE_CONFIG_END
cartslot_fixed(config, "sma_mslug3");
}
MACHINE_CONFIG_START(mvs_led_state::mslug3a)
void mvs_led_state::mslug3a(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("sma_mslug3a")
MACHINE_CONFIG_END
cartslot_fixed(config, "sma_mslug3a");
}
MACHINE_CONFIG_START(mvs_led_state::mslug3h)
void mvs_led_state::mslug3h(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_mslug3h")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_mslug3h");
}
MACHINE_CONFIG_START(mvs_led_state::mslug3b6)
void mvs_led_state::mslug3b6(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_mslug3b6")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_mslug3b6");
}
MACHINE_CONFIG_START(mvs_led_state::kof2000)
void mvs_led_state::kof2000(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("sma_kof2k")
MACHINE_CONFIG_END
cartslot_fixed(config, "sma_kof2k");
}
MACHINE_CONFIG_START(mvs_led_state::kof2000n)
void mvs_led_state::kof2000n(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc50_kof2000n")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc50_kof2000n");
}
MACHINE_CONFIG_START(mvs_led_state::zupapa)
void mvs_led_state::zupapa(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_zupapa")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_zupapa");
}
MACHINE_CONFIG_START(mvs_led_state::sengoku3)
void mvs_led_state::sengoku3(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_sengoku3")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_sengoku3");
}
MACHINE_CONFIG_START(mvs_led_state::kof2001)
void mvs_led_state::kof2001(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc50_kof2001")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc50_kof2001");
}
MACHINE_CONFIG_START(mvs_led_state::cthd2k3)
void mvs_led_state::cthd2k3(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_cthd2k3")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_cthd2k3");
}
MACHINE_CONFIG_START(mvs_led_state::ct2k3sp)
void mvs_led_state::ct2k3sp(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_ct2k3sp")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_ct2k3sp");
}
MACHINE_CONFIG_START(mvs_led_state::ct2k3sa)
void mvs_led_state::ct2k3sa(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_ct2k3sa")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_ct2k3sa");
}
MACHINE_CONFIG_START(mvs_led_state::kof2002)
void mvs_led_state::kof2002(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("k2k2_kof2k2")
MACHINE_CONFIG_END
cartslot_fixed(config, "k2k2_kof2k2");
}
MACHINE_CONFIG_START(mvs_led_state::kof2002b)
void mvs_led_state::kof2002b(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k2b")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k2b");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k2pls)
void mvs_led_state::kf2k2pls(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("k2k2_kf2k2p")
MACHINE_CONFIG_END
cartslot_fixed(config, "k2k2_kf2k2p");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k2mp)
void mvs_led_state::kf2k2mp(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k2mp")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k2mp");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k2mp2)
void mvs_led_state::kf2k2mp2(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k2mp2")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k2mp2");
}
MACHINE_CONFIG_START(mvs_led_state::kof10th)
void mvs_led_state::kof10th(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf10th")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf10th");
}
MACHINE_CONFIG_START(mvs_led_state::kf10thep)
void mvs_led_state::kf10thep(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf10thep")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf10thep");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k5uni)
void mvs_led_state::kf2k5uni(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k5uni")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k5uni");
}
MACHINE_CONFIG_START(mvs_led_state::kof2k4se)
void mvs_led_state::kof2k4se(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k4se")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k4se");
}
MACHINE_CONFIG_START(mvs_led_state::mslug5)
void mvs_led_state::mslug5(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pvc_mslug5")
MACHINE_CONFIG_END
cartslot_fixed(config, "pvc_mslug5");
}
MACHINE_CONFIG_START(mvs_led_state::ms5plus)
void mvs_led_state::ms5plus(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_ms5plus")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_ms5plus");
}
MACHINE_CONFIG_START(mvs_led_state::svc)
void mvs_led_state::svc(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pvc_svc")
MACHINE_CONFIG_END
cartslot_fixed(config, "pvc_svc");
}
MACHINE_CONFIG_START(mvs_led_state::svcboot)
void mvs_led_state::svcboot(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_svcboot")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_svcboot");
}
MACHINE_CONFIG_START(mvs_led_state::svcplus)
void mvs_led_state::svcplus(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_svcplus")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_svcplus");
}
MACHINE_CONFIG_START(mvs_led_state::svcplusa)
void mvs_led_state::svcplusa(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_svcplusa")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_svcplusa");
}
MACHINE_CONFIG_START(mvs_led_state::svcsplus)
void mvs_led_state::svcsplus(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_svcsplus")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_svcsplus");
}
MACHINE_CONFIG_START(mvs_led_state::samsho5)
void mvs_led_state::samsho5(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("k2k2_samsh5")
MACHINE_CONFIG_END
cartslot_fixed(config, "k2k2_samsh5");
}
MACHINE_CONFIG_START(mvs_led_state::samsho5b)
void mvs_led_state::samsho5b(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_samsho5b")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_samsho5b");
}
MACHINE_CONFIG_START(mvs_led_state::kof2003)
void mvs_led_state::kof2003(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pvc_kf2k3")
MACHINE_CONFIG_END
cartslot_fixed(config, "pvc_kf2k3");
}
MACHINE_CONFIG_START(mvs_led_state::kof2003h)
void mvs_led_state::kof2003h(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pvc_kf2k3h")
MACHINE_CONFIG_END
cartslot_fixed(config, "pvc_kf2k3h");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k3bl)
void mvs_led_state::kf2k3bl(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k3bl")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k3bl");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k3pl)
void mvs_led_state::kf2k3pl(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k3pl")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k3pl");
}
MACHINE_CONFIG_START(mvs_led_state::kf2k3upl)
void mvs_led_state::kf2k3upl(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_kf2k3upl")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_kf2k3upl");
}
MACHINE_CONFIG_START(mvs_led_state::samsh5sp)
void mvs_led_state::samsh5sp(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("k2k2_sams5s")
MACHINE_CONFIG_END
cartslot_fixed(config, "k2k2_sams5s");
}
MACHINE_CONFIG_START(mvs_led_state::neogeo_mj)
void mvs_led_state::neogeo_mj(machine_config &config)
{
mv1_fixed(config);
set_default_bios_tag("japan");
//no joystick panel
MCFG_DEVICE_REMOVE("edge")
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "", false)
config.device_remove("edge");
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "", false);
//P1 mahjong controller
MCFG_DEVICE_REMOVE("ctrl1")
MCFG_DEVICE_REMOVE("ctrl2")
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_arc_pin15, "mahjong", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_arc_pin15, "", true)
config.device_remove("ctrl1");
config.device_remove("ctrl2");
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_arc_pin15, "mahjong", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_arc_pin15, "", true);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom");
}
MACHINE_CONFIG_START(mvs_led_state::preisle2)
void mvs_led_state::preisle2(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_preisle2")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_preisle2");
}
MACHINE_CONFIG_START(mvs_led_state::nitd)
void mvs_led_state::nitd(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_nitd")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_nitd");
}
MACHINE_CONFIG_START(mvs_led_state::s1945p)
void mvs_led_state::s1945p(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_s1945p")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_s1945p");
}
MACHINE_CONFIG_START(mvs_led_state::lans2004)
void mvs_led_state::lans2004(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_lans2004")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_lans2004");
}
MACHINE_CONFIG_START(mvs_led_state::pnyaa)
void mvs_led_state::pnyaa(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pcm2_pnyaa")
MACHINE_CONFIG_END
cartslot_fixed(config, "pcm2_pnyaa");
}
MACHINE_CONFIG_START(mvs_led_state::popbounc)
void mvs_led_state::popbounc(machine_config &config)
{
mv1_fixed(config);
MCFG_DEVICE_REMOVE("edge")
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge_fixed, "dial", true)
config.device_remove("edge");
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge_fixed, "dial", true);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom");
}
MACHINE_CONFIG_START(mvs_led_state::ganryu)
void mvs_led_state::ganryu(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_ganryu")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_ganryu");
}
MACHINE_CONFIG_START(mvs_led_state::bangbead)
void mvs_led_state::bangbead(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc42_bangbead")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc42_bangbead");
}
MACHINE_CONFIG_START(mvs_led_state::mslug4)
void mvs_led_state::mslug4(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pcm2_mslug4")
MACHINE_CONFIG_END
cartslot_fixed(config, "pcm2_mslug4");
}
MACHINE_CONFIG_START(mvs_led_state::ms4plus)
void mvs_led_state::ms4plus(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pcm2_ms4p")
MACHINE_CONFIG_END
cartslot_fixed(config, "pcm2_ms4p");
}
MACHINE_CONFIG_START(mvs_led_state::rotd)
void mvs_led_state::rotd(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("pcm2_rotd")
MACHINE_CONFIG_END
cartslot_fixed(config, "pcm2_rotd");
}
MACHINE_CONFIG_START(mvs_led_state::matrim)
void mvs_led_state::matrim(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("k2k2_matrim")
MACHINE_CONFIG_END
cartslot_fixed(config, "k2k2_matrim");
}
MACHINE_CONFIG_START(mvs_led_state::matrimbl)
void mvs_led_state::matrimbl(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_matrimbl")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_matrimbl");
}
MACHINE_CONFIG_START(mvs_led_state::jockeygp)
void mvs_led_state::jockeygp(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("cmc50_jockeygp")
MACHINE_CONFIG_END
cartslot_fixed(config, "cmc50_jockeygp");
}
MACHINE_CONFIG_START(mvs_led_state::vliner)
void mvs_led_state::vliner(machine_config &config)
{
mv1_fixed(config);
// input handlers are installed at DRIVER_INIT...
MCFG_DEVICE_REMOVE("edge")
MCFG_DEVICE_REMOVE("ctrl1")
MCFG_DEVICE_REMOVE("ctrl2")
config.device_remove("edge");
config.device_remove("ctrl1");
config.device_remove("ctrl2");
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("rom_vliner")
MACHINE_CONFIG_END
cartslot_fixed(config, "rom_vliner");
}
MACHINE_CONFIG_START(mvs_led_state::sbp)
void mvs_led_state::sbp(machine_config &config)
{
mv1_fixed(config);
NEOGEO_CONFIG_ONE_FIXED_CARTSLOT("boot_sbp")
MACHINE_CONFIG_END
cartslot_fixed(config, "boot_sbp");
}
@ -11740,7 +11804,7 @@ GAME( 1999, garoubl, garou, garoubl, neogeo, mvs_led_state, empty_ini
GAME( 2000, mslug3, neogeo, mslug3, neogeo, mvs_led_state, empty_init, ROT0, "SNK", "Metal Slug 3 (NGM-2560)" , MACHINE_SUPPORTS_SAVE ) /* Encrypted Code & GFX */
GAME( 2000, mslug3a, mslug3, mslug3a, neogeo, mvs_led_state, empty_init, ROT0, "SNK", "Metal Slug 3 (NGM-2560, earlier)" , MACHINE_SUPPORTS_SAVE ) /* Encrypted Code & GFX - revision Mar/17/2000 1:36 (from SMA rom) */
GAME( 2000, mslug3h, mslug3, mslug3h, neogeo, mvs_led_state, empty_init, ROT0, "SNK", "Metal Slug 3 (NGH-2560)" , MACHINE_SUPPORTS_SAVE ) /* Encrypted GFX */
GAME( 2000, mslug3b6, mslug3, mslug3b6, neogeo, mvs_led_state, empty_init, ROT0, "bootleg", "Metal Slug 6 (Metal Slug 3 bootleg)", MACHINE_SUPPORTS_SAVE ) /* real Metal Slug 6 is an Atomiswave HW game, see naomi.c ;-) */
GAME( 2000, mslug3b6, mslug3, mslug3b6, neogeo, mvs_led_state, empty_init, ROT0, "bootleg", "Metal Slug 6 (Metal Slug 3 bootleg)", MACHINE_SUPPORTS_SAVE ) /* real Metal Slug 6 is an Atomiswave HW game, see naomi.cpp ;-) */
GAME( 2000, kof2000, neogeo, kof2000, neogeo, mvs_led_state, empty_init, ROT0, "SNK", "The King of Fighters 2000 (NGM-2570 ~ NGH-2570)" , MACHINE_SUPPORTS_SAVE ) /* Encrypted Code & GFX */
GAME( 2000, kof2000n, kof2000, kof2000n, neogeo, mvs_led_state, empty_init, ROT0, "SNK", "The King of Fighters 2000 (not encrypted)" , MACHINE_SUPPORTS_SAVE ) /* Encrypted GFX */
GAME( 2001, zupapa, neogeo, zupapa, neogeo, mvs_led_state, empty_init, ROT0, "SNK", "Zupapa!" , MACHINE_SUPPORTS_SAVE ) /* Encrypted GFX */

21
src/mame/drivers/neogeocd.cpp
View File

@ -1033,7 +1033,8 @@ uint32_t ngcd_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap,
}
MACHINE_CONFIG_START(ngcd_state::neocd)
void ngcd_state::neocd(machine_config &config)
{
neogeo_base(config);
neogeo_stereo(config);
@ -1045,8 +1046,7 @@ MACHINE_CONFIG_START(ngcd_state::neocd)
subdevice<hc259_device>("systemlatch")->q_out_cb<1>().set_log("NeoCD: write to regular vector change address?"); // what IS going on with "neocdz doubledr" and why do games write here if it's hooked up to nothing?
MCFG_SCREEN_MODIFY("screen")
MCFG_SCREEN_UPDATE_DRIVER(ngcd_state, screen_update)
m_screen->set_screen_update(FUNC(ngcd_state::screen_update));
// temporary until things are cleaned up
LC89510_TEMP(config, m_tempcdc, 0); // cd controller
@ -1057,15 +1057,14 @@ MACHINE_CONFIG_START(ngcd_state::neocd)
NVRAM(config, "saveram", nvram_device::DEFAULT_ALL_0);
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl1", neogeo_controls, "joy", false)
MCFG_NEOGEO_CONTROL_PORT_ADD("ctrl2", neogeo_controls, "joy", false)
NEOGEO_CONTROL_PORT(config, m_ctrl1, neogeo_controls, "joy", false);
NEOGEO_CONTROL_PORT(config, m_ctrl2, neogeo_controls, "joy", false);
MCFG_CDROM_ADD( "cdrom" )
MCFG_CDROM_INTERFACE("neocd_cdrom")
MCFG_SOFTWARE_LIST_ADD("cd_list","neocd")
CDROM(config, "cdrom").set_interface("neocd_cdrom");
SOFTWARE_LIST(config, "cd_list").set_type("neocd", SOFTWARE_LIST_ORIGINAL_SYSTEM);
m_ym->set_addrmap(0, &ngcd_state::neocd_ym_map);
MACHINE_CONFIG_END
}
@ -1087,7 +1086,7 @@ ROM_START( neocd )
ROM_REGION( 0x200000, "maincpu", ROMREGION_ERASE00 )
/* 2MB of 68K RAM */
ROM_REGION( 0x20000, "zoomy", 0 )
ROM_REGION( 0x20000, "spritegen:zoomy", 0 )
ROM_LOAD( "000-lo.lo", 0x00000, 0x20000, CRC(5a86cff2) SHA1(5992277debadeb64d1c1c64b0a92d9293eaf7e4a) )
ROM_END
@ -1101,7 +1100,7 @@ ROM_START( neocdz )
ROM_REGION( 0x200000, "maincpu", ROMREGION_ERASE00 )
/* 2MB of 68K RAM */
ROM_REGION( 0x20000, "zoomy", 0 )
ROM_REGION( 0x20000, "spritegen:zoomy", 0 )
ROM_LOAD( "000-lo.lo", 0x00000, 0x20000, CRC(5a86cff2) SHA1(5992277debadeb64d1c1c64b0a92d9293eaf7e4a) )
ROM_END

15
src/mame/drivers/neopcb.cpp
View File

@ -69,16 +69,17 @@ void neopcb_state::device_post_load()
membank("cpu_bank")->set_base(m_region_maincpu->base() + m_bank_base);
}
MACHINE_CONFIG_START(neopcb_state::neopcb)
void neopcb_state::neopcb(machine_config &config)
{
neogeo_arcade(config);
neogeo_mono(config);
MCFG_NEOGEO_CONTROL_EDGE_CONNECTOR_ADD("edge", neogeo_arc_edge, "joy", true)
NEOGEO_CTRL_EDGE_CONNECTOR(config, m_edge, neogeo_arc_edge, "joy", true);
MCFG_CMC_PROT_ADD("cmc50")
MCFG_PCM2_PROT_ADD("pcm2")
MCFG_PVC_PROT_ADD("pvc")
MACHINE_CONFIG_END
NG_CMC_PROT(config, "cmc50", 0);
NG_PCM2_PROT(config, "pcm2", 0);
NG_PVC_PROT(config, "pvc", 0);
}
// Game specific input definitions
@ -106,7 +107,7 @@ INPUT_PORTS_END
*************************************/
#define ROM_Y_ZOOM \
ROM_REGION( 0x20000, "zoomy", 0 ) \
ROM_REGION( 0x20000, "spritegen:zoomy", 0 ) \
ROM_LOAD( "000-lo.lo", 0x00000, 0x20000, CRC(5a86cff2) SHA1(5992277debadeb64d1c1c64b0a92d9293eaf7e4a) )

20
src/mame/video/neogeo_spr.cpp
View File

@ -18,7 +18,9 @@ neosprite_base_device::neosprite_base_device(
device_t *owner,
uint32_t clock)
: device_t(mconfig, type, tag, owner, clock)
, device_video_interface(mconfig, *this)
, m_bppshift(4)
, m_region_zoomy(*this, "zoomy")
{
}
@ -53,9 +55,6 @@ void neosprite_base_device::device_start()
save_item(NAME(m_auto_animation_disabled));
save_item(NAME(m_auto_animation_counter));
save_item(NAME(m_auto_animation_frame_counter));
m_region_zoomy = memregion(":zoomy")->base();
}
void neosprite_base_device::device_reset()
@ -146,7 +145,7 @@ TIMER_CALLBACK_MEMBER(neosprite_base_device::auto_animation_timer_callback)
else
m_auto_animation_frame_counter = m_auto_animation_frame_counter - 1;
m_auto_animation_timer->adjust(m_screen->time_until_pos(NEOGEO_VSSTART));
m_auto_animation_timer->adjust(screen().time_until_pos(NEOGEO_VSSTART));
}
@ -158,7 +157,7 @@ void neosprite_base_device::create_auto_animation_timer()
void neosprite_base_device::start_auto_animation_timer()
{
m_auto_animation_timer->adjust(m_screen->time_until_pos(NEOGEO_VSSTART));
m_auto_animation_timer->adjust(screen().time_until_pos(NEOGEO_VSSTART));
}
@ -524,14 +523,14 @@ TIMER_CALLBACK_MEMBER(neosprite_base_device::sprite_line_timer_callback)
/* we are at the beginning of a scanline -
we need to draw the previous scanline and parse the sprites on the current one */
if (scanline != 0)
m_screen->update_partial(scanline - 1);
screen().update_partial(scanline - 1);
parse_sprites(scanline);
/* let's come back at the beginning of the next line */
scanline = (scanline + 1) % NEOGEO_VTOTAL;
m_sprite_line_timer->adjust(m_screen->time_until_pos(scanline), scanline);
m_sprite_line_timer->adjust(screen().time_until_pos(scanline), scanline);
}
@ -543,7 +542,7 @@ void neosprite_base_device::create_sprite_line_timer()
void neosprite_base_device::start_sprite_line_timer()
{
m_sprite_line_timer->adjust(m_screen->time_until_pos(0));
m_sprite_line_timer->adjust(screen().time_until_pos(0));
}
@ -598,11 +597,6 @@ void neosprite_base_device::set_fixed_regions(uint8_t* fix_cart, uint32_t fix_ca
m_region_fixedbios = fix_bios;
}
void neosprite_base_device::set_screen(screen_device* screen)
{
m_screen = screen;
}
void neosprite_base_device::set_pens(const pen_t* pens)
{
m_pens = pens;

8
src/mame/video/neogeo_spr.h
View File

@ -21,7 +21,7 @@
#define NEOGEO_VSSTART (0x100)
// todo, sort out what needs to be public and make the rest private/protected
class neosprite_base_device : public device_t
class neosprite_base_device : public device_t, public device_video_interface
{
public:
virtual void optimize_sprite_data();
@ -48,7 +48,6 @@ public:
void start_sprite_line_timer();
virtual void set_sprite_region(uint8_t* region_sprites, uint32_t region_sprites_size);
void set_fixed_regions(uint8_t* fix_cart, uint32_t fix_cart_size, memory_region* fix_bios);
void set_screen(screen_device* screen);
void set_pens(const pen_t* pens);
std::unique_ptr<uint16_t[]> m_videoram;
@ -58,8 +57,6 @@ public:
uint16_t m_vram_read_buffer;
uint16_t m_vram_modulo;
const uint8_t *m_region_zoomy;
uint32_t m_sprite_gfx_address_mask;
uint8_t m_auto_animation_speed;
@ -92,8 +89,9 @@ protected:
uint8_t* m_region_sprites; uint32_t m_region_sprites_size;
uint8_t* m_region_fixed; uint32_t m_region_fixed_size;
memory_region* m_region_fixedbios;
screen_device* m_screen;
const pen_t *m_pens;
required_region_ptr<uint8_t> m_region_zoomy;
};