void segae_bankswitch (void)
{
data8_t *RAM = memory_region(REGION_CPU1);
cpu_setbank( 1, &RAM[ 0x10000 + ( rombank * 0x4000 ) ] );
}
static MACHINE_RESET( rpunch )
{
UINT8 *snd = memory_region(machine, "upd");
memcpy(snd, snd + 0x20000, 0x20000);
}
ROM_END
static DRIVER_INIT( cookbib2 )
{
// data16_t *HCROM = (data16_t*)memory_region(REGION_CPU1);
data16_t *PROTDATA = (data16_t*)memory_region(REGION_USER1);
int i;
// hyperpac_ram[0xf000/2] = 0x46fc;
// hyperpac_ram[0xf002/2] = 0x2700;
// verified on real hardware, need to move this to a file really
// static data16_t cookbib2_mcu68k[] =
// {
// // moved to protdata.bin
// };
//for (i = 0;i < sizeof(cookbib2_mcu68k)/sizeof(cookbib2_mcu68k[0]);i++)
// hyperpac_ram[0xf000/2 + i] = cookbib2_mcu68k[i];
for (i = 0;i < 0x200/2;i++)
hyperpac_ram[0xf000/2 + i] = PROTDATA[i];
// trojan is actually buggy and gfx flicker like crazy
// but we can pause the system after bootup with HALT line of 68k to get the table before
// it goes nuts
// hyperpac_ram[0xf07a/2] = 0x4e73;
// hyperpac_ram[0xf000/2] = 0x4e73;
#if 0
/* interrupt wait loop? */
HCROM[0x014942/2] = 0x4eb9;
HCROM[0x014944/2] = 0x0004;
HCROM[0x014946/2] = 0x8000;
HCROM[0x014948/2] = 0x4e71;
/* interrupt wait loop? */
HCROM[0x014968/2] = 0x4eb9;
HCROM[0x01496a/2] = 0x0004;
HCROM[0x01496c/2] = 0x8100;
HCROM[0x01496e/2] = 0x4e71;
/* interrupt wait loop? */
HCROM[0x014560/2] = 0x4eb9;
HCROM[0x014562/2] = 0x0004;
HCROM[0x014564/2] = 0x8200;
HCROM[0x014566/2] = 0x4e71;
/* new code for interrupt wait */
HCROM[0x048000/2] = 0x4a79;
HCROM[0x048002/2] = 0x0010;
HCROM[0x048004/2] = 0x2462;
HCROM[0x048006/2] = 0x66f8;
HCROM[0x048008/2] = 0x4eb9;
HCROM[0x04800a/2] = 0x0004;
HCROM[0x04800c/2] = 0x8300;
HCROM[0x04800e/2] = 0x4e75;
/* new code for interrupt wait */
HCROM[0x048100/2] = 0x4a79;
HCROM[0x048102/2] = 0x0010;
HCROM[0x048104/2] = 0x2460;
HCROM[0x048106/2] = 0x66f8;
HCROM[0x048108/2] = 0x4eb9;
HCROM[0x04810a/2] = 0x0004;
HCROM[0x04810c/2] = 0x8300;
HCROM[0x04810e/2] = 0x4e75;
/* new code for interrupt wait */
HCROM[0x048200/2] = 0x4a79;
HCROM[0x048202/2] = 0x0010;
HCROM[0x048204/2] = 0x2490;
HCROM[0x048206/2] = 0x66f8;
HCROM[0x048208/2] = 0x4eb9;
HCROM[0x04820a/2] = 0x0004;
HCROM[0x04820c/2] = 0x8300;
HCROM[0x04820e/2] = 0x4e75;
/* put registers on stack */
HCROM[0x048300/2] = 0x48e7;
HCROM[0x048302/2] = 0xfffe;
/* wipe sprite ram (fill with 0x0002) */
/* put the address we want to write TO in A2 */
HCROM[0x048304/2] = 0x45f9;
HCROM[0x048306/2] = 0x0070;
HCROM[0x048308/2] = 0x0000;
/* put the number of words we want to clear into D0 */
HCROM[0x04830a/2] = 0x203c;
HCROM[0x04830c/2] = 0x0000;
HCROM[0x04830e/2] = 0x1000;
/* write 0x0002 to A2 */
HCROM[0x048310/2] = 0x34bc;
HCROM[0x048312/2] = 0x0002;
/* add 1 to write address a2 */
HCROM[0x048314/2] = 0xd5fc;
HCROM[0x048316/2] = 0x0000;
HCROM[0x048318/2] = 0x0002;
/* decrease counter d0 */
HCROM[0x04831a/2] = 0x5380;
/* compare d0 to 0 */
HCROM[0x04831c/2] = 0x0c80;
HCROM[0x04831e/2] = 0x0000;
HCROM[0x048320/2] = 0x0000;
/* if its not 0 then branch back */
HCROM[0x048322/2] = 0x66ec;
/* ram has been wiped */
/* put the address we want to read protection data in A2 */
HCROM[0x048324/2] = 0x45f9;
HCROM[0x048326/2] = 0x0010;
// HCROM[0x048328/2] = 0xf000;
// HCROM[0x048328/2] = 0xf000+0xb4;
HCROM[0x048328/2] = 0xf000+0xb4+0xb4;
/* put the address of spriteram in A0 */
HCROM[0x04832a/2] = 0x41f9;
HCROM[0x04832c/2] = 0x0070;
HCROM[0x04832e/2] = 0x0000;
/* put the number of rows into D3 */
HCROM[0x048330/2] = 0x263c;
HCROM[0x048332/2] = 0x0000;
HCROM[0x048334/2] = 0x0012;
/* put the y co-ordinate of rows into D6 */
HCROM[0x048336/2] = 0x2c3c;
HCROM[0x048338/2] = 0x0000;
HCROM[0x04833a/2] = 0x0014;
/* put the number of bytes per row into D2 */
HCROM[0x04833c/2] = 0x243c;
HCROM[0x04833e/2] = 0x0000;
HCROM[0x048340/2] = 0x000a;
/* put the x co-ordinate of rows into D5 */
HCROM[0x048342/2] = 0x2a3c;
HCROM[0x048344/2] = 0x0000;
HCROM[0x048346/2] = 0x0010;
// move content of a2 to d4 (byte)
HCROM[0x048348/2] = 0x1812;
HCROM[0x04834a/2] = 0xe84c; // shift d4 right by 4
HCROM[0x04834c/2] = 0x0244; // mask with 0x000f
HCROM[0x04834e/2] = 0x000f; //
/* jump to character draw to draw first bit */
HCROM[0x048350/2] = 0x4eb9;
HCROM[0x048352/2] = 0x0004;
HCROM[0x048354/2] = 0x8600;
// increase x-cord
HCROM[0x048356/2] = 0x0645;
HCROM[0x048358/2] = 0x000a;
/* add 0x10 to draw address a0 */
HCROM[0x04835a/2] = 0xd1fc;
HCROM[0x04835c/2] = 0x0000;
HCROM[0x04835e/2] = 0x0010;
// move content of a2 to d4 (byte)
HCROM[0x048360/2] = 0x1812;
HCROM[0x048362/2] = 0x0244; // mask with 0x000f
HCROM[0x048364/2] = 0x000f; //
/* jump to character draw to draw second bit */
HCROM[0x048366/2] = 0x4eb9;
HCROM[0x048368/2] = 0x0004;
HCROM[0x04836a/2] = 0x8600;
// increase x-cord
HCROM[0x04836c/2] = 0x0645;
HCROM[0x04836e/2] = 0x000c;
/* add 0x10 to draw address a0 */
HCROM[0x048370/2] = 0xd1fc;
HCROM[0x048372/2] = 0x0000;
HCROM[0x048374/2] = 0x0010;
// newcode
/* add 1 to read address a2 */
HCROM[0x048376/2] = 0xd5fc;
HCROM[0x048378/2] = 0x0000;
HCROM[0x04837a/2] = 0x0001;
/* decrease counter d2 (row count)*/
HCROM[0x04837c/2] = 0x5382;
/* compare d2 to 0 */
HCROM[0x04837e/2] = 0x0c82;
HCROM[0x048380/2] = 0x0000;
HCROM[0x048382/2] = 0x0000;
/* if its not 0 then branch back */
HCROM[0x048384/2] = 0x66c2;
// increase y-cord d6
HCROM[0x048386/2] = 0x0646;
HCROM[0x048388/2] = 0x000c;
/* decrease counter d3 */
HCROM[0x04838a/2] = 0x5383;
/* compare d3 to 0 */
HCROM[0x04838c/2] = 0x0c83;
HCROM[0x04838e/2] = 0x0000;
HCROM[0x048390/2] = 0x0000;
/* if its not 0 then branch back */
HCROM[0x048392/2] = 0x66a8;
/* get back registers from stack*/
HCROM[0x048394/2] = 0x4cdf;
HCROM[0x048396/2] = 0x7fff;
/* rts */
HCROM[0x048398/2] = 0x4e75;
/* Draw a character! */
/* D6 = y-coordinate
D5 = x-coordinate
D4 = value to draw
A0 = spriteram base */
// 0002 0002 0002 0010 00xx 00yy 00nn 000n
// 357c 0020 000c
// 337c = a1
// move.w #$20, (#$c, A2)
HCROM[0x048600/2] = 0x317c;
HCROM[0x048602/2] = 0x0010;
HCROM[0x048604/2] = 0x0006;
HCROM[0x048606/2] = 0x3145;
HCROM[0x048608/2] = 0x0008;
HCROM[0x04860a/2] = 0x3146;
HCROM[0x04860c/2] = 0x000a;
/* get true value */
/* put lookuptable address in A3 */
HCROM[0x04860e/2] = 0x47f9;
HCROM[0x048610/2] = 0x0004;
HCROM[0x048612/2] = 0x8800;
HCROM[0x048614/2] = 0x3004; // d4 -> d0
HCROM[0x048616/2] = 0xe348;
HCROM[0x048618/2] = 0x3173;
HCROM[0x04861a/2] = 0x0000;
HCROM[0x04861c/2] = 0x000c;
/* not value */
HCROM[0x04861e/2] = 0x317c;
HCROM[0x048620/2] = 0x0000;
HCROM[0x048622/2] = 0x000e;
/* rts */
HCROM[0x048624/2] = 0x4e75;
/* table used for lookup by the draw routine to get real tile numbers */
HCROM[0x048800/2] = 0x0010;
HCROM[0x048802/2] = 0x0011;
HCROM[0x048804/2] = 0x0012;
HCROM[0x048806/2] = 0x0013;
HCROM[0x048808/2] = 0x0014;
HCROM[0x04880a/2] = 0x0015;
HCROM[0x04880c/2] = 0x0016;
HCROM[0x04880e/2] = 0x0017;
HCROM[0x048810/2] = 0x0018;
HCROM[0x048812/2] = 0x0019;
HCROM[0x048814/2] = 0x0021;
HCROM[0x048816/2] = 0x0022;
HCROM[0x048818/2] = 0x0023;
HCROM[0x04881a/2] = 0x0024;
HCROM[0x04881c/2] = 0x0025;
HCROM[0x04881e/2] = 0x0026;
/*
10 0
11 1
12 2
13 3
14 4
15 5
16 6
17 7
18 8
19 9
21 a
22 b
23 c
24 d
25 e
26 f
*/
{
FILE *fp;
fp=fopen("cookie", "w+b");
if (fp)
{
fwrite(HCROM, 0x80000, 1, fp);
fclose(fp);
}
}
#endif
}
static WRITE8_HANDLER( rom2_bank_select_w )
{
UINT8 *region_base = memory_region(REGION_USER2);
printf("ROM_BANK 0x4000 - %X @%X\n",data,activecpu_get_previouspc());
memory_set_bankptr(1, region_base + (data&0x3f ) * 0x4000);
}
static READ8_HANDLER( trvquest_question_r )
{
gameplan_state *state = machine->driver_data;
return memory_region(REGION_USER1)[*state->trvquest_question * 0x2000 + offset];
}
static DRIVER_INIT( ashnojoe )
{
memory_set_bankptr(4, memory_region(REGION_SOUND1));
}
static WRITE_HANDLER( bssoccer_pcm_2_bankswitch_w )
{
unsigned char *RAM = memory_region(REGION_CPU3);
int bank = data & 7;
cpu_setbank(2, &RAM[bank * 0x10000 + 0x1000]);
}
static DRIVER_INIT( cyclwarr )
{
UINT8 *dst = memory_region(REGION_GFX1);
UINT8 *src1 = memory_region(REGION_GFX2);
UINT8 *src2 = memory_region(REGION_GFX3);
int i;
for (i=0; i<0x100000; i+=32) {
memcpy(dst,src1,32);
src1+=32;
dst+=32;
memcpy(dst,src2,32);
dst+=32;
src2+=32;
}
dst = memory_region(REGION_CPU1);
memcpy(cyclwarr_cpua_ram,dst+0x100000,8);
memory_set_bankptr(1, memory_region(REGION_CPU1) + 0x100000);
dst = memory_region(REGION_CPU2);
memcpy(cyclwarr_cpub_ram,dst+0x100000,8);
memory_set_bankptr(2, memory_region(REGION_CPU2) + 0x100000);
/* Copy sprite & palette data out of GFX rom area */
tatsumi_rom_sprite_lookup1=auto_malloc(0x4000);
tatsumi_rom_sprite_lookup2=auto_malloc(0x4000);
tatsumi_rom_clut0=auto_malloc(0x1000);
tatsumi_rom_clut1=auto_malloc(0x1000);
memcpy(tatsumi_rom_sprite_lookup1, memory_region(REGION_GFX2),0x4000);
memcpy(tatsumi_rom_sprite_lookup2, memory_region(REGION_GFX3),0x4000);
memcpy(tatsumi_rom_clut0, memory_region(REGION_GFX2)+0x100000-0x1000,0x1000);
memcpy(tatsumi_rom_clut1, memory_region(REGION_GFX3)+0x100000-0x1000,0x1000);
tatsumi_reset();
}
static void get_sprite_info(void)
{
const int region = REGION_GFX4;
const unsigned short *base_pal = Machine->remapped_colortable + 0;
const unsigned char *base_gfx = memory_region(region);
const unsigned char *gfx_max = base_gfx + memory_region_length(region);
int sprite_bank = READ_WORD(&cave_videoregs[8]) & 1;
unsigned char *source = spriteram + (spriteram_size / 2) * sprite_bank;
struct sprite *sprite = sprite_list->sprite;
const struct sprite *finish = sprite + spriteram_size / 0x10 / 2;
int glob_flipx = READ_WORD(&cave_videoregs[0]) & 0x8000;
int glob_flipy = READ_WORD(&cave_videoregs[2]) & 0x8000;
int max_x = Machine->drv->screen_width;
int max_y = Machine->drv->screen_height;
for (; sprite < finish; sprite++,source+=0x10 )
{
int x,y,attr,code,zoomx,zoomy,size,flipx,flipy;
if ( cave_spritetype == 0) // most of the games
{
x = READ_WORD(&source[ 0x00 ]);
y = READ_WORD(&source[ 0x02 ]);
attr = READ_WORD(&source[ 0x04 ]);
code = READ_WORD(&source[ 0x06 ]);
zoomx = READ_WORD(&source[ 0x08 ]);
zoomy = READ_WORD(&source[ 0x0a ]);
size = READ_WORD(&source[ 0x0c ]);
}
else // ddonpach
{
attr = READ_WORD(&source[ 0x00 ]);
code = READ_WORD(&source[ 0x02 ]);
x = READ_WORD(&source[ 0x04 ]) << 6;
y = READ_WORD(&source[ 0x06 ]) << 6;
size = READ_WORD(&source[ 0x08 ]);
zoomx = 0x100;
zoomy = 0x100;
}
code += (attr & 3) << 16;
flipx = attr & 0x0008;
flipy = attr & 0x0004;
if (x & 0x8000) x -= 0x10000;
if (y & 0x8000) y -= 0x10000;
x /= 0x40; y /= 0x40;
sprite->priority = (attr & 0x0030) >> 4;
sprite->flags = SPRITE_VISIBLE;
sprite->tile_width = ( (size >> 8) & 0x1f ) * 16;
sprite->tile_height = ( (size >> 0) & 0x1f ) * 16;
sprite->total_width = (sprite->tile_width * zoomx) / 0x100;
sprite->total_height = (sprite->tile_height * zoomy) / 0x100;
sprite->pen_data = base_gfx + (16*16) * code;
sprite->line_offset = sprite->tile_width;
sprite->pal_data = base_pal + (attr & 0x3f00); // first 0x4000 colors
/* Bound checking */
if ((sprite->pen_data + sprite->tile_width * sprite->tile_height - 1) >= gfx_max )
{sprite->flags = 0; continue;}
if (glob_flipx) { x = max_x - x - sprite->total_width; flipx = !flipx; }
if (glob_flipy) { y = max_y - y - sprite->total_height; flipy = !flipy; }
sprite->x = x;
sprite->y = y;
if (flipx) sprite->flags |= SPRITE_FLIPX;
if (flipy) sprite->flags |= SPRITE_FLIPY;
}
}
ROM_END
/*
Cannon Dancer / Osman are odd, they don't init their own Eeprom...
Roms on boths games are identical, and the Eeprom contains several settings the user isn't
permitted to change, including region and button config.. the first 2 bytes must match the
last first 2 bytes in the last block of 8 bytes, and the at 0x20 there must be 0088 or the
game won't boot
The second byte of Eeprom contains the following
(Switch 0 in test mode)
-bss llfr (byte 0x01 / 0x79 of eeprom)
*- = unknown / unused (no observed effect)
*b = button config (2 buttons, or 3 buttons)
s = number of special weapons (bombs)
l = lives
f = flip (screen rotation)
*r = region
other settings
Switch 1 (byte 0x00 / 0x78 of eeprom)
ppdd -ecs
p = number of players (health bar?)
d = difficulty
*- = unknown / unused (no observed effect)
e = extend score
c = continue
s = demo sound
Switch 2 (byte 0x7d of eeprom)
cccC CCxb
ccc = coin1
CCC = coin 2
*x = breaks attract mode / game..
b = blood
items marked * the user can't configure in test mode
I don't know if any of the other bytes in the eeprom are tested / used.
1 in eeprom is 0 in test mode
Both games are currently configured to 3 buttons, its possible the game was never
released with a 2 button configuration.
NOTE: an actual read of the eeprom appears to be byteswapped vs. this data / the file
MAME outputs
*/
static DRIVER_INIT( simpl156 )
{
UINT8 *rom = memory_region(machine, "okimusic");
int length = memory_region_length(machine, "okimusic");
UINT8 *buf1 = auto_alloc_array(machine, UINT8, length);
UINT32 x;
/* hmm low address line goes to banking chip instead? */
for (x = 0; x < length; x++)
{
UINT32 addr;
addr = BITSWAP24 (x,23,22,21,0, 20,
19,18,17,16,
15,14,13,12,
11,10,9, 8,
7, 6, 5, 4,
3, 2, 1 );
buf1[addr] = rom[x];
}
memcpy(rom, buf1, length);
auto_free(machine, buf1);
deco56_decrypt_gfx(machine, "gfx1");
deco156_decrypt(machine);
}
static void reset_sound_region(void)
{
cpu_setbank( 5, memory_region(REGION_CPU2) + (banknum * 0x4000) + 0x10000 );
}
static READ32_HANDLER( a_bus_ctrl_r )
{
UINT32 *ROM = (UINT32 *)memory_region(REGION_USER1);
if(a_bus[0] & 0x00010000)//protection calculation is activated
{
if(offset == 3)
{
logerror("A-Bus control protection read at %06x with data = %08x\n",activecpu_get_pc(),a_bus[3]);
#ifdef MAME_DEBUG
popmessage("Prot read at %06x with data = %08x",activecpu_get_pc(),a_bus[3]);
#endif
switch(a_bus[3])
{
case 0x01230000://astrass,char data in test mode PC=60118f2
/*
TODO: the chars that are used are 8x8x4,but we need to convert them to
16x16x4 format.
[01] NULL
[02] NULL
[03] NULL
[04] NULL
[05] NULL
[06] NULL
[07] NULL
[08] NULL
[09] data 1
[10] data 2
[11] data 3
[12] data 4
[13] data 5
[14] data 6
[15] data 7
[16] data 8
2b5 = A (up-left)
2b6 = A (up-right)
2d1 = A (down-left)
2d0 = A (down-right)
2f2 = S (up-left)
2f3 = S (up-right)
311 = S (down-left)
310 = S (down-right)
2f4 = T (up-left)
2f5 = T (up-right)
2b7 = E (up-left) (not 2bc,maybe because the up-left corner of E is equal of B?)
2bd = E (up-right)
*/
internal_counter++;
if(char_offset == 0)
{
if(internal_counter > ((8*0x234)-1))
{
internal_counter = 0;
char_offset = 1;
}
return 0;
}
else
{
if(internal_counter > 8)
{
if(internal_counter > 15)
{
ctrl_index-=8;
internal_counter = 0;
}
ctrl_index++;
return ROM[ctrl_index];
}
else
{
ctrl_index++;
return ROM[ctrl_index];
}
}
case 0x10da0000://ffreveng, boot vectors at $6080000,test mode
ctrl_index++;
if(ctrl_index > 2)
return 0x234;
else
return vector_prot[ctrl_index-1];
case 0x10d70000://ffreveng, boot vectors at $6080000,attract mode
ctrl_index++;
return ROM[ctrl_index];
case 0x2c5b0000://sss
case 0x47f10000:
case 0xfcda0000:
case 0xb5e60000:
case 0x392c0000:
case 0x77c30000:
case 0x8a620000:
ctrl_index++;
return ROM[ctrl_index];
case 0x77770000: {//rsgun
UINT32 val =
((ctrl_index & 0xff)<<24) |
(((ctrl_index+1) & 0xff)<<16) |
(((ctrl_index+2) & 0xff)<<8) |
((ctrl_index+3) & 0xff);
if(ctrl_index & 0x100)
val &= 0x0f0f0f0f;
else
val &= 0xf0f0f0f0;
ctrl_index += 4;
return val;
}
case 0xff7f0000://elandore
if(a_bus[2] == 0xe69000f9)
{
ctrl_index++;
return ROM[ctrl_index];
}
else return 0x12345678;
case 0xffbf0000:
ctrl_index++;
return ROM[ctrl_index];
}
}
return a_bus[offset];
}
else
{
if(a_bus[offset] != 0) return a_bus[offset];
else return ROM[(0x02fffff0/4)+offset];
}
}
static READ8_HANDLER( speech_rom_r )
{
return memory_region(REGION_SOUND1)[0x100 * (speech_p2 & 0x3f) + offset];
}
static READ_HANDLER( exprraid_prot_0_r )
{
unsigned char *RAM = memory_region(REGION_CPU1);
return RAM[0x02a9];
}
static void undrfire_draw_sprites_16x16(mame_bitmap *bitmap,const rectangle *cliprect,int *primasks,int x_offs,int y_offs)
{
UINT16 *spritemap = (UINT16 *)memory_region(REGION_USER1);
int offs, data, tilenum, color, flipx, flipy;
int x, y, priority, dblsize, curx, cury;
int sprites_flipscreen = 0;
int zoomx, zoomy, zx, zy;
int sprite_chunk,map_offset,code,j,k,px,py;
int dimension,total_chunks,bad_chunks;
/* pdrawgfx() needs us to draw sprites front to back, so we have to build a list
while processing sprite ram and then draw them all at the end */
struct tempsprite *sprite_ptr = spritelist;
for (offs = (spriteram_size/4-4);offs >= 0;offs -= 4)
{
data = spriteram32[offs+0];
flipx = (data & 0x00800000) >> 23;
zoomx = (data & 0x007f0000) >> 16;
tilenum = (data & 0x00007fff);
data = spriteram32[offs+2];
priority = (data & 0x000c0000) >> 18;
color = (data & 0x0003fc00) >> 10;
x = (data & 0x000003ff);
data = spriteram32[offs+3];
dblsize = (data & 0x00040000) >> 18;
flipy = (data & 0x00020000) >> 17;
zoomy = (data & 0x0001fc00) >> 10;
y = (data & 0x000003ff);
color |= (0x100 + (priority << 6)); /* priority bits select color bank */
color /= 2; /* as sprites are 5bpp */
flipy = !flipy;
y = (-y &0x3ff);
if (!tilenum) continue;
flipy = !flipy;
zoomx += 1;
zoomy += 1;
y += y_offs;
/* treat coords as signed */
if (x>0x340) x -= 0x400;
if (y>0x340) y -= 0x400;
x -= x_offs;
bad_chunks = 0;
dimension = ((dblsize*2) + 2); /* 2 or 4 */
total_chunks = ((dblsize*3) + 1) << 2; /* 4 or 16 */
map_offset = tilenum << 2;
{
for (sprite_chunk=0;sprite_chunk<total_chunks;sprite_chunk++)
{
j = sprite_chunk / dimension; /* rows */
k = sprite_chunk % dimension; /* chunks per row */
px = k;
py = j;
/* pick tiles back to front for x and y flips */
if (flipx) px = dimension-1-k;
if (flipy) py = dimension-1-j;
code = spritemap[map_offset + px + (py<<(dblsize+1))];
if (code==0xffff)
{
bad_chunks += 1;
continue;
}
curx = x + ((k*zoomx)/dimension);
cury = y + ((j*zoomy)/dimension);
zx= x + (((k+1)*zoomx)/dimension) - curx;
zy= y + (((j+1)*zoomy)/dimension) - cury;
if (sprites_flipscreen)
{
/* -zx/y is there to fix zoomed sprite coords in screenflip.
drawgfxzoom does not know to draw from flip-side of sprites when
screen is flipped; so we must correct the coords ourselves. */
curx = 320 - curx - zx;
cury = 256 - cury - zy;
flipx = !flipx;
flipy = !flipy;
}
sprite_ptr->gfx = 0;
sprite_ptr->code = code;
sprite_ptr->color = color;
sprite_ptr->flipx = !flipx;
sprite_ptr->flipy = flipy;
sprite_ptr->x = curx;
sprite_ptr->y = cury;
sprite_ptr->zoomx = zx << 12;
sprite_ptr->zoomy = zy << 12;
if (primasks)
{
sprite_ptr->primask = primasks[priority];
sprite_ptr++;
}
else
{
drawgfxzoom(bitmap,Machine->gfx[sprite_ptr->gfx],
sprite_ptr->code,
sprite_ptr->color,
sprite_ptr->flipx,sprite_ptr->flipy,
sprite_ptr->x,sprite_ptr->y,
cliprect,TRANSPARENCY_PEN,0,
sprite_ptr->zoomx,sprite_ptr->zoomy);
}
}
}
if (bad_chunks)
logerror("Sprite number %04x had %02x invalid chunks\n",tilenum,bad_chunks);
}
/* this happens only if primsks != NULL */
while (sprite_ptr != spritelist)
{
sprite_ptr--;
pdrawgfxzoom(bitmap,Machine->gfx[sprite_ptr->gfx],
sprite_ptr->code,
sprite_ptr->color,
sprite_ptr->flipx,sprite_ptr->flipy,
sprite_ptr->x,sprite_ptr->y,
cliprect,TRANSPARENCY_PEN,0,
sprite_ptr->zoomx,sprite_ptr->zoomy,
sprite_ptr->primask);
}
}
static READ8_HANDLER( bank_r )
{
unsigned char* bank = memory_region(REGION_USER2);
return bank[offset + (malzak_bank1 * 0x0400)];
}
static WRITE8_HANDLER(writeB)
{
memory_set_bankptr(4, memory_region(REGION_SOUND1) + ((data & 0xf) * 0x8000));
}
}
videobank = lines & 0x10;
/* bit 5 = enable char ROM reading through the video RAM */
K052109_set_RMRD_line((lines & 0x20) ? ASSERT_LINE : CLEAR_LINE);
/* bit 6 is unknown, 1 most of the time */
/* bit 7 controls layer priority */
k88games_priority = lines & 0x80;
}
static MACHINE_INIT( 88games )
{
cpunum_set_info_ptr(0, CPUINFO_PTR_KONAMI_SETLINES_CALLBACK, (void *)k88games_banking);
paletteram = &memory_region(REGION_CPU1)[0x20000];
}
static DRIVER_INIT( 88games )
{
konami_rom_deinterleave_2(REGION_GFX1);
konami_rom_deinterleave_2(REGION_GFX2);
}
GAME( 1988, 88games, 0, 88games, 88games, 88games, ROT0, "Konami", "'88 Games" )
GAME( 1988, konami88, 88games, 88games, 88games, 88games, ROT0, "Konami", "Konami '88" )
GAME( 1988, hypsptsp, 88games, 88games, 88games, 88games, ROT0, "Konami", "Hyper Sports Special (Japan)" )
static void reset_sound_region(running_machine *machine)
{
memory_set_bankptr(machine, 10, memory_region(machine, "audiocpu") + (banknum * 0x4000) + 0x10000 );
}
static MACHINE_RESET(macs)
{
/*
BIOS ram init:
72CA: 01 C7 00 ld bc,$00C7
72CD: 11 9F FE ld de,$FE9F
72D0: 21 27 73 ld hl,$7327
72D3: ED B0 ldir
72D5: 3E C3 ld a,$C3
72D7: 32 16 E8 ld ($E816),a
72DA: 32 19 E8 ld ($E819),a
72DD: 21 9F FE ld hl,$FE9F
72E0: 22 17 E8 ld ($E817),hl
72E3: 21 E0 FE ld hl,$FEE0
72E6: 22 1A E8 ld ($E81A),hl
...
//bank change ? = set 5th bit in port $c0
...
72F8: 01 C7 00 ld bc,$00C7
72FB: 11 9F FE ld de,$FE9F
72FE: 21 27 73 ld hl,$7327
7301: ED B0 ldir
...
7305: 01 07 05 ld bc,$0507
7308: 11 00 F8 ld de,$F800
730B: 21 FA 73 ld hl,$73FA
730E: ED B0 ldir
...
*/
memcpy(macs_ram1 + 0x0e9f, memory_region(REGION_USER1)+0x7327, 0xc7);
memcpy(macs_ram1 + 0x1e9f, memory_region(REGION_USER1)+0x7327, 0xc7);
memcpy(macs_ram1 + 0x0800, memory_region(REGION_USER1)+0x73fa, 0x507);
memcpy(macs_ram1 + 0x1800, memory_region(REGION_USER1)+0x73fa, 0x507);
#define MAKEJMP(n,m) macs_ram2[(n) - 0xe800 + 0]=0xc3;\
macs_ram2[(n) - 0xe800 + 1]=(m)&0xff;\
macs_ram2[(n) - 0xe800 + 2]=((m)>>8)&0xff;
MAKEJMP(0xe810, 0xfe4b);
MAKEJMP(0xe816, 0xfe9f);
MAKEJMP(0xe81a, 0xfee0);
#undef MAKEJMP
{
int i;
for(i=0; i<160; i++)
{
macs_ram1[0xe00+i]=ramdata[i];
macs_ram1[0x1e00+i]=ramdata[i];
}
}
macs_ram1[0x0f67]=0xff;
macs_ram1[0x1f67]=0xff;
macs_ram1[0x0ff6]=0x02;
macs_ram1[0x1ff6]=0x02;
macs_ram1[0x0ff7]=0x08;
macs_ram1[0x1ff7]=0x08;
macs_ram1[0x0ff8]=0x6c;
macs_ram1[0x1ff8]=0x6c;
macs_ram1[0x0ff9]=0x07;
macs_ram1[0x1ff9]=0x07;
memory_set_bankptr( 1, memory_region(REGION_CPU1) + 0x10000 );
memory_set_bankptr( 2, macs_ram1+0x800);
memory_set_bankptr( 3, macs_ram1+0x10000);
}
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x7006, 0x7006, 0, 0, gteikob2_flip_screen_x_w);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x7007, 0x7007, 0, 0, gteikob2_flip_screen_y_w);
}
DRIVER_INIT( azurian )
{
driver_init_pisces(machine);
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x6800, 0x6800, 0, 0, azurian_IN1_r);
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x7000, 0x7000, 0, 0, azurian_IN2_r);
}
DRIVER_INIT( 4in1 )
{
offs_t i;
UINT8 *RAM = memory_region(REGION_CPU1);
/* Decrypt Program Roms */
for (i = 0; i < memory_region_length(REGION_CPU1); i++)
RAM[i] = RAM[i] ^ (i & 0xff);
/* games are banked at 0x0000 - 0x3fff */
memory_configure_bank(1, 0, 4, &RAM[0x10000], 0x4000);
_4in1_bank_w(0, 0); /* set the initial CPU bank */
state_save_register_global(_4in1_bank);
}
INTERRUPT_GEN( hunchbks_vh_interrupt )
{
static READ8_HANDLER( trvquest_question_r )
{
gameplan_state *state = space->machine->driver_data<gameplan_state>();
return memory_region(space->machine, "questions")[*state->trvquest_question * 0x2000 + offset];
}
static void mcatadv_drawsprites ( struct mame_bitmap *bitmap, const struct rectangle *cliprect )
{
data16_t *source = spriteram_old;
data16_t *finish = source + (spriteram_size/2)/2;
int global_x = mcatadv_vidregs[0]-0x184;
int global_y = mcatadv_vidregs[1]-0x1f1;
UINT16 *destline;
UINT8 *priline;
int xstart, xend, xinc;
int ystart, yend, yinc;
if( vidregs_old[2] == 0x0001 ) /* Double Buffered */
{
source += (spriteram_size/2)/2;
finish += (spriteram_size/2)/2;
}
else if( vidregs_old[2] ) /* I suppose it's possible that there is 4 banks, haven't seen it used though */
{
logerror("Spritebank != 0/1\n");
}
while ( source<finish )
{
int pen = (source[0]&0x3f00)>>8;
int tileno = source[1]&0xffff;
int pri = (source[0]&0xc000)>>14;
int x = source[2]&0x3ff;
int y = source[3]&0x3ff;
int flipy = source[0] & 0x0040;
int flipx = source[0] & 0x0080;
int height = ((source[3]&0xf000)>>12)*16;
int width = ((source[2]&0xf000)>>12)*16;
int offset = tileno * 256;
data8_t *sprdata = memory_region ( REGION_GFX1 );
int drawxpos, drawypos;
int xcnt,ycnt;
int pix;
if (x & 0x200) x-=0x400;
if (y & 0x200) y-=0x400;
#if 0 // For Flipscreen/Cocktail
if(mcatadv_vidregs[0]&0x8000)
{
flipx = !flipx;
}
if(mcatadv_vidregs[1]&0x8000)
{
flipy = !flipy;
}
#endif
if (source[3] != source[0]) // 'hack' don't draw sprites while its testing the ram!
{
if(!flipx) { xstart = 0; xend = width; xinc = 1; }
else { xstart = width-1; xend = -1; xinc = -1; }
if(!flipy) { ystart = 0; yend = height; yinc = 1; }
else { ystart = height-1; yend = -1; yinc = -1; }
for (ycnt = ystart; ycnt != yend; ycnt += yinc) {
drawypos = y+ycnt-global_y;
if ((drawypos >= cliprect->min_y) && (drawypos <= cliprect->max_y)) {
destline = (UINT16 *)(bitmap->line[drawypos]);
priline = (UINT8 *)(priority_bitmap->line[drawypos]);
for (xcnt = xstart; xcnt != xend; xcnt += xinc) {
drawxpos = x+xcnt-global_x;
if (offset >= 0x500000*2) offset = 0;
pix = sprdata[offset/2];
if (offset & 1) pix = pix >> 4;
pix &= 0x0f;
if ((drawxpos >= cliprect->min_x) && (drawxpos <= cliprect->max_x) && pix)
if((priline[drawxpos] < pri))
destline[drawxpos] = (pix + (pen<<4));
offset++;
}
}
else {
offset += width;
}
}
}
static MACHINE_INIT(EFO) {
sndbrd_0_init(core_gameData->hw.soundBoard, 1, memory_region(REGION_CPU2), NULL, NULL);
ctc_intf.baseclock[2] = Machine->drv->cpu[0].cpu_clock;
z80ctc_init(&ctc_intf);
timer_pulse(TIME_IN_HZ(2000000), 0, ck0_pulse);
}
static WRITE8_HANDLER( banksel_2_1_w )
{
memory_set_bankptr(1,memory_region(REGION_CPU1) + 0x14000);
}
static void command_verify_memory(void)
{
int i = 0;
offs_t offset, offset_start, offset_end;
const UINT8 *verify_data;
size_t verify_data_size;
const UINT8 *target_data;
size_t target_data_size;
int region;
offset_start = current_command->u.verify_args.start;
offset_end = current_command->u.verify_args.end;
verify_data = (const UINT8 *) current_command->u.verify_args.verify_data;
verify_data_size = current_command->u.verify_args.verify_data_size;
if (offset_end == 0)
offset_end = offset_start + verify_data_size - 1;
region = current_command->u.verify_args.mem_region;
if (region)
{
target_data = memory_region(region);
target_data_size = memory_region_length(region);
}
else
{
target_data = mess_ram;
target_data_size = mess_ram_size;
}
/* sanity check the ranges */
if (!verify_data || (verify_data_size <= 0))
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Invalid memory region during verify");
return;
}
if (offset_start > offset_end)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Invalid verify offset range (0x%x-0x%x)", offset_start, offset_end);
return;
}
if (offset_end >= target_data_size)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Verify memory range out of bounds");
return;
}
for (offset = offset_start; offset <= offset_end; offset++)
{
if (verify_data[i] != target_data[offset])
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Failed verification step (REGION_%s; 0x%x-0x%x)",
memory_region_to_string(region), offset_start, offset_end);
break;
}
i = (i + 1) % verify_data_size;
}
}
hyperpac_ram[0xe080/2] = 0xfedc;
hyperpac_ram[0xe082/2] = 0xba98;
hyperpac_ram[0xe084/2] = 0x7654;
hyperpac_ram[0xe086/2] = 0x3210;
}
READ16_HANDLER ( _4in1_02_read )
{
return 0x0202;
}
static DRIVER_INIT(4in1boot)
{
unsigned char *buffer;
data8_t *src = memory_region(REGION_CPU1);
int len = memory_region_length(REGION_CPU1);
/* strange order */
if ((buffer = malloc(len)))
{
int i;
for (i = 0;i < len; i++)
if (i&1) buffer[i] = BITSWAP8(src[i],6,7,5,4,3,2,1,0);
else buffer[i] = src[i];
memcpy(src,buffer,len);
free(buffer);
}
src = memory_region(REGION_CPU2);
MACHINE_DRIVER_END
/* Genie's Hardware (contains no real sega parts) */
/***************************************************************************
Puckman Pokemon Genie 2000
(c) 2000? Manufacturer ?
Hardware looks bootleg-ish, but is newly manufactured.
CPU: ? (one of the SMD chips)
SND: OKI6295, U6612 (probably YM3812), U6614B (Probably YM3014B)
XTAL: 3.579545MHz, 4.0000MHz
OSC: 53.693175MHz
Other Chips: Possible CPU: TA-06SD 9933 B816453 128 pin square SMD
GFX support chips: Y-BOX TA891945 100 pin SMD
TV16B 0010 ME251271 160 pin SMD
There are 13 PAL's on the PCB !
RAM: 62256 x 3, D41264 x 2 (ZIP Ram)
DIPS: 2 x 8 position
SW1:
1 2 3 4 5 6 7 8
coins 1coin 1 Cred. off off off
2c 1c on off off
3c 1c off on off
4c 1c on on off
5c 1c off off on
1c 2c on off on
1c 3c off on on
1c 4c on on on
players 1 off off off
2 on off off
3 off on off
4 on on off
5 off off on
6 on off on
7 off on on
8 on on on
diffic-
ulty v.easy off off
normal on off
diffic. off on
v. diffic. on on
SW2
note position 3-8 not used
1 2 3 4 5 6 7 8
test mode no off
yes on
demo sound yes off
no on
ROMS:
PUCKPOKE.U3 M5M27C201 Sound
PUCKPOKE.U4 27C040--\
PUCKPOKE.U5 27C040---\
PUCKPOKE.U7 27C040----- Main program & GFX
PUCKPOKE.U8 27C4001---/
ROM sockets U63 & U64 empty
Hi-res PCB scan available on request.
Screenshots available on my site at http://unemulated.emuunlim.com (under PCB Shop Raid #2)
****************************************************************************/
static DRIVER_INIT( puckpkmn )
{
UINT8 *rom = memory_region(machine, "maincpu");
size_t len = memory_region_length(machine, "maincpu");
int i;
for (i = 0; i < len; i++)
rom[i] = BITSWAP8(rom[i],1,4,2,0,7,5,3,6);
DRIVER_INIT_CALL(megadriv);
}
static READ_HANDLER( starshp1_zeropage_r )
{
return memory_region(REGION_CPU1)[offset & 0xff];
}
void master6801_behaviour(int offset, int data)
{
/*
The Master MC6801 controls all AdamNet operations, keyboard, tapes, disks...
We are going to "simulate" the behaviour of the master 6801, because we does not have the 2kbytes ROM DUMP
If you have the source listing or the Rom dump, please send us.
*/
int DCB_Num, deviceNum, statusDCB;
int i, buffer, byteCount, sectorNmbr, sectorCount, currentSector;
UINT8 kbcode;
static UINT8 interleave[8] = {0,5,2,7,4,1,6,3};
mess_image *image;
if (offset == adam_pcb)
{
switch (data)
{
case 1: /* Request to synchronize the Z80 clock */
memory_region(REGION_CPU1)[offset] = 0x81;
//printf("Synchronizing the Z80 clock\n");
break;
case 2: /* Request to synchronize the Master 6801 clock */
memory_region(REGION_CPU1)[offset] = 0x82;
//printf("Synchronizing the Master 6801 clock\n");
break;
case 3: /* Request to relocate adam_pcb */
memory_region(REGION_CPU1)[offset] = 0x83; /* Must return 0x83 if success */
//memory_region(REGION_CPU1)[offset] = 0x9B; /* Time Out */
printf("Request to relocate adam_pcb from %04Xh to %04Xh... not implemented... but returns OK\n", adam_pcb, (memory_region(REGION_CPU1)[adam_pcb+1]&memory_region(REGION_CPU1)[adam_pcb+2]<<8));
break;
}
}
for(DCB_Num=1;DCB_Num<=memory_region(REGION_CPU1)[adam_pcb+3];DCB_Num++) /* Test status of each DCB in adam_pcb table */
{
statusDCB = (adam_pcb+4)+(DCB_Num-1)*21;
if (offset==statusDCB)
{
//printf("Accesing DCB %02Xh\n", DCB_Num);
deviceNum = (memory_region(REGION_CPU1)[statusDCB+0x10]&0x0F)+(memory_region(REGION_CPU1)[statusDCB+0x09]<<4);
buffer=(memory_region(REGION_CPU1)[statusDCB+0x01])+(memory_region(REGION_CPU1)[statusDCB+0x02]<<8);
byteCount=(memory_region(REGION_CPU1)[statusDCB+0x03])+(memory_region(REGION_CPU1)[statusDCB+0x04]<<8);
if (deviceNum>=4 && deviceNum<=7)
{
image = image_from_devtype_and_index(IO_FLOPPY, deviceNum - 4);
if (image_exists(image))
memory_region(REGION_CPU1)[statusDCB+20] = (memory_region(REGION_CPU1)[statusDCB+20]&0xF0); /* Inserted Media */
else
memory_region(REGION_CPU1)[statusDCB+20] = (memory_region(REGION_CPU1)[statusDCB+20]&0xF0)|0x03; /* No Media on Drive*/
}
switch (data)
{
case 0: /* Initialize Drive */
if (deviceNum>=4 && deviceNum<=7)
{
memory_region(REGION_CPU1)[statusDCB] = 0x80;
}
break;
case 1: /* Return current status */
if (deviceNum==1||deviceNum==2)
{
memory_region(REGION_CPU1)[statusDCB] = 0x80; /* Device Found (1=Keyboard, 2=Printer) */
memory_region(REGION_CPU1)[statusDCB+0x13] = 0x01; /* Character device */
}
else if (deviceNum>=4 && deviceNum<=7)
{
image = image_from_devtype_and_index(IO_FLOPPY, deviceNum - 4);
if (image_exists(image))
{
memory_region(REGION_CPU1)[statusDCB] = 0x80;
memory_region(REGION_CPU1)[statusDCB+17] = 1024&255;
memory_region(REGION_CPU1)[statusDCB+18] = 1024>>8;
}
else
{
memory_region(REGION_CPU1)[statusDCB] = 0x83; /* Device Found but No Disk in Drive*/
}
}
else
{