BYTE save_slot_save(BYTE slot) {
uTCHAR *file;
FILE *fp;
/* game genie */
if (info.mapper.id == GAMEGENIE_MAPPER) {
text_add_line_info(1, "[yellow]save is impossible in Game Genie menu");
return (EXIT_ERROR);
}
if (slot < SAVE_SLOT_FILE) {
if ((file = name_slot_file(slot)) == NULL) {
return (EXIT_ERROR);
}
} else {
file = cfg->save_file;
}
if ((fp = ufopen(file, uL("wb"))) == NULL) {
fprintf(stderr, "error on write save state\n");
return (EXIT_ERROR);
}
slot_operation(SAVE_SLOT_SAVE, slot, fp);
fflush(fp);
/* aggiorno la posizione della preview e il totalsize */
slot_operation(SAVE_SLOT_COUNT, slot, fp);
save_slot.state[slot] = TRUE;
fclose(fp);
if (slot < SAVE_SLOT_FILE) {
text_save_slot(SAVE_SLOT_SAVE);
}
return (EXIT_OK);
}
BYTE save_slot_load(BYTE slot) {
uTCHAR *file;
FILE *fp;
if (tas.type) {
text_add_line_info(1, "[yellow]movie playback interrupted[normal]");
tas_quit();
}
/* game genie */
if (info.mapper.id == GAMEGENIE_MAPPER) {
gamegenie_reset();
gamegenie.phase = GG_LOAD_ROM;
emu_reset(CHANGE_ROM);
gamegenie.phase = GG_FINISH;
}
if (slot < SAVE_SLOT_FILE) {
if ((file = name_slot_file(slot)) == NULL) {
return (EXIT_ERROR);
}
} else {
file = cfg->save_file;
}
if ((fp = ufopen(file, uL("rb"))) == NULL) {
text_add_line_info(1, "[red]error[normal] loading state");
fprintf(stderr, "error loading state\n");
return (EXIT_ERROR);
}
/*
* mi salvo lo stato attuale da ripristinare in caso
* di un file di salvataggio corrotto.
*/
timeline_snap(TL_SAVE_SLOT);
if (slot == SAVE_SLOT_FILE) {
slot_operation(SAVE_SLOT_COUNT, slot, fp);
if (memcmp(info.sha1sum.prg.value, save_slot.sha1sum.prg.value,
sizeof(info.sha1sum.prg.value)) != 0) {
text_add_line_info(1, "[red]state file is not for this rom[normal]");
fprintf(stderr, "state file is not for this rom.\n");
timeline_back(TL_SAVE_SLOT, 0);
fclose(fp);
return (EXIT_ERROR);
}
}
if (slot_operation(SAVE_SLOT_READ, slot, fp)) {
fprintf(stderr, "error loading state, corrupted file.\n");
timeline_back(TL_SAVE_SLOT, 0);
fclose(fp);
return (EXIT_ERROR);
}
fclose(fp);
if (slot < SAVE_SLOT_FILE) {
text_save_slot(SAVE_SLOT_READ);
}
/* riavvio il timeline */
timeline_init();
return (EXIT_OK);
}
void gfx_set_screen(BYTE scale, BYTE filter, BYTE fullscreen, BYTE palette, BYTE force_scale,
BYTE force_palette) {
BYTE set_mode;
WORD width, height, w_for_pr, h_for_pr;
gfx_set_screen_start:
set_mode = FALSE;
width = 0, height = 0;
w_for_pr = 0, h_for_pr = 0;
/*
* l'ordine dei vari controlli non deve essere cambiato:
* 0) overscan
* 1) filtro
* 2) fullscreen
* 3) fattore di scala
* 4) tipo di paletta (IMPORTANTE: dopo il SDL_SetVideoMode)
*/
/* overscan */
{
overscan.enabled = cfg->oscan;
gfx.rows = SCR_ROWS;
gfx.lines = SCR_LINES;
if (overscan.enabled == OSCAN_DEFAULT) {
overscan.enabled = cfg->oscan_default;
}
if (overscan.enabled) {
gfx.rows -= (overscan.borders->left + overscan.borders->right);
gfx.lines -= (overscan.borders->up + overscan.borders->down);
}
}
/* filtro */
if (filter == NO_CHANGE) {
filter = cfg->filter;
}
if ((filter != cfg->filter) || info.on_cfg || force_scale) {
switch (filter) {
case PHOSPHOR:
case SCANLINE:
case NO_FILTER:
case DBL:
case CRT_CURVE:
case CRT_NO_CURVE:
case PHOSPHOR2:
case DARK_ROOM:
gfx.filter = scale_surface;
/*
* se sto passando dal filtro ntsc ad un'altro, devo
* ricalcolare la larghezza del video mode quindi
* forzo il controllo del fattore di scala.
*/
if (cfg->filter == NTSC_FILTER) {
/* devo reimpostare la larghezza del video mode */
scale = cfg->scale;
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
}
break;
case SCALE2X:
case SCALE3X:
case SCALE4X:
case HQ2X:
case HQ3X:
case HQ4X:
case XBRZ2X:
case XBRZ3X:
case XBRZ4X:
if ((filter >= SCALE2X) && (filter <= SCALE4X)) {
gfx.filter = scaleNx;
} else if ((filter >= HQ2X) && (filter <= HQ4X)) {
gfx.filter = hqNx;
} else if ((filter >= XBRZ2X) && (filter <= XBRZ4X)) {
gfx.filter = xBRZ;
}
/*
* se sto passando dal filtro ntsc ad un'altro, devo
* ricalcolare la larghezza del video mode quindi
* forzo il controllo del fattore di scala.
*/
if (cfg->filter == NTSC_FILTER) {
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
}
break;
case NTSC_FILTER:
gfx.filter = ntsc_surface;
/*
* il fattore di scala deve essere gia' stato
* inizializzato almeno una volta.
*/
if (cfg->scale != NO_CHANGE) {
/* devo reimpostare la larghezza del video mode */
scale = cfg->scale;
} else if (scale == NO_CHANGE) {
/*
* se scale e new_scale sono uguali a NO_CHANGE,
* imposto un default.
*/
scale = X2;
}
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
break;
}
}
/* fullscreen */
if (fullscreen == NO_CHANGE) {
fullscreen = cfg->fullscreen;
}
if ((fullscreen != cfg->fullscreen) || info.on_cfg) {
/* forzo il controllo del fattore di scale */
force_scale = TRUE;
/* indico che devo cambiare il video mode */
set_mode = TRUE;
}
/* fattore di scala */
if (scale == NO_CHANGE) {
scale = cfg->scale;
}
if ((scale != cfg->scale) || info.on_cfg || force_scale) {
#define ctrl_filter_scale(scalexf, hqxf, xbrzxf)\
if ((filter >= SCALE2X) && (filter <= SCALE4X)) {\
filter = scalexf;\
} else if ((filter >= HQ2X) && (filter <= HQ4X)) {\
filter = hqxf;\
} else if ((filter >= XBRZ2X) && (filter <= XBRZ4X)) {\
filter = xbrzxf;\
}
switch (scale) {
case X1:
/*
* il fattore di scala a 1 e' possibile
* solo senza filtro.
*/
if (filter != NO_FILTER) {
/*
* con un fattore di scala X1 effect deve essere
* sempre impostato su scale_surface.
*/
gfx.filter = scale_surface;
return;
}
set_mode = TRUE;
break;
case X2:
ctrl_filter_scale(SCALE2X, HQ2X, XBRZ2X)
ntsc_width(width, ntsc_width_pixel[scale], TRUE);
set_mode = TRUE;
break;
case X3:
ctrl_filter_scale(SCALE3X, HQ3X, XBRZ3X)
ntsc_width(width, ntsc_width_pixel[scale], TRUE);
set_mode = TRUE;
break;
case X4:
ctrl_filter_scale(SCALE4X, HQ4X, XBRZ4X)
ntsc_width(width, ntsc_width_pixel[scale], TRUE);
set_mode = TRUE;
break;
}
if (!width) {
width = gfx.rows * scale;
gfx.w[CURRENT] = width;
gfx.w[NO_OVERSCAN] = SCR_ROWS * scale;
}
height = gfx.lines * scale;
gfx.h[CURRENT] = height;
gfx.h[NO_OVERSCAN] = SCR_LINES * scale;
}
/*
* cfg->scale e cfg->filter posso aggiornarli prima
* del set_mode, mentre cfg->fullscreen e cfg->palette
* devo farlo necessariamente dopo.
*/
/* salvo il nuovo fattore di scala */
cfg->scale = scale;
/* salvo ill nuovo filtro */
cfg->filter = filter;
/* devo eseguire un SDL_SetVideoMode? */
if (set_mode) {
uint32_t flags = software_flags;
gfx.w[VIDEO_MODE] = width;
gfx.h[VIDEO_MODE] = height;
gfx.pixel_aspect_ratio = 1.0f;
if (gfx.opengl) {
flags = opengl.flags;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
//SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
//SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
/* abilito il doublebuffering */
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, TRUE);
/* abilito il vsync se e' necessario */
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, cfg->vsync);
if (fullscreen) {
gfx.w[VIDEO_MODE] = gfx.w[MONITOR];
gfx.h[VIDEO_MODE] = gfx.h[MONITOR];
}
/* Pixel Aspect Ratio */
{
if (cfg->filter == NTSC_FILTER) {
gfx.pixel_aspect_ratio = 1.0f;
} else {
switch (cfg->pixel_aspect_ratio) {
case PAR11:
gfx.pixel_aspect_ratio = 1.0f;
break;
case PAR54:
gfx.pixel_aspect_ratio = 5.0f / 4.0f;
break;
case PAR87:
gfx.pixel_aspect_ratio = 8.0f / 7.0f;
break;
}
}
if ((gfx.pixel_aspect_ratio != 1.0f) && !fullscreen) {
float brd = 0;
gfx.w[VIDEO_MODE] = (gfx.w[NO_OVERSCAN] * gfx.pixel_aspect_ratio);
if (overscan.enabled) {
brd = (float) gfx.w[VIDEO_MODE] / (float) SCR_ROWS;
brd *= (overscan.borders->right + overscan.borders->left);
}
gfx.w[VIDEO_MODE] -= brd;
}
}
}
/* faccio quello che serve prima del setvideo */
gui_set_video_mode();
/*
* nella versione a 32 bit (GTK) dopo un gfx_reset_video,
* se non lo faccio anche qui, crasha tutto.
*/
//sdl_wid();
/* inizializzo la superfice video */
surface_sdl = SDL_SetVideoMode(gfx.w[VIDEO_MODE], gfx.h[VIDEO_MODE], 0, flags);
gui_after_set_video_mode();
/* in caso di errore */
if (!surface_sdl) {
fprintf(stderr, "SDL_SetVideoMode failed : %s\n", SDL_GetError());
return;
}
gfx.bit_per_pixel = surface_sdl->format->BitsPerPixel;
}
/* interpolation */
if (gfx.opengl && cfg->interpolation) {
opengl.interpolation = TRUE;
} else {
opengl.interpolation = FALSE;
}
/* paletta */
if (palette == NO_CHANGE) {
palette = cfg->palette;
}
if ((palette != cfg->palette) || info.on_cfg || force_palette) {
if (palette == PALETTE_FILE) {
if (strlen(cfg->palette_file) != 0) {
if (palette_load_from_file(cfg->palette_file) == EXIT_ERROR) {
memset(cfg->palette_file, 0x00, sizeof(cfg->palette_file));
text_add_line_info(1, "[red]error on palette file");
if (cfg->palette != PALETTE_FILE) {
palette = cfg->palette;
} else if (machine.type == NTSC) {
palette = PALETTE_NTSC;
} else {
palette = PALETTE_SONY;
}
} else {
ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_base_file, 0,
(BYTE *) palette_RGB);
}
}
}
switch (palette) {
case PALETTE_PAL:
ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_base_pal, 0,
(BYTE *) palette_RGB);
break;
case PALETTE_NTSC:
ntsc_set(cfg->ntsc_format, FALSE, 0, 0, (BYTE *) palette_RGB);
break;
case PALETTE_GREEN:
rgb_modifier(-0x20, 0x20, -0x20);
break;
case PALETTE_FILE:
break;
default:
ntsc_set(cfg->ntsc_format, palette, 0, 0, (BYTE *) palette_RGB);
break;
}
/* inizializzo in ogni caso la tabella YUV dell'hqx */
hqx_init();
/*
* memorizzo i colori della paletta nel
* formato di visualizzazione.
*/
{
WORD i;
for (i = 0; i < NUM_COLORS; i++) {
palette_win[i] = SDL_MapRGBA(surface_sdl->format, palette_RGB[i].r,
palette_RGB[i].g, palette_RGB[i].b, 255);
}
}
}
/* salvo il nuovo stato del fullscreen */
cfg->fullscreen = fullscreen;
/* salvo il nuovo tipo di paletta */
cfg->palette = palette;
/* software rendering */
framebuffer = surface_sdl;
flip = SDL_Flip;
text.surface = surface_sdl;
text_clear = gfx_text_clear;
text_blit = gfx_text_blit;
text.w = surface_sdl->w;
text.h = surface_sdl->h;
w_for_pr = gfx.w[VIDEO_MODE];
h_for_pr = gfx.h[VIDEO_MODE];
if (gfx.opengl) {
opengl.scale_force = FALSE;
opengl.scale = cfg->scale;
opengl.factor = X1;
opengl.PSS = FALSE;
opengl.glsl.shader_used = FALSE;
shader.id = SHADER_NONE;
opengl.glsl.param = 0;
if ((opengl.glsl.compliant == TRUE) && (opengl.glsl.enabled == TRUE)) {
#define PSS()\
opengl.PSS = ((gfx.pixel_aspect_ratio != 1.0f) && (cfg->PAR_soft_stretch == TRUE)) ? TRUE : FALSE
#define glsl_up(e, s, p)\
opengl.glsl.shader_used = TRUE;\
shader.id = s;\
opengl.scale_force = TRUE;\
opengl.scale = X1;\
opengl.factor = cfg->scale;\
PSS();\
opengl.glsl.param = p;\
gfx.filter = e
glsl_delete_shaders(&shader);
switch (cfg->filter) {
case NO_FILTER:
glsl_up(scale_surface, SHADER_NO_FILTER, 0);
break;
case PHOSPHOR:
glsl_up(scale_surface, SHADER_PHOSPHOR, 0);
break;
case PHOSPHOR2:
glsl_up(scale_surface, SHADER_PHOSPHOR, 1);
break;
case SCANLINE:
glsl_up(scale_surface, SHADER_SCANLINE, 0);
break;
case DBL:
glsl_up(scale_surface, SHADER_DONTBLOOM, 0);
break;
case DARK_ROOM:
glsl_up(scale_surface, SHADER_DONTBLOOM, 1);
break;
case CRT_CURVE:
glsl_up(scale_surface, SHADER_CRT, 0);
/* niente interpolazione perche' gia fatta dallo shader stesso */
opengl.interpolation = opengl.PSS = FALSE;
break;
case CRT_NO_CURVE:
glsl_up(scale_surface, SHADER_CRT, 1);
/* niente interpolazione perche' gia fatta dallo shader stesso */
opengl.interpolation = opengl.PSS = FALSE;
break;
case SCALE2X:
case SCALE3X:
case SCALE4X:
case HQ2X:
case HQ3X:
case HQ4X:
case XBRZ2X:
case XBRZ3X:
case XBRZ4X:
case NTSC_FILTER:
PSS();
break;
}
/*
if (cfg->fullscreen) {
if ((cfg->filter >= SCALE2X) && (cfg->filter <= SCALE4X)) {
glsl_up(scaleNx, SHADER_NO_FILTER);
opengl.scale = X2;
opengl.factor = (float) cfg->scale / 2.0f;
} else if ((cfg->filter >= HQ2X) && (cfg->filter <= HQ4X)) {
glsl_up(hqNx, SHADER_NO_FILTER);
opengl.scale = X2;
opengl.factor = (float) cfg->scale / 2.0f;
}
}
*/
}
/* creo la superficie che utilizzero' come texture */
sdl_create_surface_gl(surface_sdl, gfx.w[CURRENT], gfx.h[CURRENT], cfg->fullscreen);
/* opengl rendering */
framebuffer = opengl.surface_gl;
flip = opengl_flip;
text.surface = surface_sdl;
text_clear = opengl_text_clear;
text_blit = opengl_text_blit;
text.w = gfx.w[CURRENT];
text.h = gfx.h[CURRENT];
{
WORD r = (WORD) opengl.quadcoords.r;
WORD l = (WORD) opengl.quadcoords.l;
WORD t = (WORD) opengl.quadcoords.t;
WORD b = (WORD) opengl.quadcoords.b;
w_for_pr = r - l;
h_for_pr = t - b;
}
}
/* questo controllo devo farlo necessariamente dopo il glew_init() */
if ((opengl.glsl.compliant == FALSE) || (opengl.glsl.enabled == FALSE)) {
if ((filter >= PHOSPHOR) && (filter <= CRT_NO_CURVE)) {
filter = NO_FILTER;
goto gfx_set_screen_start;
}
}
gfx_text_reset();
/*
* calcolo le proporzioni tra il disegnato a video (overscan e schermo
* con le dimensioni per il filtro NTSC compresi) e quello che dovrebbe
* essere (256 x 240). Mi serve per calcolarmi la posizione del puntatore
* dello zapper.
*/
gfx.w_pr = ((float) w_for_pr / gfx.w[CURRENT]) * ((float) gfx.w[NO_OVERSCAN] / SCR_ROWS);
gfx.h_pr = ((float) h_for_pr / gfx.h[CURRENT]) * ((float) gfx.h[NO_OVERSCAN] / SCR_LINES);
/* setto il titolo della finestra */
gui_update();
if (info.on_cfg == TRUE) {
info.on_cfg = FALSE;
}
}
BYTE map_init(void) {
BYTE i;
/*
* di default la routine di salvataggio
* di una possibile struttura interna
* di dati della mapper e' NULL.
*/
for (i = 0; i < LENGTH(mapper.internal_struct); i++) {
mapper.internal_struct[i] = 0;
}
/* disabilito gli accessori */
irqA12.present = FALSE;
irql2f.present = FALSE;
/* disabilito tutte le chiamate relative alle mappers */
extcl_init();
switch (info.mapper.id) {
case 0:
map_init_0();
break;
case 1:
map_init_MMC1();
break;
case 2:
if (info.mapper.submapper == UNLROM) {
map_init_UxROM(UNLROM);
} else if (info.mapper.submapper == UNROM_BK2) {
map_init_UxROM(UNROM_BK2);
} else {
map_init_UxROM(UXROM);
}
break;
case 3:
map_init_CNROM();
break;
case 4:
map_init_MMC3();
break;
case 5:
map_init_MMC5();
break;
case 7:
map_init_AxROM();
break;
/* per MMC2 e MMC4 uso le stesse routine */
case 9:
case 10:
map_init_MMC2and4();
break;
case 11:
map_init_ColorDreams();
break;
case 12:
map_init_Rex(DBZ);
break;
case 13:
map_init_CPROM();
break;
case 15:
map_init_Waixing(WPSX);
break;
case 16: {
switch (info.mapper.submapper) {
case E24C02:
map_init_Bandai(E24C02);
break;
case DATACH:
map_init_Bandai(DATACH);
break;
default:
map_init_Bandai(FCGx);
break;
}
break;
}
case 18:
map_init_Jaleco(SS8806);
break;
case 19:
map_init_Namco(N163);
break;
case 21:
map_init_VRC4(info.mapper.submapper == DEFAULT ? VRC4A : info.mapper.submapper);
break;
case 22:
map_init_VRC2(VRC2A);
break;
case 23:
if (info.mapper.submapper == VRC4BMC) {
map_init_VRC4BMC();
} else if (info.mapper.submapper == VRC4E) {
map_init_VRC4(VRC4E);
} else {
map_init_VRC2(VRC2B);
}
break;
case 24:
map_init_VRC6(VRC6A);
break;
case 25:
map_init_VRC4(info.mapper.submapper == DEFAULT ? VRC4B : info.mapper.submapper);
break;
case 26:
map_init_VRC6(VRC6B);
break;
case 28:
map_init_28();
break;
case 31:
map_init_31();
break;
case 32:
map_init_Irem(G101);
break;
case 33:
map_init_Taito(TC0190FMC);
break;
case 34:
map_init_BxROM();
break;
case 37:
map_init_37();
break;
case 38:
map_init_74x138x161();
break;
case 41:
map_init_Caltron();
break;
case 42:
map_init_42();
break;
case 44:
map_init_44();
break;
case 45:
map_init_45();
break;
case 46:
map_init_46();
break;
case 47:
map_init_47();
break;
case 49:
map_init_49();
break;
case 50:
map_init_50();
break;
case 51:
map_init_51();
break;
case 52:
map_init_52();
break;
case 53:
map_init_53();
break;
case 56:
map_init_Kaiser(KS202);
break;
case 57:
map_init_57();
break;
case 58:
map_init_58();
break;
case 60:
if (info.mapper.submapper == MAP60_VT5201) {
map_init_60_vt5201();
} else {
map_init_60();
}
break;
case 61:
map_init_61();
break;
case 62:
map_init_62();
break;
case 64:
map_init_Tengen(TRAMBO);
break;
case 65:
map_init_Irem(H3000);
break;
case 66:
map_init_GxROM();
break;
case 67:
map_init_Sunsoft(SUN3);
break;
case 68:
map_init_Sunsoft(SUN4);
break;
case 69:
map_init_Sunsoft(FM7);
break;
case 70:
map_init_74x161x161x32(IC74X161X161X32A);
break;
case 71:
map_init_Camerica();
break;
case 72:
map_init_Jaleco(JF17);
break;
case 73:
map_init_VRC3();
break;
case 74:
map_init_Waixing(WTA);
break;
case 75:
map_init_VRC1();
break;
case 76:
map_init_Namco(N3446);
break;
case 77:
map_init_Irem(LROG017);
break;
case 78:
map_init_Jaleco(JF16);
break;
case 79:
map_init_Ave(NINA06);
break;
case 80:
if (info.mapper.submapper == X1005B) {
map_init_Taito(X1005B);
} else {
map_init_Taito(X1005A);
}
break;
case 82:
map_init_Taito(X1017);
break;
case 83:
map_init_83();
break;
case 85:
if (info.mapper.submapper == VRC7A) {
map_init_VRC7(VRC7A);
} else {
map_init_VRC7(VRC7B);
}
break;
case 86:
map_init_Jaleco(JF13);
break;
case 87:
map_init_Jaleco(JF05);
break;
case 88:
map_init_Namco(N3433);
break;
case 89:
map_init_Sunsoft(SUN2B);
break;
case 90:
map_init_90_209_211(MAP90);
break;
case 91:
map_init_91();
break;
case 92:
map_init_Jaleco(JF19);
break;
case 93:
map_init_Sunsoft(SUN2A);
break;
case 94:
map_init_UxROM(UNL1XROM);
break;
case 95:
map_init_Namco(N3425);
break;
case 96:
map_init_Bandai(B161X02X74);
break;
case 97:
map_init_Irem(TAMS1);
break;
case 99:
map_init_Vs();
break;
case 105:
map_init_105();
break;
case 107:
map_init_Magic();
break;
case 108:
map_init_Whirlwind();
break;
case 112:
map_init_Ntdec(ASDER);
break;
case 113:
map_init_Hes();
break;
case 114:
map_init_114();
break;
case 115:
map_init_Kasing();
break;
case 116:
map_init_116();
break;
case 117:
map_init_Futuremedia();
break;
case 118:
if (info.mapper.submapper == TKSROM) {
map_init_TxROM(TKSROM);
} else {
map_init_TxROM(TLSROM);
}
break;
case 119:
map_init_TxROM(TQROM);
break;
case 120:
map_init_120();
break;
case 121:
map_init_121();
break;
case 132:
map_init_Txc(T22211A);
break;
case 133:
map_init_Sachen(SA72008);
break;
case 136:
map_init_Sachen(TCU02);
break;
case 137:
map_init_Sachen(SA8259D);
break;
case 138:
map_init_Sachen(SA8259B);
break;
case 139:
map_init_Sachen(SA8259C);
break;
case 140:
map_init_Jaleco(JF11);
break;
case 141:
map_init_Sachen(SA8259A);
break;
case 142:
map_init_Kaiser(KS7032);
break;
case 143:
map_init_Sachen(TCA01);
break;
case 144:
map_init_Agci();
break;
case 145:
map_init_Sachen(SA72007);
break;
case 146:
map_init_Ave(NINA06);
break;
case 147:
map_init_Sachen(TCU01);
break;
case 148:
map_init_Sachen(SA0037);
break;
case 149:
map_init_Sachen(SA0036);
break;
case 150:
map_init_Sachen(SA74374B);
break;
case 152:
map_init_74x161x161x32(IC74X161X161X32B);
break;
case 153:
/* Famicom Jump II - Saikyou no 7 Nin (J) [!].nes */
map_init_Bandai(FCGx);
break;
case 154:
map_init_Namco(N3453);
break;
case 156:
map_init_156();
break;
case 158:
map_init_Tengen(T800037);
break;
case 159:
map_init_Bandai(E24C01);
break;
case 163:
map_init_163();
break;
case 164:
map_init_164();
break;
case 165:
map_init_Waixing(SH2);
break;
case 171:
map_init_Kaiser(KS7058);
break;
case 172:
map_init_Txc(T22211B);
break;
case 173:
map_init_Txc(T22211C);
break;
case 175:
map_init_Kaiser(KS7022);
break;
case 176:
if (info.id == NOBMCFK23C) {
map_init_176();
} else {
map_init_BMCFK23C();
}
break;
case 177:
if (info.mapper.submapper != DEFAULT) {
/* questa e' la mappers 179 in nestopia */
map_init_Hen(info.mapper.submapper);
} else {
map_init_Hen(HEN_177);
}
break;
case 178:
if (info.mapper.submapper != DEFAULT) {
map_init_178(info.mapper.submapper);
} else {
map_init_178(MAP178);
}
break;
case 180:
map_init_UxROM(UNROM180);
break;
case 182:
map_init_182();
break;
case 183:
map_init_183();
break;
case 184:
map_init_Sunsoft(SUN1);
break;
case 185:
info.mapper.submapper = CNROM_CNFL;
map_init_CNROM();
break;
case 186:
map_init_186();
break;
case 189:
map_init_Txc(TXCTW);
break;
case 191:
map_init_Waixing(WTB);
break;
case 192:
map_init_Waixing(WTC);
break;
case 193:
map_init_Ntdec(FHERO);
break;
case 194:
map_init_Waixing(WTD);
break;
case 195:
map_init_Waixing(WTE);
break;
case 199:
map_init_Waixing(WTG);
break;
case 200:
map_init_200();
break;
case 201:
map_init_201();
break;
case 202:
map_init_202();
break;
case 203:
map_init_203();
break;
case 204:
map_init_204();
break;
case 205:
map_init_205();
break;
case 206:
map_init_Namco(N3416);
break;
/*
* la mapper 207 la tratto come mapper 80
* case 207:
*/
case 208:
map_init_208();
break;
case 209:
map_init_90_209_211(MAP209);
break;
case 211:
map_init_90_209_211(MAP211);
break;
case 212:
map_init_212();
break;
case 213:
map_init_213();
break;
case 214:
map_init_214();
break;
case 215:
map_init_215();
break;
case 216:
map_init_Rcm(GS2015);
break;
case 217:
map_init_217();
break;
case 219:
map_init_219();
break;
case 221:
map_init_221();
break;
case 222:
map_init_222();
break;
case 225:
map_init_225();
break;
case 226:
map_init_226();
break;
case 227:
map_init_227();
break;
case 228:
map_init_Active();
break;
case 229:
map_init_229();
break;
case 230:
map_init_230();
break;
case 231:
map_init_231();
break;
case 232:
info.mapper.submapper = BF9096;
map_init_Camerica();
break;
case 233:
map_init_233();
break;
case 234:
map_init_Ave(D1012);
break;
case 235:
map_init_235();
break;
case 240:
map_init_240();
break;
case 241:
map_init_241();
break;
case 242:
map_init_242();
break;
case 243:
map_init_Sachen(SA74374A);
break;
case 244:
map_init_244();
break;
case 245:
map_init_Waixing(WTH);
break;
case 246:
map_init_246();
break;
case 249:
map_init_249();
break;
default:
text_add_line_info(1, "[yellow]Mapper %d not supported", info.mapper.id);
fprintf(stderr, "Mapper not supported\n");
EXTCL_CPU_WR_MEM(0);
break;
/* casi speciali */
case FDS_MAPPER:
map_init_FDS();
break;
case GAMEGENIE_MAPPER:
map_init_GameGenie();
break;
case UNIF_MAPPER:
switch (unif.internal_mapper) {
case 0:
/* BMC-A65AS */
map_init_A65AS();
break;
case 1:
/* BMC-MARIO1-MALEE2 */
map_init_malee();
break;
}
break;
}
map_prg_rom_8k_update();
map_prg_ram_init();
if (map_chr_ram_init()) {
return (EXIT_ERROR);
}
return (EXIT_OK);
}
