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); }