static INT_PTR CALLBACK AuditWindowProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
static HANDLE hThread;
static DWORD dwThreadID;
DWORD dwExitCode;
HWND hEdit;
switch (Msg)
{
case WM_INITDIALOG:
hAudit = hDlg;
//RS 20030613 Set Bkg of RichEdit Ctrl
hEdit = GetDlgItem(hAudit, IDC_AUDIT_DETAILS);
if (hEdit != NULL)
SendMessage( hEdit, EM_SETBKGNDCOLOR, FALSE, GetSysColor(COLOR_BTNFACE) );
SendDlgItemMessage(hDlg, IDC_ROMS_PROGRESS, PBM_SETRANGE, 0, MAKELPARAM(0, GetNumGames()));
SendDlgItemMessage(hDlg, IDC_SAMPLES_PROGRESS, PBM_SETRANGE, 0, MAKELPARAM(0, GetNumGames()));
bPaused = FALSE;
bCancel = FALSE;
rom_index = 0;
hThread = CreateThread(NULL, 0, AuditThreadProc, hDlg, 0, &dwThreadID);
return 1;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDCANCEL:
bPaused = FALSE;
if (hThread)
{
bCancel = TRUE;
if (GetExitCodeThread(hThread, &dwExitCode) && dwExitCode == STILL_ACTIVE)
{
PostMessage(hDlg, WM_COMMAND, wParam, lParam);
return 1;
}
CloseHandle(hThread);
}
EndDialog(hDlg,0);
break;
case IDPAUSE:
if (bPaused)
{
SendDlgItemMessage(hAudit, IDPAUSE, WM_SETTEXT, 0, (LPARAM)"Pause");
bPaused = FALSE;
}
else
{
SendDlgItemMessage(hAudit, IDPAUSE, WM_SETTEXT, 0, (LPARAM)"Continue");
bPaused = TRUE;
}
break;
}
return 1;
}
return 0;
}
void CreateOrientationFolders(int parent_index)
{
int jj;
int nGames = GetNumGames();
LPTREEFOLDER lpFolder = treeFolders[parent_index];
// create our two subfolders
LPTREEFOLDER lpVert, lpHorz;
lpVert = NewFolder("Vertical", next_folder_id++, parent_index, IDI_FOLDER,
GetFolderFlags(numFolders));
AddFolder(lpVert);
lpHorz = NewFolder("Horizontal", next_folder_id++, parent_index, IDI_FOLDER,
GetFolderFlags(numFolders));
AddFolder(lpHorz);
// no games in top level folder
SetAllBits(lpFolder->m_lpGameBits,FALSE);
for (jj = 0; jj < nGames; jj++)
{
if (drivers[jj]->flags & ORIENTATION_SWAP_XY)
{
AddGame(lpVert,jj);
}
else
{
AddGame(lpHorz,jj);
}
}
}
void CreateSoundFolders(int parent_index)
{
int i,jj;
int nGames = GetNumGames();
int nFolder = numFolders;
LPTREEFOLDER lpFolder = treeFolders[parent_index];
LPTREEFOLDER map[SOUND_COUNT];
// no games in top level folder
SetAllBits(lpFolder->m_lpGameBits,FALSE);
for (i=1;i<SOUND_COUNT;i++)
{
// Defined in sndintrf.c
struct snd_interface
{
unsigned sound_num; /* ID */
const char *name; /* description */
int (*chips_num)(const struct MachineSound *msound); /* returns number of chips if applicable */
int (*chips_clock)(const struct MachineSound *msound); /* returns chips clock if applicable */
int (*start)(const struct MachineSound *msound); /* starts sound emulation */
void (*stop)(void); /* stops sound emulation */
void (*update)(void); /* updates emulation once per frame if necessary */
void (*reset)(void); /* resets sound emulation */
};
extern struct snd_interface sndintf[];
LPTREEFOLDER lpTemp;
for (jj = 1; jj < i; jj++)
if (!strcmp(soundtype_name(i), soundtype_name(jj)))
break;
if (i != jj)
{
map[i] = map[jj];
continue;
}
lpTemp = NewFolder(sndintf[i].name, next_folder_id++, parent_index, IDI_CPU,
GetFolderFlags(numFolders));
AddFolder(lpTemp);
map[i] = treeFolders[nFolder++];
}
for (jj = 0; jj < nGames; jj++)
{
int n;
struct InternalMachineDriver drv;
expand_machine_driver(drivers[jj]->drv,&drv);
for (n = 0; n < MAX_SOUND; n++)
if (drv.sound[n].sound_type != SOUND_DUMMY)
{
// sound type #'s are one-based
AddGame(map[drv.sound[n].sound_type],jj);
}
}
}
/* Allocate and initialize a NEW TREEFOLDER */
static LPTREEFOLDER NewFolder(const char *lpTitle,
UINT nFolderId, int nParent, UINT nIconId, DWORD dwFlags)
{
LPTREEFOLDER lpFolder = (LPTREEFOLDER)malloc(sizeof(TREEFOLDER));
memset(lpFolder, '\0', sizeof (TREEFOLDER));
lpFolder->m_lpTitle = (LPSTR)malloc(strlen(lpTitle) + 1);
strcpy((char *)lpFolder->m_lpTitle,lpTitle);
lpFolder->m_lpGameBits = NewBits(GetNumGames());
lpFolder->m_nFolderId = nFolderId;
lpFolder->m_nParent = nParent;
lpFolder->m_nIconId = nIconId;
lpFolder->m_dwFlags = dwFlags;
return lpFolder;
}
void CreateCPUFolders(int parent_index)
{
int i,jj;
int nGames = GetNumGames();
int nFolder = numFolders;
LPTREEFOLDER lpFolder = treeFolders[parent_index];
LPTREEFOLDER map[CPU_COUNT];
// no games in top level folder
SetAllBits(lpFolder->m_lpGameBits,FALSE);
for (i=1;i<CPU_COUNT;i++)
{
LPTREEFOLDER lpTemp;
for (jj = 1; jj < i; jj++)
if (!strcmp(cputype_name(i), cputype_name(jj)))
break;
if (i != jj)
{
map[i] = map[jj];
continue;
}
lpTemp = NewFolder(cputype_name(i), next_folder_id++, parent_index, IDI_CPU,
GetFolderFlags(numFolders));
AddFolder(lpTemp);
map[i] = treeFolders[nFolder++];
}
for (jj = 0; jj < nGames; jj++)
{
int n;
struct InternalMachineDriver drv;
expand_machine_driver(drivers[jj]->drv,&drv);
for (n = 0; n < MAX_CPU; n++)
if (drv.cpu[n].cpu_type != CPU_DUMMY)
{
// cpu type #'s are one-based
AddGame(map[drv.cpu[n].cpu_type],jj);
}
}
}
void CreateManufacturerFolders(int parent_index)
{
int i,jj;
int nGames = GetNumGames();
int start_folder = numFolders;
LPTREEFOLDER lpFolder = treeFolders[parent_index];
// not sure why this is added separately
// should find out at some point.
LPTREEFOLDER lpTemp;
lpTemp = NewFolder("Romstar", next_folder_id++, parent_index, IDI_MANUFACTURER,
GetFolderFlags(numFolders));
AddFolder(lpTemp);
// no games in top level folder
SetAllBits(lpFolder->m_lpGameBits,FALSE);
for (jj = 0; jj < nGames; jj++)
{
const char *s = FixString(drivers[jj]->manufacturer);
const char *s2 = LicenseManufacturer(drivers[jj]->manufacturer);
if (s == NULL || s[0] == '\0')
continue;
// look for an extant manufacturer treefolder for this game
for (i=numFolders-1;i>=start_folder;i--)
{
if (strncmp(treeFolders[i]->m_lpTitle,s,20) == 0 ||
(s2 != NULL && strncmp(treeFolders[i]->m_lpTitle,s2,20) == 0))
{
AddGame(treeFolders[i],jj);
break;
}
}
if (i == start_folder-1)
{
// nope, it's a manufacturer we haven't seen before, make it.
lpTemp = NewFolder(s, next_folder_id++, parent_index, IDI_MANUFACTURER,
GetFolderFlags(numFolders));
AddFolder(lpTemp);
AddGame(lpTemp,jj);
}
}
}
static void ProcessNextSample()
{
int retval;
char buffer[200];
retval = Mame32VerifySampleSet(sample_index);
switch (retval)
{
case CORRECT:
if (DriverUsesSamples(sample_index))
{
samples_correct++;
sprintf(buffer, "%i", samples_correct);
SendDlgItemMessage(hAudit, IDC_SAMPLES_CORRECT, WM_SETTEXT, 0, (LPARAM)buffer);
sprintf(buffer, "%i", samples_correct + samples_incorrect);
SendDlgItemMessage(hAudit, IDC_SAMPLES_TOTAL, WM_SETTEXT, 0, (LPARAM)buffer);
break;
}
case NOTFOUND:
break;
case INCORRECT:
samples_incorrect++;
sprintf(buffer, "%i", samples_incorrect);
SendDlgItemMessage(hAudit, IDC_SAMPLES_INCORRECT, WM_SETTEXT, 0, (LPARAM)buffer);
sprintf(buffer, "%i", samples_correct + samples_incorrect);
SendDlgItemMessage(hAudit, IDC_SAMPLES_TOTAL, WM_SETTEXT, 0, (LPARAM)buffer);
break;
}
sample_index++;
SendDlgItemMessage(hAudit, IDC_SAMPLES_PROGRESS, PBM_SETPOS, sample_index, 0);
if (sample_index == GetNumGames())
{
DetailsPrintf("Audit complete.\n");
SendDlgItemMessage(hAudit, IDCANCEL, WM_SETTEXT, 0, (LPARAM)"Close");
sample_index = -1;
}
}
void CreateYearFolders(int parent_index)
{
int i,jj;
int nGames = GetNumGames();
int start_folder = numFolders;
LPTREEFOLDER lpFolder = treeFolders[parent_index];
// no games in top level folder
SetAllBits(lpFolder->m_lpGameBits,FALSE);
for (jj = 0; jj < nGames; jj++)
{
char s[100];
strcpy(s,drivers[jj]->year);
if (s[0] == '\0')
continue;
if (s[4] == '?')
s[4] = '\0';
// look for an extant year treefolder for this game
// (likely to be the previous one, so start at the end)
for (i=numFolders-1;i>=start_folder;i--)
{
if (strncmp(treeFolders[i]->m_lpTitle,s,4) == 0)
{
AddGame(treeFolders[i],jj);
break;
}
}
if (i == start_folder-1)
{
// nope, it's a year we haven't seen before, make it.
LPTREEFOLDER lpTemp;
lpTemp = NewFolder(s, next_folder_id++, parent_index, IDI_YEAR,
GetFolderFlags(numFolders));
AddFolder(lpTemp);
AddGame(lpTemp,jj);
}
}
}
static void ProcessNextRom()
{
int retval;
char buffer[200];
retval = Mame32VerifyRomSet(rom_index);
switch (retval)
{
case BEST_AVAILABLE: /* correct, incorrect or separate count? */
case CORRECT:
case MISSING_OPTIONAL:
roms_correct++;
sprintf(buffer, "%i", roms_correct);
SendDlgItemMessage(hAudit, IDC_ROMS_CORRECT, WM_SETTEXT, 0, (LPARAM)buffer);
sprintf(buffer, "%i", roms_correct + roms_incorrect);
SendDlgItemMessage(hAudit, IDC_ROMS_TOTAL, WM_SETTEXT, 0, (LPARAM)buffer);
break;
case NOTFOUND:
break;
case INCORRECT:
roms_incorrect++;
sprintf(buffer, "%i", roms_incorrect);
SendDlgItemMessage(hAudit, IDC_ROMS_INCORRECT, WM_SETTEXT, 0, (LPARAM)buffer);
sprintf(buffer, "%i", roms_correct + roms_incorrect);
SendDlgItemMessage(hAudit, IDC_ROMS_TOTAL, WM_SETTEXT, 0, (LPARAM)buffer);
break;
}
rom_index++;
SendDlgItemMessage(hAudit, IDC_ROMS_PROGRESS, PBM_SETPOS, rom_index, 0);
if (rom_index == GetNumGames())
{
sample_index = 0;
rom_index = -1;
}
}
void CreateSourceFolders(int parent_index)
{
int i,jj;
int nGames = GetNumGames();
int start_folder = numFolders;
LPTREEFOLDER lpFolder = treeFolders[parent_index];
// no games in top level folder
SetAllBits(lpFolder->m_lpGameBits,FALSE);
for (jj = 0; jj < nGames; jj++)
{
const char *s = GetDriverFilename(jj);
if (s == NULL || s[0] == '\0')
continue;
// look for an extant source treefolder for this game
// (likely to be the previous one, so start at the end)
for (i=numFolders-1;i>=start_folder;i--)
{
if (strcmp(treeFolders[i]->m_lpTitle,s) == 0)
{
AddGame(treeFolders[i],jj);
break;
}
}
if (i == start_folder-1)
{
// nope, it's a source file we haven't seen before, make it.
LPTREEFOLDER lpTemp;
lpTemp = NewFolder(s, next_folder_id++, parent_index, IDI_SOURCE,
GetFolderFlags(numFolders));
AddFolder(lpTemp);
AddGame(lpTemp,jj);
}
}
}
// Called to re-associate games with folders
void ResetWhichGamesInFolders(void)
{
UINT i, jj, k;
BOOL b;
int nGames = GetNumGames();
for (i = 0; i < numFolders; i++)
{
LPTREEFOLDER lpFolder = treeFolders[i];
// setup the games in our built-in folders
for (k = 0; g_lpFolderData[k].m_lpTitle; k++)
{
if (lpFolder->m_nFolderId == g_lpFolderData[k].m_nFolderId)
{
if (g_lpFolderData[k].m_pfnQuery || g_lpFolderData[k].m_bExpectedResult)
{
SetAllBits(lpFolder->m_lpGameBits, FALSE);
for (jj = 0; jj < nGames; jj++)
{
// invoke the query function
b = g_lpFolderData[k].m_pfnQuery ? g_lpFolderData[k].m_pfnQuery(jj) : TRUE;
// if we expect FALSE, flip the result
if (!g_lpFolderData[k].m_bExpectedResult)
b = !b;
// if we like what we hear, add the game
if (b)
AddGame(lpFolder, jj);
}
}
break;
}
}
}
}
BOOL TrySaveExtraFolder(LPTREEFOLDER lpFolder)
{
char fname[MAX_PATH];
FILE *fp;
BOOL error = FALSE;
int i,j;
LPTREEFOLDER root_folder = NULL;
LPEXFOLDERDATA extra_folder = NULL;
for (i=0;i<numExtraFolders;i++)
{
if (ExtraFolderData[i]->m_nFolderId == lpFolder->m_nFolderId)
{
root_folder = lpFolder;
extra_folder = ExtraFolderData[i];
break;
}
if (lpFolder->m_nParent >= 0 &&
ExtraFolderData[i]->m_nFolderId == treeFolders[lpFolder->m_nParent]->m_nFolderId)
{
root_folder = treeFolders[lpFolder->m_nParent];
extra_folder = ExtraFolderData[i];
break;
}
}
if (extra_folder == NULL || root_folder == NULL)
{
MessageBox(GetMainWindow(), "Error finding custom file name to save", MAME32NAME, MB_OK | MB_ICONERROR);
return FALSE;
}
/* "folder\title.ini" */
_snprintf( fname, sizeof(fname), "%s\\%s.ini", GetFolderDir(), extra_folder->m_szTitle);
fp = fopen(fname, "wt");
if (fp == NULL)
error = TRUE;
else
{
TREEFOLDER *folder_data;
fprintf(fp,"[FOLDER_SETTINGS]\n");
// negative values for icons means it's custom, so save 'em
if (extra_folder->m_nIconId < 0)
{
fprintf(fp, "RootFolderIcon %s\n",
ExtraFolderIcons[(-extra_folder->m_nIconId) - ICON_MAX]);
}
if (extra_folder->m_nSubIconId < 0)
{
fprintf(fp,"SubFolderIcon %s\n",
ExtraFolderIcons[(-extra_folder->m_nSubIconId) - ICON_MAX]);
}
/* need to loop over all our TREEFOLDERs--first the root one, then each child.
start with the root */
folder_data = root_folder;
fprintf(fp,"\n[ROOT_FOLDER]\n");
for (i=0;i<GetNumGames();i++)
{
int driver_index = GetIndexFromSortedIndex(i);
if (TestBit(folder_data->m_lpGameBits,driver_index))
{
fprintf(fp,"%s\n",drivers[driver_index]->name);
}
}
/* look through the custom folders for ones with our root as parent */
for (j=0;j<numFolders;j++)
{
folder_data = treeFolders[j];
if (folder_data->m_nParent >= 0 &&
treeFolders[folder_data->m_nParent] == root_folder)
{
fprintf(fp,"\n[%s]\n",folder_data->m_lpTitle);
for (i=0;i<GetNumGames();i++)
{
int driver_index = GetIndexFromSortedIndex(i);
if (TestBit(folder_data->m_lpGameBits,driver_index))
{
fprintf(fp,"%s\n",drivers[driver_index]->name);
}
}
}
}
if (fclose(fp) != 0)
error = TRUE;
}
if (error)
{
char buf[500];
_snprintf(buf,sizeof(buf),"Error while saving custom file %s",fname);
MessageBox(GetMainWindow(), buf, MAME32NAME, MB_OK | MB_ICONERROR);
}
return !error;
}
std::string Lobby::ReportState() {
std::string outString;
outString += GetNumGames();
outString += GetGameList();
return outString;
}
static struct DriversInfo* GetDriversInfo(int driver_index)
{
if (drivers_info == NULL)
{
int ndriver;
drivers_info = (DriversInfo*)malloc(sizeof(struct DriversInfo) * GetNumGames());
for (ndriver = 0; ndriver < GetNumGames(); ndriver++)
{
const game_driver *gamedrv = drivers[ndriver];
struct DriversInfo *gameinfo = &drivers_info[ndriver];
const rom_entry *region, *rom;
machine_config *config;
const rom_source *source;
int num_speakers;
/* Allocate machine config */
config = global_alloc(machine_config(gamedrv->machine_config));
gameinfo->isClone = (GetParentRomSetIndex(gamedrv) != -1);
gameinfo->isBroken = ((gamedrv->flags & GAME_NOT_WORKING) != 0);
gameinfo->supportsSaveState = ((gamedrv->flags & GAME_SUPPORTS_SAVE) != 0);
gameinfo->isHarddisk = FALSE;
gameinfo->isVertical = (gamedrv->flags & ORIENTATION_SWAP_XY) ? TRUE : FALSE;
for (source = rom_first_source(gamedrv, config); source != NULL; source = rom_next_source(gamedrv, config, source))
{
for (region = rom_first_region(gamedrv, source); region; region = rom_next_region(region))
{
if (ROMREGION_ISDISKDATA(region))
gameinfo->isHarddisk = TRUE;
}
}
gameinfo->hasOptionalBIOS = FALSE;
if (gamedrv->rom != NULL)
{
for (rom = gamedrv->rom; !ROMENTRY_ISEND(rom); rom++)
{
if (ROMENTRY_ISSYSTEM_BIOS(rom))
{
gameinfo->hasOptionalBIOS = TRUE;
break;
}
}
}
num_speakers = numberOfSpeakers(config);
gameinfo->isStereo = (num_speakers > 1);
gameinfo->screenCount = numberOfScreens(config);
gameinfo->isVector = isDriverVector(config); // ((drv.video_attributes & VIDEO_TYPE_VECTOR) != 0);
gameinfo->usesRoms = FALSE;
for (source = rom_first_source(gamedrv, config); source != NULL; source = rom_next_source(gamedrv, config, source))
{
for (region = rom_first_region(gamedrv, source); region; region = rom_next_region(region))
{
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
gameinfo->usesRoms = TRUE;
break;
}
}
}
gameinfo->usesSamples = FALSE;
{
const device_config_sound_interface *sound;
const char * const * samplenames = NULL;
for (bool gotone = config->m_devicelist.first(sound); gotone; gotone = sound->next(sound)) {
if (sound->devconfig().type() == SOUND_SAMPLES)
{
const samples_interface *intf = (const samples_interface *)sound->devconfig().static_config();
samplenames = intf->samplenames;
if (samplenames != 0 && samplenames[0] != 0)
{
gameinfo->usesSamples = TRUE;
break;
}
}
}
}
gameinfo->numPlayers = 0;
gameinfo->numButtons = 0;
memset(gameinfo->usesController, 0, sizeof gameinfo->usesController);
gameinfo->parentIndex = -1;
if (gameinfo->isClone)
{
int i;
for (i = 0; i < GetNumGames(); i++)
{
if (GetParentRomSetIndex(gamedrv) == i)
{
gameinfo->parentIndex = i;
break;
}
}
}
gameinfo->biosIndex = -1;
if (DriverIsBios(ndriver))
gameinfo->biosIndex = ndriver;
else if (gameinfo->hasOptionalBIOS)
{
int parentIndex;
if (gameinfo->isClone)
parentIndex = gameinfo->parentIndex;
else
parentIndex = ndriver;
while (1)
{
parentIndex = GetGameNameIndex(drivers[parentIndex]->parent);
if (parentIndex == -1)
{
dprintf("bios for %s is not found", drivers[ndriver]->name);
break;
}
if (DriverIsBios(parentIndex))
{
gameinfo->biosIndex = parentIndex;
break;
}
}
}
/* Free the structure */
global_free(config);
gameinfo->usesTrackball = FALSE;
gameinfo->usesLightGun = FALSE;
if (gamedrv->ipt != NULL)
{
const input_port_config *port;
ioport_list portlist;
input_port_list_init(portlist, gamedrv->ipt, NULL, 0, FALSE);
for (port = portlist.first(); port != NULL; port = port->next())
{
const input_field_config *field;
for (field = port->fieldlist; field != NULL; field = field->next)
{
UINT32 type;
type = field->type;
if (type == IPT_END)
break;
if (type == IPT_DIAL || type == IPT_PADDLE ||
type == IPT_TRACKBALL_X || type == IPT_TRACKBALL_Y ||
type == IPT_AD_STICK_X || type == IPT_AD_STICK_Y)
gameinfo->usesTrackball = TRUE;
if (type == IPT_LIGHTGUN_X || type == IPT_LIGHTGUN_Y)
gameinfo->usesLightGun = TRUE;
if (type == IPT_MOUSE_X || type == IPT_MOUSE_Y)
gameinfo->usesMouse = TRUE;
}
}
}
}
UpdateController();
}
return &drivers_info[driver_index];
}
static void UpdateController(void)
{
struct control_cache_t *cache;
const input_port_token *last_ipt = NULL;
BOOL flags[CONTROLLER_MAX];
int nGames = GetNumGames();
int b = 0;
int p = 0;
int i;
cache = (control_cache_t *)malloc(sizeof (*cache) * nGames);
if (cache == NULL)
return;
for (i = 0; i < nGames; i++)
{
cache[i].ipt = (input_port_token *)drivers[i]->ipt;
cache[i].num = i;
}
qsort(cache, nGames, sizeof (*cache), cmp_ipt);
for (i = 0; i < nGames; i++)
{
struct DriversInfo *gameinfo = &drivers_info[cache[i].num];
if (!cache[i].ipt)
continue;
if (cache[i].ipt != last_ipt)
{
const input_port_config *port;
ioport_list portlist;
int w = CONTROLLER_JOY8WAY;
BOOL lr = FALSE;
BOOL ud = FALSE;
BOOL dual = FALSE;
last_ipt = cache[i].ipt;
memset(flags, 0, sizeof flags);
b = 0;
p = 0;
input_port_list_init(portlist, last_ipt, NULL, 0, FALSE);
for (port = portlist.first(); port != NULL; port = port->next())
{
const input_field_config *field;
for (field = port->fieldlist; field != NULL; field = field->next)
{
int n;
if (p < field->player + 1)
p = field->player + 1;
n = field->type - IPT_BUTTON1 + 1;
if (n >= 1 && n <= MAX_NORMAL_BUTTONS && n > b)
{
b = n;
continue;
}
switch (field->type)
{
case IPT_JOYSTICKRIGHT_LEFT:
case IPT_JOYSTICKRIGHT_RIGHT:
case IPT_JOYSTICKLEFT_LEFT:
case IPT_JOYSTICKLEFT_RIGHT:
dual = TRUE;
case IPT_JOYSTICK_LEFT:
case IPT_JOYSTICK_RIGHT:
lr = TRUE;
if (field->way == 4)
w = CONTROLLER_JOY4WAY;
else if (field->way == 16)
w = CONTROLLER_JOY16WAY;
break;
case IPT_JOYSTICKRIGHT_UP:
case IPT_JOYSTICKRIGHT_DOWN:
case IPT_JOYSTICKLEFT_UP:
case IPT_JOYSTICKLEFT_DOWN:
dual = TRUE;
case IPT_JOYSTICK_UP:
case IPT_JOYSTICK_DOWN:
ud = TRUE;
if (field->way == 4)
w = CONTROLLER_JOY4WAY;
else if (field->way == 16)
w = CONTROLLER_JOY16WAY;
break;
case IPT_PADDLE:
flags[CONTROLLER_PADDLE] = TRUE;
break;
case IPT_DIAL:
flags[CONTROLLER_DIAL] = TRUE;
break;
case IPT_TRACKBALL_X:
case IPT_TRACKBALL_Y:
flags[CONTROLLER_TRACKBALL] = TRUE;
break;
case IPT_AD_STICK_X:
case IPT_AD_STICK_Y:
flags[CONTROLLER_ADSTICK] = TRUE;
break;
case IPT_LIGHTGUN_X:
case IPT_LIGHTGUN_Y:
flags[CONTROLLER_LIGHTGUN] = TRUE;
break;
case IPT_PEDAL:
flags[CONTROLLER_PEDAL] = TRUE;
break;
}
}
}
//input_port_list_deinit(&portlist);
if (lr || ud)
{
if (lr && !ud)
w = CONTROLLER_JOY2WAY;
else if (!lr && ud)
w = CONTROLLER_VJOY2WAY;
if (dual)
w += CONTROLLER_DOUBLEJOY2WAY - CONTROLLER_JOY2WAY;
flags[w] = TRUE;
}
}
gameinfo->numPlayers = p;
gameinfo->numButtons = b;
memcpy(gameinfo->usesController, flags, sizeof gameinfo->usesController);
}
global_free(cache);
}
static struct DriversInfo* GetDriversInfo(int driver_index)
{
if (drivers_info == NULL)
{
UINT16 ndriver;
drivers_info = (DriversInfo*)malloc(sizeof(struct DriversInfo) * GetNumGames());
for (ndriver = 0; ndriver < GetNumGames(); ndriver++)
{
const game_driver *gamedrv = &driver_list::driver(ndriver);
struct DriversInfo *gameinfo = &drivers_info[ndriver];
const rom_entry *region, *rom;
machine_config config(*gamedrv, MameUIGlobal());
const rom_source *source;
int num_speakers;
gameinfo->isClone = (GetParentRomSetIndex(gamedrv) != -1);
gameinfo->isBroken = ((gamedrv->flags & GAME_NOT_WORKING) != 0);
gameinfo->supportsSaveState = ((gamedrv->flags & GAME_SUPPORTS_SAVE) != 0);
gameinfo->isHarddisk = FALSE;
gameinfo->isVertical = (gamedrv->flags & ORIENTATION_SWAP_XY) ? TRUE : FALSE;
for (source = rom_first_source(config); source != NULL; source = rom_next_source(*source))
for (region = rom_first_region(*source); region; region = rom_next_region(region))
if (ROMREGION_ISDISKDATA(region))
gameinfo->isHarddisk = TRUE;
gameinfo->hasOptionalBIOS = FALSE;
if (gamedrv->rom != NULL)
for (rom = gamedrv->rom; !ROMENTRY_ISEND(rom); rom++)
if (ROMENTRY_ISSYSTEM_BIOS(rom))
{
gameinfo->hasOptionalBIOS = TRUE;
break;
}
num_speakers = numberOfSpeakers(&config);
gameinfo->isStereo = (num_speakers > 1);
gameinfo->screenCount = numberOfScreens(&config);
gameinfo->isVector = isDriverVector(&config); // ((drv.video_attributes & VIDEO_TYPE_VECTOR) != 0);
gameinfo->usesRoms = FALSE;
for (source = rom_first_source(config); source != NULL; source = rom_next_source(*source))
for (region = rom_first_region(*source); region; region = rom_next_region(region))
for (rom = rom_first_file(region); rom; rom = rom_next_file(rom))
{
gameinfo->usesRoms = TRUE;
break;
}
gameinfo->usesSamples = FALSE;
samples_device_iterator iter(config.root_device());
if (iter.first() != NULL)
gameinfo->usesSamples = TRUE;
gameinfo->numPlayers = 0;
gameinfo->numButtons = 0;
memset(gameinfo->usesController, 0, sizeof gameinfo->usesController);
gameinfo->parentIndex = -1;
if (gameinfo->isClone)
{
int i;
for (i = 0; i < GetNumGames(); i++)
{
if (GetParentRomSetIndex(gamedrv) == i)
{
gameinfo->parentIndex = i;
break;
}
}
}
gameinfo->biosIndex = -1;
if (DriverIsBios(ndriver))
gameinfo->biosIndex = ndriver;
else if (gameinfo->hasOptionalBIOS)
{
int parentIndex;
if (gameinfo->isClone)
parentIndex = gameinfo->parentIndex;
else
parentIndex = ndriver;
while (1)
{
parentIndex = GetGameNameIndex(driver_list::driver(parentIndex).parent);
if (parentIndex == -1)
{
dprintf("bios for %s is not found", driver_list::driver(ndriver).name);
break;
}
if (DriverIsBios(parentIndex))
{
gameinfo->biosIndex = parentIndex;
break;
}
}
}
gameinfo->usesTrackball = FALSE;
gameinfo->usesLightGun = FALSE;
if (gamedrv->ipt != NULL)
{
input_port_config *port;
ioport_list portlist;
astring errors;
device_iterator iter(config.root_device());
for (device_t *device = iter.first(); device != NULL; device = iter.next())
if (device->input_ports()!=NULL)
input_port_list_init(*device, portlist, errors);
for (port = portlist.first(); port != NULL; port = port->next())
{
const input_field_config *field;
for (field = port->first_field(); field != NULL; field = field->next())
{
UINT32 type;
type = field->type;
if (type == IPT_END)
break;
if (type == IPT_DIAL || type == IPT_PADDLE ||
type == IPT_TRACKBALL_X || type == IPT_TRACKBALL_Y ||
type == IPT_AD_STICK_X || type == IPT_AD_STICK_Y)
gameinfo->usesTrackball = TRUE;
if (type == IPT_LIGHTGUN_X || type == IPT_LIGHTGUN_Y)
gameinfo->usesLightGun = TRUE;
if (type == IPT_MOUSE_X || type == IPT_MOUSE_Y)
gameinfo->usesMouse = TRUE;
}
}
}
}
UpdateController();
}
return &drivers_info[driver_index];
}