void osd_init(running_machine *machine)
{
//add_exit_callback(machine, osd_exit);
machine->add_notifier(MACHINE_NOTIFY_EXIT, osd_exit);
our_target = render_target_alloc(machine, NULL, 0);
if (our_target == NULL)
fatalerror("Error creating render target");
myosd_inGame = !(machine->gamedrv == &GAME_NAME(empty));
options_set_bool(mame_options(), OPTION_CHEAT,myosd_cheat,OPTION_PRIORITY_CMDLINE);
options_set_bool(mame_options(), OPTION_AUTOSAVE,myosd_autosave,OPTION_PRIORITY_CMDLINE);
options_set_bool(mame_options(), OPTION_SOUND,myosd_sound_value != -1,OPTION_PRIORITY_CMDLINE);
if(myosd_sound_value!=-1)
options_set_int(mame_options(), OPTION_SAMPLERATE,myosd_sound_value,OPTION_PRIORITY_CMDLINE);
options_set_float(mame_options(), OPTION_BEAM,myosd_vector_bean2x ? 2.5 : 1.0, OPTION_PRIORITY_CMDLINE);
options_set_float(mame_options(), OPTION_FLICKER,myosd_vector_flicker ? 0.4 : 0.0, OPTION_PRIORITY_CMDLINE);
options_set_bool(mame_options(), OPTION_ANTIALIAS,myosd_vector_antialias,OPTION_PRIORITY_CMDLINE);
droid_ios_init_input(machine);
droid_ios_init_sound(machine);
droid_ios_init_video(machine);
netplay_t *handle = netplay_get_handle();
if(handle->has_connection)
{
handle->has_begun_game = 1;
}
}
void osd_init(running_machine *machine)
{
//add_exit_callback(machine, osd_exit);
machine->add_notifier(MACHINE_NOTIFY_EXIT, osd_exit);
our_target = render_target_alloc(machine, NULL, 0);
if (our_target == NULL)
fatalerror("Error creating render target");
myosd_inGame = !(machine->gamedrv == &GAME_NAME(empty));
options_set_bool(mame_options(), OPTION_CHEAT,myosd_cheat,OPTION_PRIORITY_CMDLINE);
options_set_bool(mame_options(), OPTION_AUTOSAVE,myosd_autosave,OPTION_PRIORITY_CMDLINE);
options_set_bool(mame_options(), OPTION_SOUND,myosd_sound_value != -1,OPTION_PRIORITY_CMDLINE);
if(myosd_sound_value!=-1)
options_set_int(mame_options(), OPTION_SAMPLERATE,myosd_sound_value,OPTION_PRIORITY_CMDLINE);
droid_ios_init_input(machine);
droid_ios_init_sound(machine);
droid_ios_init_video(machine);
}
int machine_manager::execute()
{
bool started_empty = false;
bool firstgame = true;
bool firstrun = true;
// loop across multiple hard resets
bool exit_pending = false;
int error = MAMERR_NONE;
if (m_options.console()) {
m_lua->start_console();
}
while (error == MAMERR_NONE && !exit_pending)
{
m_new_driver_pending = nullptr;
// if no driver, use the internal empty driver
const game_driver *system = m_options.system();
if (system == nullptr)
{
system = &GAME_NAME(___empty);
if (firstgame)
started_empty = true;
}
firstgame = false;
// parse any INI files as the first thing
if (m_options.read_config())
{
m_options.revert(OPTION_PRIORITY_INI);
std::string errors;
m_options.parse_standard_inis(errors);
}
// otherwise, perform validity checks before anything else
if (system != nullptr)
{
validity_checker valid(m_options);
valid.set_verbose(false);
valid.check_shared_source(*system);
}
// create the machine configuration
machine_config config(*system, m_options);
// create the machine structure and driver
running_machine machine(config, *this);
set_machine(&machine);
// run the machine
error = machine.run(firstrun);
firstrun = false;
// check the state of the machine
if (m_new_driver_pending)
{
std::string old_system_name(m_options.system_name());
bool new_system = (old_system_name.compare(m_new_driver_pending->name)!=0);
// first: if we scheduled a new system, remove device options of the old system
// notice that, if we relaunch the same system, there is no effect on the emulation
if (new_system)
m_options.remove_device_options();
// second: set up new system name (and the related device options)
m_options.set_system_name(m_new_driver_pending->name);
// third: if we scheduled a new system, take also care of ramsize options
if (new_system)
{
std::string error_string;
m_options.set_value(OPTION_RAMSIZE, "", OPTION_PRIORITY_CMDLINE, error_string);
}
firstrun = true;
if (m_options.software_name())
{
std::string sw_load(m_options.software_name());
std::string sw_list, sw_name, sw_part, sw_instance, option_errors, error_string;
int left = sw_load.find_first_of(':');
int middle = sw_load.find_first_of(':', left + 1);
int right = sw_load.find_last_of(':');
sw_list = sw_load.substr(0, left - 1);
sw_name = sw_load.substr(left + 1, middle - left - 1);
sw_part = sw_load.substr(middle + 1, right - middle - 1);
sw_instance = sw_load.substr(right + 1);
sw_load.assign(sw_load.substr(0, right));
char arg[] = "ume";
char *argv = &arg[0];
m_options.set_value(OPTION_SOFTWARENAME, sw_name.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
m_options.parse_slot_devices(1, &argv, option_errors, sw_instance.c_str(), sw_load.c_str());
}
}
else
{
if (machine.exit_pending()) m_options.set_system_name("");
}
if (machine.exit_pending() && (!started_empty || (system == &GAME_NAME(___empty))))
exit_pending = true;
// machine will go away when we exit scope
set_machine(nullptr);
}
// return an error
return error;
}
int mame_execute(emu_options &options, osd_interface &osd)
{
bool firstgame = true;
bool firstrun = true;
// extract the verbose printing option
if (options.verbose())
print_verbose = true;
// loop across multiple hard resets
bool exit_pending = false;
int error = MAMERR_NONE;
while (error == MAMERR_NONE && !exit_pending)
{
// if no driver, use the internal empty driver
const game_driver *system = options.system();
if (system == NULL)
{
system = &GAME_NAME(___empty);
if (firstgame)
started_empty = true;
}
// otherwise, perform validity checks before anything else
else
validate_drivers(options, system);
firstgame = false;
// parse any INI files as the first thing
if (options.read_config())
{
options.revert(OPTION_PRIORITY_INI);
astring errors;
options.parse_standard_inis(errors);
}
// create the machine configuration
machine_config config(*system, options);
// create the machine structure and driver
running_machine machine(config, osd, started_empty);
// looooong term: remove this
global_machine = &machine;
// run the machine
error = machine.run(firstrun);
firstrun = false;
// check the state of the machine
if (machine.new_driver_pending())
{
options.set_system_name(machine.new_driver_name());
firstrun = true;
}
if (machine.exit_pending())
exit_pending = true;
// machine will go away when we exit scope
global_machine = NULL;
}
// return an error
return error;
}
int machine_manager::execute()
{
bool started_empty = false;
bool firstgame = true;
bool firstrun = true;
// loop across multiple hard resets
bool exit_pending = false;
int error = MAMERR_NONE;
m_lua.initialize();
if (m_options.console()) {
m_lua.start_console();
}
while (error == MAMERR_NONE && !exit_pending)
{
m_new_driver_pending = NULL;
// if no driver, use the internal empty driver
const game_driver *system = m_options.system();
if (system == NULL)
{
system = &GAME_NAME(___empty);
if (firstgame)
started_empty = true;
}
firstgame = false;
// parse any INI files as the first thing
if (m_options.read_config())
{
m_options.revert(OPTION_PRIORITY_INI);
astring errors;
m_options.parse_standard_inis(errors);
}
// otherwise, perform validity checks before anything else
if (system != NULL)
{
validity_checker valid(m_options);
valid.check_shared_source(*system);
}
// create the machine configuration
machine_config config(*system, m_options);
//Set up client/server as appropriate
if(m_options.client())
{
deleteGlobalClient();
createGlobalClient(m_options.username());
}
else if(m_options.server())
{
deleteGlobalServer();
createGlobalServer(m_options.username(),
(unsigned short)m_options.port(),
m_options.baseDelay(),
m_options.rollback());
netServer->setSyncTransferTime(m_options.syncTransferSeconds());
}
// create the machine structure and driver
running_machine machine(config, *this);
set_machine(&machine);
// run the machine
error = machine.run(firstrun);
firstrun = false;
deleteGlobalClient();
deleteGlobalServer();
// check the state of the machine
if (m_new_driver_pending)
{
astring old_system_name(m_options.system_name());
bool new_system = (old_system_name != m_new_driver_pending->name);
// first: if we scheduled a new system, remove device options of the old system
// notice that, if we relaunch the same system, there is no effect on the emulation
if (new_system)
m_options.remove_device_options();
// second: set up new system name (and the related device options)
m_options.set_system_name(m_new_driver_pending->name);
// third: if we scheduled a new system, take also care of ramsize options
if (new_system)
{
astring error_string;
m_options.set_value(OPTION_RAMSIZE, "", OPTION_PRIORITY_CMDLINE, error_string);
}
firstrun = true;
}
else
{
if (machine.exit_pending()) m_options.set_system_name("");
}
if (machine.exit_pending() && (!started_empty || (system == &GAME_NAME(___empty))))
exit_pending = true;
// machine will go away when we exit scope
set_machine(NULL);
}
// return an error
return error;
}
void driver_switch::assign_drivers(emu_options &opts)
{
static const struct
{
const char *name;
const game_driver * const *driver;
} drivers_table[] =
{
#ifndef TINY_BUILD
{ "mame", mamedrivers },
{ "plus", mameplusdrivers },
{ "homebrew", mamehbdrivers },
{ "decrypted", mamedecrypteddrivers },
#ifdef MAMEMESS
{ "console", messdrivers },
#endif /* MAMEMESS */
#else
{ "mame", tinydrivers },
#endif /* !TINY_BUILD */
{ NULL }
};
UINT32 enabled = 0;
int i, n;
bool mechanical = opts.bool_value(OPTION_DISABLE_MECHANICAL_DRIVER);
#ifndef TINY_BUILD
const char *drv_option = opts.value(OPTION_DRIVER_CONFIG);
if (drv_option)
{
char *temp = mame_strdup(drv_option);
if (temp)
{
char *p = strtok(temp, ",");
while (p)
{
char *s = core_strtrim(p); //get individual driver name
if (s[0])
{
if (mame_stricmp(s, "all") == 0)
{
enabled = (UINT32)-1;
break;
}
for (i = 0; drivers_table[i].name; i++)
if (mame_stricmp(s, drivers_table[i].name) == 0)
{
enabled |= 1 << i;
break;
}
if (!drivers_table[i].name)
mame_printf_warning(_("Illegal value for %s = %s\n"), OPTION_DRIVER_CONFIG, s);
}
osd_free(s);
p = strtok(NULL, ",");
}
osd_free(temp);
}
}
#endif /* !TINY_BUILD */
if (enabled == 0)
enabled = 1; // default to mamedrivers
n = 0;
for (i = 0; drivers_table[i].name; i++)
if (enabled & (1 << i))
{
for (int c = 0; drivers_table[i].driver[c]; c++)
if (mame_stricmp(drivers_table[i].driver[c]->name, "___empty"))
if (!mechanical || !(drivers_table[i].driver[c]->flags & GAME_MECHANICAL))
driver_list::s_drivers_sorted[n++] = drivers_table[i].driver[c];
}
// ___empty driver add once
driver_list::s_drivers_sorted[n++] = &GAME_NAME(___empty);
driver_list::s_driver_count = n;
qsort(driver_list::s_drivers_sorted, n, sizeof(*driver_list::s_drivers_sorted), driver_list::driver_sort_callback);
}
void driver_switch::init_assign_drivers(void)
{
//direct change protected member
driver_list::s_drivers_sorted[0] = &GAME_NAME(___empty);
driver_list::s_driver_count = 1;
}
int mame_execute(emu_options &options, osd_interface &osd)
{
bool firstgame = true;
bool firstrun = true;
// extract the verbose printing option
if (options.verbose())
print_verbose = true;
// loop across multiple hard resets
bool exit_pending = false;
int error = MAMERR_NONE;
// We need to preprocess the config files once to determine the web server's configuration
if (options.read_config())
{
options.revert(OPTION_PRIORITY_INI);
astring errors;
options.parse_standard_inis(errors);
}
web_engine web(options);
while (error == MAMERR_NONE && !exit_pending)
{
// if no driver, use the internal empty driver
const game_driver *system = options.system();
if (system == NULL)
{
system = &GAME_NAME(___empty);
if (firstgame)
started_empty = true;
}
firstgame = false;
// parse any INI files as the first thing
if (options.read_config())
{
options.revert(OPTION_PRIORITY_INI);
astring errors;
options.parse_standard_inis(errors);
}
// otherwise, perform validity checks before anything else
if (system != NULL)
{
validity_checker valid(options);
valid.check_shared_source(*system);
}
// create the machine configuration
machine_config config(*system, options);
// create the machine structure and driver
running_machine machine(config, osd, started_empty);
ui_show_mouse(machine.system().flags & GAME_CLICKABLE_ARTWORK);
// looooong term: remove this
global_machine = &machine;
web.set_machine(machine);
web.push_message("update_machine");
// run the machine
error = machine.run(firstrun);
firstrun = false;
// check the state of the machine
if (machine.new_driver_pending())
{
options.set_system_name(machine.new_driver_name());
firstrun = true;
}
if (machine.exit_pending())
exit_pending = true;
// machine will go away when we exit scope
global_machine = NULL;
}
// return an error
return error;
}
int mame_machine_manager::execute()
{
bool started_empty = false;
bool firstgame = true;
bool firstrun = true;
// loop across multiple hard resets
bool exit_pending = false;
int error = EMU_ERR_NONE;
if (m_options.console()) {
m_lua->start_console();
}
while (error == EMU_ERR_NONE && !exit_pending)
{
m_new_driver_pending = nullptr;
// if no driver, use the internal empty driver
const game_driver *system = m_options.system();
if (system == nullptr)
{
system = &GAME_NAME(___empty);
if (firstgame)
started_empty = true;
}
firstgame = false;
// parse any INI files as the first thing
if (m_options.read_config())
{
m_options.revert(OPTION_PRIORITY_INI);
std::string errors;
mame_options::parse_standard_inis(m_options,errors);
}
// otherwise, perform validity checks before anything else
if (system != nullptr)
{
validity_checker valid(m_options);
valid.set_verbose(false);
valid.check_shared_source(*system);
}
// create the machine configuration
machine_config config(*system, m_options);
// create the machine structure and driver
running_machine machine(config, *this);
set_machine(&machine);
// run the machine
error = machine.run(firstrun);
firstrun = false;
// check the state of the machine
if (m_new_driver_pending)
{
// set up new system name and adjust device options accordingly
mame_options::set_system_name(m_options,m_new_driver_pending->name);
firstrun = true;
}
else
{
if (machine.exit_pending()) mame_options::set_system_name(m_options,"");
}
if (machine.exit_pending() && (!started_empty || (system == &GAME_NAME(___empty))))
exit_pending = true;
// machine will go away when we exit scope
set_machine(nullptr);
}
// return an error
return error;
}
void media_identifier::match_hashes(std::vector<file_info> &info)
{
std::unordered_set<std::string> listnames;
// iterate over drivers
m_drivlist.reset();
while (m_drivlist.next())
{
// iterate over regions and files within the region
device_t &device = m_drivlist.config()->root_device();
for (romload::region const ®ion : romload::entries(device.rom_region()).get_regions())
{
for (romload::file const &rom : region.get_files())
{
util::hash_collection const romhashes(rom.get_hashdata());
if (!romhashes.flag(util::hash_collection::FLAG_NO_DUMP))
{
for (file_info &file : info)
file.match(device, rom, romhashes);
}
}
}
// next iterate over softlists
for (software_list_device &swlistdev : software_list_device_iterator(device))
{
if (listnames.insert(swlistdev.list_name()).second)
{
for (software_info const &swinfo : swlistdev.get_info())
{
for (software_part const &part : swinfo.parts())
{
for (rom_entry const *region = part.romdata().data(); region; region = rom_next_region(region))
{
for (rom_entry const *rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
util::hash_collection romhashes(ROM_GETHASHDATA(rom));
if (!romhashes.flag(util::hash_collection::FLAG_NO_DUMP))
{
for (file_info &file : info)
file.match(swlistdev.list_name(), swinfo, *rom, romhashes);
}
}
}
}
}
}
}
}
// iterator over devices
machine_config config(GAME_NAME(___empty), m_drivlist.options());
for (device_type type : registered_device_types)
{
// iterate over regions and files within the region
device_t *const device = config.device_add(&config.root_device(), "_tmp", type, 0);
for (romload::region const ®ion : romload::entries(device->rom_region()).get_regions())
{
for (romload::file const &rom : region.get_files())
{
util::hash_collection const romhashes(rom.get_hashdata());
if (!romhashes.flag(util::hash_collection::FLAG_NO_DUMP))
{
for (file_info &file : info)
file.match(*device, rom, romhashes);
}
}
}
config.device_remove(&config.root_device(), "_tmp");
}
}