C# Mame类代码示例

        static void draw_sprites(Mame.osd_bitmap bitmap)
        {
            /* sprite information is scattered through memory */
            /* and uses a portion of the text layer memory (outside the visible area) */
            _BytePtr spriteram_area1 = new _BytePtr(Generic.spriteram, 0x28);
            _BytePtr spriteram_area2 = new _BytePtr(Generic.spriteram_2, 0x28);
            _BytePtr spriteram_area3 = new _BytePtr(driver_kyugo.kyugo_videoram, 0x28);

            for (int n = 0; n < 12 * 2; n++)
            {
                int offs = 2 * (n % 12) + 64 * (n / 12);

                int sx = spriteram_area3[offs + 1] + 256 * (spriteram_area2[offs + 1] & 1);
                if (sx > 320) sx -= 512;

                int sy = 255 - spriteram_area1[offs];
                if (driver_kyugo.flipscreen != 0) sy = 240 - sy;

                int color = spriteram_area1[offs + 1] & 0x1f;

                for (int y = 0; y < 16; y++)
                {
                    int attr2 = spriteram_area2[offs + 128 * y];
                    int code = spriteram_area3[offs + 128 * y];
                    if ((attr2 & 0x01) != 0) code += 512;
                    if ((attr2 & 0x02) != 0) code += 256;
                    bool flipx = (attr2 & 0x08) != 0;
                    bool flipy = (attr2 & 0x04) != 0;
                    if (driver_kyugo.flipscreen != 0)
                    {
                        flipx = !flipx;
                        flipy = !flipy;
                    }

                    Mame.drawgfx(bitmap, Mame.Machine.gfx[1],
                        (uint)code,
                        (uint)color,
                        flipx, flipy,
                        sx, driver_kyugo.flipscreen != 0 ? sy - 16 * y : sy + 16 * y,
                        Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_PEN, 0);
                }
            }
        }

            static void draw_background(Mame.osd_bitmap bitmap)
            {
                Mame.GfxElement gfx = Mame.Machine.gfx[0];

                for (int offs = Generic.videoram_size[0] - 2; offs >= 0; offs -= 2)
                {
                    if (Generic.dirtybuffer[offs] || Generic.dirtybuffer[offs + 1])
                    {
                        Generic.dirtybuffer[offs] = Generic.dirtybuffer[offs + 1] = false;

                        int sx = (offs / 2) % 32;
                        int sy = (offs / 2) / 32;

                        int attr = Generic.videoram[offs];
                        int code = Generic.videoram[offs + 1] + ((attr & 0xc0) << 2);
                        bool flipx = (attr & 0x20) != 0;

                        if (flipscreen != 0)
                        {
                            sx = 31 - sx;
                            sy = 31 - sy;
                            flipx = !flipx;
                        }

                        Mame.drawgfx(Generic.tmpbitmap, gfx,
                            (uint)code,
                            (uint)attr & 0x1f,
                            flipx, flipscreen != 0,
                            8 * sx, 8 * sy,
                            null, Mame.TRANSPARENCY_NONE, 0);
                    }
                }

                {
                    int[] xscroll = new int[256];

                    if (flipscreen != 0)
                    {
                        /* fixed */
                        for (int offs = 0; offs < 64; offs++) xscroll[255 - offs] = 0;

                        /* scroll (wraps around) */
                        for (int offs = 64; offs < 128; offs++) xscroll[255 - offs] = troangel_scroll[64];

                        /* linescroll (no wrap) */
                        for (int offs = 128; offs < 256; offs++) xscroll[255 - offs] = troangel_scroll[offs];
                    }
                    else
                    {
                        /* fixed */
                        for (int offs = 0; offs < 64; offs++) xscroll[offs] = 0;

                        /* scroll (wraps around) */
                        for (int offs = 64; offs < 128; offs++) xscroll[offs] = -troangel_scroll[64];

                        /* linescroll (no wrap) */
                        for (int offs = 128; offs < 256; offs++) xscroll[offs] = -troangel_scroll[offs];
                    }

                    Mame.copyscrollbitmap(bitmap, Generic.tmpbitmap, 256, xscroll, 0, null, Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);
                }
            }

 public namcos1_specific(int key_id_query, int key_id, Mame.mem_read_handler key_r, Mame.mem_write_handler key_w,
     namcos1_slice_timer[] slice_timer, int tilemap_use)
 {
     this.key_id_query = key_id_query;
     this.key_id = key_id;
     this.key_r = key_r;
     this.key_w = key_w;
     this.slice_timer = slice_timer;
     this.tilemap_use = tilemap_use;
 }

            public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
            {
                /* for every character in the video RAM, check if it has been modified */
                /* since last time and update it accordingly. */
                for (int offs = Generic.videoram_size[0] - 1; offs >= 0; offs--)
                {
                    if (Generic.dirtybuffer[offs])
                    {
                        int sx, sy, mx, my;

                        Generic.dirtybuffer[offs] = false;

                        /* Even if Phozon screen is 28x36, the memory layout is 32x32. We therefore
                        have to convert the memory coordinates into screen coordinates.
                        Note that 32*32 = 1024, while 28*36 = 1008: therefore 16 bytes of Video RAM
                        don't map to a screen position. We don't check that here, however: range
                        checking is performed by drawgfx(). */

                        mx = offs % 32;
                        my = offs / 32;

                        if (my <= 1)
                        {       /* bottom screen characters */
                            sx = my + 34;
                            sy = mx - 2;
                        }
                        else if (my >= 30)
                        {	/* top screen characters */
                            sx = my - 30;
                            sy = mx - 2;
                        }
                        else
                        {               /* middle screen characters */
                            sx = mx + 2;
                            sy = my - 2;
                        }

                        Mame.drawgfx(Generic.tmpbitmap, Mame.Machine.gfx[(Generic.colorram[offs] & 0x80) != 0 ? 1 : 0],
                                 Generic.videoram[offs],
                                 (uint)(Generic.colorram[offs] & 0x3f),
                                false, false,
                                8 * sx, 8 * sy,
                                Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);
                    }
                }

                Mame.copybitmap(bitmap, Generic.tmpbitmap, false, false, 0, 0, Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);

                /* Draw the sprites. */
                for (int offs = 0; offs < Generic.spriteram_size[0]; offs += 2)
                {
                    /* is it on? */
                    if ((Generic.spriteram_3[offs + 1] & 2) == 0)
                    {
                        uint sprite = Generic.spriteram[offs];
                        uint color = Generic.spriteram[offs + 1];
                        int x = (Generic.spriteram_2[offs + 1] - 69) + 0x100 * (Generic.spriteram_3[offs + 1] & 1);
                        int y = (Mame.Machine.drv.screen_height) - Generic.spriteram_2[offs] - 8;
                        int flipx = Generic.spriteram_3[offs] & 1;
                        int flipy = Generic.spriteram_3[offs] & 2;

                        switch (Generic.spriteram_3[offs] & 0x3c)
                        {
                            case 0x00:		/* 16x16 */
                                phozon_draw_sprite(bitmap, sprite, color, flipx, flipy, x, y);
                                break;

                            case 0x14:		/* 8x8 */
                                sprite = (uint)((sprite << 2) | ((Generic.spriteram_3[offs] & 0xc0) >> 6));
                                phozon_draw_sprite8(bitmap, sprite, color, flipx, flipy, x, y + 8);
                                break;

                            case 0x04:		/* 8x16 */
                                sprite = (uint)((sprite << 2) | ((Generic.spriteram_3[offs] & 0xc0) >> 6));
                                if (flipy == 0)
                                {
                                    phozon_draw_sprite8(bitmap, 2 + sprite, color, flipx, flipy, x, y + 8);
                                    phozon_draw_sprite8(bitmap, sprite, color, flipx, flipy, x, y);
                                }
                                else
                                {
                                    phozon_draw_sprite8(bitmap, 2 + sprite, color, flipx, flipy, x, y);
                                    phozon_draw_sprite8(bitmap, sprite, color, flipx, flipy, x, y + 8);
                                }
                                break;

                            case 0x24:		/* 8x32 */
                                sprite = (uint)((sprite << 2) | ((Generic.spriteram_3[offs] & 0xc0) >> 6));
                                if (flipy == 0)
                                {
                                    phozon_draw_sprite8(bitmap, 10 + sprite, color, flipx, flipy, x, y + 8);
                                    phozon_draw_sprite8(bitmap, 8 + sprite, color, flipx, flipy, x, y);
                                    phozon_draw_sprite8(bitmap, 2 + sprite, color, flipx, flipy, x, y - 8);
                                    phozon_draw_sprite8(bitmap, sprite, color, flipx, flipy, x, y - 16);
                                }
                                else
                                {
                                    phozon_draw_sprite8(bitmap, 10 + sprite, color, flipx, flipy, x, y - 16);
                                    phozon_draw_sprite8(bitmap, 8 + sprite, color, flipx, flipy, x, y - 8);
                                    phozon_draw_sprite8(bitmap, 2 + sprite, color, flipx, flipy, x, y);
//.........这里部分代码省略.........

            public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
            {

                Mame.palette_init_used_colors();

                for (int offs = Generic.videoram_size[0] - 1; offs >= 0; offs--)
                {
                    int code, color;

                    code = Mame.memory_region(Mame.REGION_GFX4)[0x1000 * bg_image + offs];
                    color = Mame.memory_region(Mame.REGION_GFX4)[0xc000 + 0x100 * bg_image + code];
                    for (int i = 0; i < 16; i++) Mame.palette_used_colors[i + 256 + 16 * color] = Mame.PALETTE_COLOR_USED;
                }
                for (int offs = 0; offs < 256; offs++)
                {
                    int color;

                    color = citycon_charlookup[offs];
                    Mame.palette_used_colors[512 + 4 * color] = Mame.PALETTE_COLOR_TRANSPARENT;
                    for (int i = 0; i < 3; i++) Mame.palette_used_colors[i + 512 + 4 * color + 1] = Mame.PALETTE_COLOR_USED; ;
                }
                for (int offs = Generic.spriteram_size[0] - 4; offs >= 0; offs -= 4)
                {
                    int color;

                    color = Generic.spriteram[offs + 2] & 0x0f;
                    for (int i = 0; i < 15; i++) Mame.palette_used_colors[i + 16 * color + 1] = Mame.PALETTE_COLOR_USED;
                }

                if (Mame.palette_recalc() != null)
                {
                    Generic.SetDirtyBuffer(true);
                    dirty_background = 1;
                }

                /* Create the background */
                if (dirty_background != 0)
                {
                    dirty_background = 0;

                    for (int offs = Generic.videoram_size[0] - 1; offs >= 0; offs--)
                    {
                        int sx, sy, code;


                        sy = offs / 32;
                        sx = (offs % 32) + (sy & 0x60);
                        sy = sy & 31;
                        if (flipscreen != 0)
                        {
                            sx = 127 - sx;
                            sy = 31 - sy;
                        }

                        code = Mame.memory_region(Mame.REGION_GFX4)[0x1000 * bg_image + offs];

                        Mame.drawgfx(tmpbitmap2, Mame.Machine.gfx[3 + bg_image],
                                (uint)code,
                                Mame.memory_region(Mame.REGION_GFX4)[0xc000 + 0x100 * bg_image + code],
                                flipscreen != 0, flipscreen != 0,
                                8 * sx, 8 * sy,
                                null, Mame.TRANSPARENCY_NONE, 0);
                    }
                }

                /* copy the temporary bitmap to the screen */
                {
                    int scroll;

                    if (flipscreen != 0)
                        scroll = 256 + ((citycon_scroll[0] * 256 + citycon_scroll[1]) >> 1);
                    else
                        scroll = -((citycon_scroll[0] * 256 + citycon_scroll[1]) >> 1);

                    Mame.copyscrollbitmap(bitmap, tmpbitmap2, 1, new int[] { scroll }, 0, null, Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);
                }


                /* for every character in the Video RAM, check if it has been modified */
                /* since last time and update it accordingly. */
                for (int offs = Generic.videoram_size[0] - 1; offs >= 0; offs--)
                {
                    int sx, sy;


                    sy = offs / 32;
                    sx = (offs % 32) + (sy & 0x60);
                    sy = sy & 0x1f;

                    if (Generic.dirtybuffer[offs] || dirtylookup[sy])
                    {
                        int i;
                        Mame.rectangle clip = new Mame.rectangle();


                        Generic.dirtybuffer[offs] = false;

                        if (flipscreen != 0)
                        {
                            sx = 127 - sx;
//.........这里部分代码省略.........

        public static void tecmo_vh_screenrefresh(Mame.osd_bitmap bitmap, int full_refresh)
        {
            int offs;


            Mame.palette_init_used_colors();

            {
                int color, code, i;
                int[] colmask = new int[16];
                int pal_base;


                pal_base = Mame.Machine.drv.gfxdecodeinfo[5].color_codes_start;

                for (color = 0; color < 16; color++) colmask[color] = 0;

                for (offs = Generic.videoram_size[0] - 1; offs >= 0; offs--)
                {
                    if (video_type == 2)	/* Gemini Wing */
                    {
                        code = Generic.videoram[offs] + 16 * (Generic.colorram[offs] & 0x70);
                        color = Generic.colorram[offs] & 0x0f;
                    }
                    else
                    {
                        code = Generic.videoram[offs] + 256 * (Generic.colorram[offs] & 0x07);
                        color = Generic.colorram[offs] >> 4;
                    }

                    colmask[color] |= (int)Mame.Machine.gfx[5].pen_usage[code];
                }

                for (color = 0; color < 16; color++)
                {
                    if ((colmask[color] & (1 << 0)) != 0)
                        Mame.palette_used_colors[pal_base + 16 * color] = Mame.PALETTE_COLOR_TRANSPARENT;
                    for (i = 1; i < 16; i++)
                    {
                        if ((colmask[color] & (1 << i)) != 0)
                            Mame.palette_used_colors[pal_base + 16 * color + i] = Mame.PALETTE_COLOR_USED;
                    }
                }


                pal_base = Mame.Machine.drv.gfxdecodeinfo[4].color_codes_start;

                for (color = 0; color < 16; color++) colmask[color] = 0;

                for (offs = Generic.videoram_size[0] - 1; offs >= 0; offs--)
                {
                    if (video_type == 2)	/* Gemini Wing */
                    {
                        code = tecmo_videoram[offs] + 16 * (tecmo_colorram[offs] & 0x70);
                        color = tecmo_colorram[offs] & 0x0f;
                    }
                    else
                    {
                        code = tecmo_videoram[offs] + 256 * (tecmo_colorram[offs] & 0x07);
                        color = tecmo_colorram[offs] >> 4;
                    }

                    colmask[color] |= (int)Mame.Machine.gfx[4].pen_usage[code];
                }

                for (color = 0; color < 16; color++)
                {
                    if ((colmask[color] & (1 << 0)) != 0)
                        Mame.palette_used_colors[pal_base + 16 * color] = Mame.PALETTE_COLOR_TRANSPARENT;
                    for (i = 1; i < 16; i++)
                    {
                        if ((colmask[color] & (1 << i)) != 0)
                            Mame.palette_used_colors[pal_base + 16 * color + i] = Mame.PALETTE_COLOR_USED;
                    }
                }


                pal_base = Mame.Machine.drv.gfxdecodeinfo[1].color_codes_start;

                for (color = 0; color < 16; color++) colmask[color] = 0;

                for (offs = 0; offs < Generic.spriteram_size[0]; offs += 8)
                {
                    int flags = Generic.spriteram[offs + 3];
                    int bank = Generic.spriteram[offs + 0];
                    if ((bank & 4) != 0)
                    { /* visible */
                        int which = Generic.spriteram[offs + 1];
                        int size = (Generic.spriteram[offs + 2] & 3);
                        /* 0 = 8x8 1 = 16x16 2 = 32x32 3 = 64x64 */
                        if (size == 3) continue;	/* not used by these games */


                        if (video_type != 0)
                            code = (which) + ((bank & 0xf8) << 5); /* silkworm */
                        else
                            code = (which) + ((bank & 0xf0) << 4); /* rygar */

                        if (size == 1) code >>= 2;
                        else if (size == 2) code >>= 4;
//.........这里部分代码省略.........

            static void draw_sprites(Mame.osd_bitmap bitmap, int pri_mask)
            {
                int offs, fx, fy, x, y, color, sprite;

                for (offs = 0x1000 - 8; offs >= 0; offs -= 8)
                {
                    /* Don't draw empty sprite table entries */
                    if (Generic.buffered_spriteram[offs + 7] != 0xf) continue;
                    if (Generic.buffered_spriteram[offs + 0] == 0x0f) continue;
                    if ((pri_mask & Generic.buffered_spriteram[offs + 5]) == 0) continue;

                    fx = Generic.buffered_spriteram[offs + 1] & 0x20;
                    fy = Generic.buffered_spriteram[offs + 1] & 0x40;
                    y = Generic.buffered_spriteram[offs + 0];
                    x = Generic.buffered_spriteram[offs + 4];

                    if ((Generic.buffered_spriteram[offs + 5] & 1) != 0) x = 0 - (0x100 - x);

                    color = Generic.buffered_spriteram[offs + 1] & 0xf;
                    sprite = Generic.buffered_spriteram[offs + 2] + (Generic.buffered_spriteram[offs + 3] << 8);
                    sprite &= 0x0fff;

                    if (flipscreen != 0)
                    {
                        x = 240 - x;
                        y = 240 - y;
                        if (fx != 0) fx = 0; else fx = 1;
                        if (fy != 0) fy = 0; else fy = 1;
                    }

                    Mame.drawgfx(bitmap, Mame.Machine.gfx[3],
                            (uint)sprite,
                            (uint)color, fx != 0, fy != 0, x, y,
                            Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_PEN, 15);
                }
            }

        public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
        {
            Mame.tilemap_update(Mame.ALL_TILEMAPS);

            Mame.palette_init_used_colors();

            mark_sprites_palette();

            /* the following is required to make the colored background work */
            for (int i = 15; i < Mame.Machine.drv.total_colors; i += 16)
                Mame.palette_used_colors[i] = Mame.PALETTE_COLOR_TRANSPARENT;

            if (Mame.palette_recalc() != null)
                Mame.tilemap_mark_all_pixels_dirty(Mame.ALL_TILEMAPS);

            Mame.tilemap_render(Mame.ALL_TILEMAPS);

            Mame.tilemap_draw(bitmap, driver_mitchell.bg_tilemap, 0);

            draw_sprites(bitmap);
        }

            public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
            {
                if (Mame.palette_recalc() != null)
                {
                    /* if we ran out of palette entries, rebuild the whole screen */
                    for (int y = 0; y < 256; y++)
                    {
                        for (int x = 0; x < 320; x += 2)
                        {
                            updatepixels(x, y);
                        }
                    }
                }

                Mame.copybitmap(bitmap, Generic.tmpbitmap, false, false, 0, 0, Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);

                {
                    int color = Mame.Machine.pens[512];

                    for (int y = 0; y < 256; y++)
                    {
                        for (int x = 0; x < 320; x += 8)
                        {
                            int d = blockout_frontvideoram.READ_WORD(y * 128 + (x / 4));

                            if (d != 0)
                            {
                                if ((d & 0x80) != 0) Mame.plot_pixel(bitmap, x, y, color);
                                if ((d & 0x40) != 0) Mame.plot_pixel(bitmap, x + 1, y, color);
                                if ((d & 0x20) != 0) Mame.plot_pixel(bitmap, x + 2, y, color);
                                if ((d & 0x10) != 0) Mame.plot_pixel(bitmap, x + 3, y, color);
                                if ((d & 0x08) != 0) Mame.plot_pixel(bitmap, x + 4, y, color);
                                if ((d & 0x04) != 0) Mame.plot_pixel(bitmap, x + 5, y, color);
                                if ((d & 0x02) != 0) Mame.plot_pixel(bitmap, x + 6, y, color);
                                if ((d & 0x01) != 0) Mame.plot_pixel(bitmap, x + 7, y, color);
                            }
                        }
                    }
                }

            }

            public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
            {
                for (int offs = Generic.videoram_size[0] - 2; offs >= 0; offs -= 2)
                {
                    int offs2;

                    offs2 = offs / 2;
                    if (Generic.dirtybuffer[offs] || Generic.dirtybuffer[offs + 1])
                    {
                        int sx, sy, code;


                        Generic.dirtybuffer[offs] = false;
                        Generic.dirtybuffer[offs + 1] = false;

                        sx = offs2 % 32;
                        sy = offs2 / 32;

                        if (flipscreen[0] != 0) sx = 31 - sx;
                        if (flipscreen[1] != 0) sy = 31 - sy;

                        code = Generic.videoram[offs + 1] + ((Generic.videoram[offs] & 0x07) << 8) + 2048 * gfxbank;
                        Mame.drawgfx(Generic.tmpbitmap, Mame.Machine.gfx[0],
                                (uint)code,
                                (uint)(((Generic.videoram[offs] & 0xf8) >> 3) + 32 * palettebank),
                                flipscreen[0] != 0, flipscreen[1] != 0,
                                8 * sx, 8 * sy,
                                Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);
                    }
                }


                /* copy the temporary bitmap to the screen */
                Mame.copybitmap(bitmap, Generic.tmpbitmap, false, false, 0, 0, Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);


                /* Draw the sprites. */
                for (int offs = 0; offs < Generic.spriteram_size[0]; offs += 4)
                {
                    int sx, sy, code;


                    sx = Generic.spriteram[offs];
                    sy = 248 - Generic.spriteram[offs + 1];
                    if (flipscreen[0] != 0) sx = 248 - sx;
                    if (flipscreen[1] != 0) sy = 248 - sy;

                    code = Generic.spriteram[offs + 3] + ((Generic.spriteram[offs + 2] & 0x03) << 8) + 1024 * gfxbank;
                    Mame.drawgfx(bitmap, Mame.Machine.gfx[0],
                            (uint)(2 * code),
                            (uint)(((Generic.spriteram[offs + 2] & 0xf8) >> 3) + 32 * palettebank),
                            flipscreen[0] != 0, flipscreen[1] != 0,
                            sx, sy + (flipscreen[1] != 0 ? 8 : -8),
                            Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_PEN, 0);
                    Mame.drawgfx(bitmap, Mame.Machine.gfx[0],
                            (uint)(2 * code + 1),
                            (uint)(((Generic.spriteram[offs + 2] & 0xf8) >> 3) + 32 * palettebank),
                            flipscreen[0] != 0, flipscreen[1] != 0,
                            sx, sy,
                            Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_PEN, 0);
                }
            }

 public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
 {
     invaders_vh_screenrefresh(bitmap, full_refresh != 0);
 }

        public static void vh_screenrefresh(Mame.osd_bitmap bitmap, bool full_refresh)
        {
            if (Mame.palette_recalc() != null || redraw_screen != 0 || (full_refresh && use_tmpbitmap == 0))
            {
                int offs;

                for (offs = 0; offs < Generic.videoram_size[0]; offs++)
                    videoram_w_p(offs, Generic.videoram[offs]);

                redraw_screen = 0;

                if (overlay != null)
                    Mame.overlay_remap(overlay);
            }


            if (full_refresh && use_tmpbitmap != 0)
                /* copy the character mapped graphics */
                Mame.copybitmap(bitmap, Generic.tmpbitmap, false, false, 0, 0, Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_NONE, 0);

            if (overlay != null)
                Mame.overlay_draw(bitmap, overlay);
        }

 public static void invaders_vh_screenrefresh(Mame.osd_bitmap bitmap, bool full_refresh)
 {
     vh_screenrefresh_p(bitmap, full_refresh);
 }

 public override void vh_update(Mame.osd_bitmap bitmap, int full_refresh)
 {
     draw_background(bitmap);
     draw_sprites(bitmap);
 }

            static void draw_sprites(Mame.osd_bitmap bitmap)
            {
                for (int offs = Generic.spriteram_size[0] - 4; offs >= 0; offs -= 4)
                {
                    byte attributes = Generic.spriteram[offs + 1];
                    int sx = Generic.spriteram[offs + 3];
                    int sy = ((224 - Generic.spriteram[offs + 0] - 32) & 0xff) + 32;
                    int code = Generic.spriteram[offs + 2];
                    int color = attributes & 0x1f;
                    bool flipy = (attributes & 0x80) != 0;
                    bool flipx = (attributes & 0x40) != 0;

                    int tile_number = code & 0x3f;

                    int bank = 0;
                    if ((code & 0x80) != 0) bank += 1;
                    if ((attributes & 0x20) != 0) bank += 2;

                    if (flipscreen != 0)
                    {
                        sx = 240 - sx;
                        sy = 224 - sy;
                        flipx = !flipx;
                        flipy = !flipy;
                    }

                    Mame.drawgfx(bitmap, Mame.Machine.gfx[1 + bank],
                        (uint)tile_number,
                        (uint)color,
                        flipx, flipy,
                        sx, sy,
                        Mame.Machine.drv.visible_area, Mame.TRANSPARENCY_PEN, 0);
                }
            }