Virtual Donkey's Demo Scene (sgdk)

[Top l'âne]

Hey friends,

a couple of months since the Cursed Knight KickStarter.
This event choked me enough to bring me back to Megadrive software creation.

SGDK, here I am.

Here is a short demo to deal with various basic features.
Tile display and sprite engine, mainly.
First attempt with a tracker.
This was also the opportunity to code a bunch of paterns and remind a bit of C.


(ugly sound, low down the speaker...^^):

https://www.youtube.com/watch?v=hKQTZ2hk_UY


The demo runs good and shows quite accurately my previous goal.
I have a few ideas to improve the demo but don't want to spend much more time on it.

This first object is all the more a way to point out a few difficulties.


Here is the big problem... Colors!...:

I used a sided tool to create my bitmaps and "rescomp" module to add them to the code.
I used Paint and saved the files as 16Colors.bmp.

Which software may I use to enlarge my palette?

To be perfect I would find a way to work with a palette matching the Megadrive 512 colors.

Don't you have any clue?

[Top l'âne]

I auto answer.

I've tried a couple of freewares to create my pixel art.
I feel pretty good using mtPaint.
It allows to export light files used by SGDK. Much more important I work now with 256 colors. Great!


On the contrary I felt quite disapointed by my first uses of GrafX2. Unfriendly tool to me.

Another demo is almost hot. Just finished the engine and the main structure. I wouldn't feel ashamed to broadcast it as is, I'll wait a bit more though.
A few months more to add details to enlighten the production.


To last with, one more good thing.
I've discovered (but you might all have already known that), an AVI recorder on KEGA.
I immediatly re-uplaod my very first demo, throwing away the CamStudio disgusting quality.

Right here:

https://www.youtube.com/watch?v=3z_9yNgPW6Y

[Top l'âne]

Hey guys.

I've renamed this topic to gather all my short productions in the same place.

I've been working these days on another short demo.
Mainly to code a few patterns of physics, that is to say sprites moves and gravity effects.
I'm proud to present an upped quality considering the previous demo.

https://www.youtube.com/watch?v=KXHyVo_FqGM


I've learned much on this small project. It enlighted a few (unexpected) difficulties though.
I'll probably share a bit of questions with you in the coming days.

[Chilly Willy]

Your demo has improved considerably. Good job.

[SegaTim]

Are you posting the ROM file?

[Top l'âne]

@Chilly: thank you very much. I'd like to offer much better the next time.

@Tim: I decided this demo was not worth a sharing. I can tell you the soundtrack sounds much better on hardware, but graphics show my real lack of efficience.
If really interested and hurry, feel free to send me an email so I send you the rom.

I was much more thinking of sharing the next demo. This should be called "Where is my pixel" and that will be my real big job of the year. Many more work on sprite, animation and direction.
When this project comes around I will zip my three demos together maybe.


I add a small question of C.

The code of Cubes&Physics works around a switch(timer).
I load all my tiles at the beginning of the timer, then I spread my background piece by piece through the switch as the timer goes on.
I decided to get only one timer and added to it, the sprites appearance and the final texts.

This gives a very large and quite unreadable paragraph.

I would be glad to collect your opinion about this.

Code: Select all

void setBackground()
{
    u8 i = 0;
    static s16 ind, idx1, idx2, idx3, ix[16] = {0};

    static s16 timer;

    timer ++;

    switch(timer)
    {
    case 1:
        //BG_A
        ind = TILE_USERINDEX;
        idx1 = ind;
        VDP_loadTileSet(brickRed16.tileset, TILE_ATTR_FULL(PAL1, FALSE, FALSE, FALSE, idx1), CPU);
        ind += brickRed16.tileset->numTile;
        idx2 = ind;
        VDP_loadTileSet(&br8, idx2, CPU);
        ind += br8.numTile;
        for(i = 11; i < 28; i ++)
        {
        VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL3, TRUE, FALSE, FALSE, idx2), i, 7);
        VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL3, TRUE, FALSE, FALSE, idx2), i, 15);
        }
        for(i = 8; i < 15; i ++)
        {
        VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL3, TRUE, FALSE, FALSE, idx2), 11, i);
        VDP_setTileMapXY(BG_A, TILE_ATTR_FULL(PAL3, TRUE, FALSE, FALSE, idx2), 27, i);
        }
        idx3 = ind;
        VDP_loadTileSet(hud.tileset, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), CPU);
        ind += hud.tileset->numTile;
        //BG_B
        ix[0] = ind;
        VDP_loadTileSet(bgb1.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[0]), CPU);
        ind += bgb1.tileset->numTile;


        ix[1] = ind;
        VDP_loadTileSet(bgb2.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[1]), CPU);
        ind += bgb2.tileset->numTile;


        ix[2] = ind;
        VDP_loadTileSet(bgb3.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[2]), CPU);
        ind += bgb3.tileset->numTile;


        ix[3] = ind;
        VDP_loadTileSet(bgb4.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[3]), CPU);
        ind += bgb4.tileset->numTile;


        ix[4] = ind;
        VDP_loadTileSet(bgb5.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[4]), CPU);
        ind += bgb5.tileset->numTile;


        ix[5] = ind;
        VDP_loadTileSet(bgb6.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[5]), CPU);
        ind += bgb6.tileset->numTile;


        ix[6] = ind;
        VDP_loadTileSet(bgb7.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[6]), CPU);
        ind += bgb7.tileset->numTile;


        ix[7] = ind;
        VDP_loadTileSet(bgb8.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[7]), CPU);
        ind += bgb8.tileset->numTile;


        ix[8] = ind;
        VDP_loadTileSet(bgb9.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[8]), CPU);
        ind += bgb9.tileset->numTile;


        ix[9] = ind;
        VDP_loadTileSet(bgb10.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[9]), CPU);
        ind += bgb10.tileset->numTile;


        ix[10] = ind;
        VDP_loadTileSet(bgb11.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[10]), CPU);
        ind += bgb11.tileset->numTile;


        ix[11] = ind;
        VDP_loadTileSet(bgb12.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[11]), CPU);
        ind += bgb12.tileset->numTile;



        ix[12] = ind;
        VDP_loadTileSet(bgb13.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[12]), CPU);
        ind += bgb13.tileset->numTile;


        ix[13] = ind;
        VDP_loadTileSet(bgb14.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[13]), CPU);
        ind += bgb14.tileset->numTile;


        ix[14] = ind;
        VDP_loadTileSet(bgb15.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[14]), CPU);
        ind += bgb15.tileset->numTile;



        ix[15] = ind;
        VDP_loadTileSet(bgb16.tileset, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[15]), CPU);
        ind += bgb16.tileset->numTile;

        PAL_setPalette(PAL1, brickRed16.palette->data, CPU);
        PAL_setPalette(PAL0, bgb1.palette->data, CPU);
        //PAL_setPalette(PAL3, hud.palette->data, CPU);

        break;

    case 250:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE,idx1), 0, 0, 0, 0, 2, 2, CPU);
        //for(i = 0; i < 20; i ++)
        //VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), i * 2, 0, 0, 0, 2, 2, CPU);
        break;
    case 323:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE,idx1), 38, 0, 0, 0, 2, 2, CPU);
        break;
    case 423:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE,idx1), 38, 24, 0, 0, 2, 2, CPU);
        break;
    case 523:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE,idx1), 0, 24, 0, 0, 2, 2, CPU);
        Bgd16Data.state = 1;
        Bgd16Data.posY = FIX32(150);
        break;

    case 613:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb1.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[0]),i*2, 2, 0, 0, 2, 2, CPU);
    }
        break;
    case 663:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb2.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[1]),i*2, 4, 0, 0, 2, 2, CPU);
    }
        break;
    case 713:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb3.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[2]),i*2, 6, 0, 0, 2, 2, CPU);
    }
        break;
    case 763:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb4.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[3]),i*2, 8, 0, 0, 2, 2, CPU);
    }
        break;
    case 813:
        for(i= 0; i < 20; i ++)
        {
        VDP_setTileMapEx(BG_B, bgb5.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[4]),i*2, 10, 0, 0, 2, 2, CPU);
        }
        break;
    case 860:
        VDP_setTileMapEx(BG_B, bgb6.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[5]),18, 12, 0, 0, 2, 2, CPU);
        break;
    case 910:
        VDP_setTileMapEx(BG_B, bgb7.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[6]),18, 14, 0, 0, 2, 2, CPU);
        break;
    case 960:
        VDP_setTileMapEx(BG_B, bgb8.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[7]),18, 16, 0, 0, 2, 2, CPU);
        break;
    case 1010:
        VDP_setTileMapEx(BG_B, bgb9.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[8]),18, 18, 0, 0, 2, 2, CPU);
        break;
    case 1060:
        VDP_setTileMapEx(BG_B, bgb10.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[9]),18, 20, 0, 0, 2, 2, CPU);
        break;
    case 1110:
        VDP_setTileMapEx(BG_B, bgb11.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[10]),18, 22, 0, 0, 2, 2, CPU);
        break;
    case 1160:
        VDP_setTileMapEx(BG_B, bgb12.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[11]),18, 24, 0, 0, 2, 2, CPU);
        break;
    case 1210:
        VDP_setTileMapEx(BG_B, bgb13.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[12]),18, 26, 0, 0, 2, 2, CPU);
        break;
    case 1230:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb14.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[13]),i*2, 28, 0, 0, 2, 2, CPU);
    }
        break;
    case 1240:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb15.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[14]),i*2, 30, 0, 0, 2, 2, CPU);
    }
        break;
    case 1310:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb16.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[15]),i*2, 32, 0, 0, 2, 2, CPU);
    }
        break;


    case 1360:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb13.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[12]),i*2, 26, 0, 0, 2, 2, CPU);
    }
        break;
    case 1410:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb12.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[11]),i*2, 24, 0, 0, 2, 2, CPU);
    }
        break;
    case 1460:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb11.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[10]),i*2, 22, 0, 0, 2, 2, CPU);
    }
        break;
    case 1510:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb10.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[9]),i*2, 20, 0, 0, 2, 2, CPU);
    }
        break;

    case 1560:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb9.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[8]),i*2, 18, 0, 0, 2, 2, CPU);
    }
        break;
    case 1610:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb8.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[7]),i*2, 16, 0, 0, 2, 2, CPU);
    }
        break;
    case 1660:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb7.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[6]),i*2, 14, 0, 0, 2, 2, CPU);
    }
        break;
    case 1710:
        for(i= 0; i < 20; i ++)
    {
        VDP_setTileMapEx(BG_B, bgb6.tilemap, TILE_ATTR_FULL(PAL0, FALSE, FALSE, FALSE, ix[5]),i*2, 12, 0, 0, 2, 2, CPU);
    }
        break;
    case 1750:
        PAL_fadeOutPalette(PAL0, 100, TRUE);
        //PAL_fadeToPalette(PAL0, palette_black, )
        break;
    case 2000:
        PAL_fadeInPalette(PAL3, hud.palette->data, 100, TRUE);
        scrollOrder = 1;
        break;
    case 2150:
        PAL_fadeInPalette(PAL0, bgb1.palette->data, 100, TRUE);
        break;
    case 2250:
        Bgm8Data.state = 1;
        Bgm8Data.posY = FIX32(100);
    case 2300:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 0, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 38, 26, 0, 0, 2, 2, CPU);
        break;
    case 2310:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 2, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 36, 26, 0, 0, 2, 2, CPU);
        break;
    case 2320:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 4, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 34, 26, 0, 0, 2, 2, CPU);
        break;
    case 2330:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 6, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 32, 26, 0, 0, 2, 2, CPU);
        break;
    case 2340:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 8, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 30, 26, 0, 0, 2, 2, CPU);
        break;
    case 2350:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 10, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 28, 26, 0, 0, 2, 2, CPU);
        break;
    case 2360:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 12, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 26, 26, 0, 0, 2, 2, CPU);
        break;
    case 2370:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 14, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 24, 26, 0, 0, 2, 2, CPU);
        break;
    case 2380:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 16, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 22, 26, 0, 0, 2, 2, CPU);
        break;
    case 2390:
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 18, 26, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, hud.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx3), 20, 26, 0, 0, 2, 2, CPU);
        break;
    case 2450:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 36, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 2, 0, 0, 0, 2, 2, CPU);
        break;
    case 2455:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 34, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 4, 0, 0, 0, 2, 2, CPU);
        break;
    case 2460:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 32, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 6, 0, 0, 0, 2, 2, CPU);
        break;
    case 2465:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 30, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 8, 0, 0, 0, 2, 2, CPU);
        break;
    case 2470:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 28, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 10, 0, 0, 0, 2, 2, CPU);
        break;
    case 2475:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 26, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 12, 0, 0, 0, 2, 2, CPU);
        break;
    case 2480:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 24, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 14, 0, 0, 0, 2, 2, CPU);
        break;
    case 2485:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 22, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 16, 0, 0, 0, 2, 2, CPU);
        break;
    case 2490:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 20, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 18, 0, 0, 0, 2, 2, CPU);
        break;
    case 2495:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 18, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 20, 0, 0, 0, 2, 2, CPU);
        break;
    case 2500:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 16, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 22, 0, 0, 0, 2, 2, CPU);
        break;
    case 2505:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 14, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 24, 0, 0, 0, 2, 2, CPU);
        break;
    case 2510:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 12, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 26, 0, 0, 0, 2, 2, CPU);
        break;
    case 2515:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 10, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 28, 0, 0, 0, 2, 2, CPU);
        break;
    case 2520:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 8, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 30, 0, 0, 0, 2, 2, CPU);
        break;
    case 2525:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 6, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 32, 0, 0, 0, 2, 2, CPU);
        break;
    case 2530:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 4, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 34, 0, 0, 0, 2, 2, CPU);
        break;
    case 2535:
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 2, 24, 0, 0, 2, 2, CPU);
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 36, 0, 0, 0, 2, 2, CPU);
        break;

    case 2550:
        Bg8Data.state = 1;
        Bg8Data.posY = FIX32(30);
        break;
    case 2650:
        for(i = 1; i < 12; i ++)
    {
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 0, i * 2, 0, 0, 2, 2, CPU);
    }
        break;
    case 2700:
    for(i = 1; i < 12; i ++)
    {
        VDP_setTileMapEx(BG_A, brickRed16.tilemap, TILE_ATTR_FULL(PAL1, TRUE, FALSE, FALSE, idx1), 38, i*2, 0, 0, 2, 2, CPU);
    }
        break;
    case 2750:
        Bgr8Data.state = 1;
        Bgr8Data.posY = FIX32(GROUND - Bgr8Data.h);
        break;
    case 3200:
        VDP_drawTextEx(BG_A, "Cubes&Physics", TILE_ATTR(PAL3, FALSE, FALSE, FALSE), 13, 9, CPU);
        break;
    case 3400:
        VDP_drawTextEx(BG_A, "Cubes&Physics", TILE_ATTR(PAL0, FALSE, FALSE, FALSE), 13, 10, CPU);
        break;
    case 3450:
        VDP_drawTextEx(BG_A, "Cubes&Physics", TILE_ATTR(PAL1, FALSE, FALSE, FALSE), 13, 11, CPU);
        break;
    case 3500:
        VDP_drawTextEx(BG_A, "Cubes&Physics", TILE_ATTR(PAL2, FALSE, FALSE, FALSE), 13, 12, CPU);
        break;
    case 4000:
        VDP_drawTextEx(BG_A, "UNKNOWN WHEREABOUTS", TILE_ATTR(PAL2, FALSE, FALSE, FALSE), 2, 2, CPU);
        break;
    case 4010:
        VDP_drawTextEx(BG_A, "written by ", TILE_ATTR(PAL3, FALSE, FALSE, FALSE), 25, 2, CPU);
        break;
    case 4020:
        VDP_drawTextEx(BG_A, "Virtual", TILE_ATTR(PAL2, FALSE, FALSE, FALSE), 26, 3, CPU);
        break;
    case 4030:
        VDP_drawTextEx(BG_A, "performed by ", TILE_ATTR(PAL3, FALSE, FALSE, FALSE), 24, 4, CPU);
        break;
    case 4040:
        VDP_drawTextEx(BG_A, "Donkey", TILE_ATTR(PAL2, FALSE, FALSE, FALSE), 26, 5, CPU);
        break;
    case 4300:
        VDP_drawTextEx(BG_A,"Look for", TILE_ATTR(PAL3, TRUE, FALSE, FALSE), 5, 18, CPU);
        break;
    case 4320:
        VDP_drawTextEx(BG_A,"MASIAKA", TILE_ATTR(PAL2, TRUE, FALSE, FALSE), 14, 18, CPU);
        break;
    case 4340:
        VDP_drawTextEx(BG_A,"by", TILE_ATTR(PAL3, TRUE, FALSE, FALSE), 22, 18, CPU);
        break;
    case 4360:
        VDP_drawTextEx(BG_A,"RESISTANCE", TILE_ATTR(PAL2, TRUE, FALSE, FALSE), 25, 18, CPU);
        break;
    case 4450:
        VDP_drawTextEx(BG_A,"Guys you rock!!!", TILE_ATTR(PAL3, TRUE, FALSE, FALSE), 11, 20, CPU);
        break;
    case 5600:
        VDP_drawTextEx(BG_A, "So on...", TILE_ATTR(PAL1, TRUE, FALSE, FALSE), 27, 23, CPU);
        break;

    case 5800:
        PAL_fadeOutAll(200, TRUE);
        break;
    case 6050:
        loop = 0;
        break;



    }




    return;

}

[Top l'âne]

Hey guys!

Things are getting much more interesting.


Where is my pixel:

https://www.youtube.com/watch?v=WOZI7w1jo8o


The rom:

https://virtualdonkey.itch.io/where-is-my-pixel

[Top l'âne]

Hello Friends!!


I'm glad to introduce you two new projects.
To start with, let's celebrate the birth of the next musical demo, know as Sphere.
I've worked on a couple of effects and a few graphics.
I've laid down a short storyboard to direct the plot and have started working on an original guitar riff.

I feel reluctant to share more of this project. So less would be left to discover on 4 minutes release!

As a matter of fact I decide to enlight a side project.
I will try to create a game.
This will be mainly an opportunity to deal with controls handling.
Because of my technical limitations, I'll start coding a gameplay. As smooth as possible. Then I'll define the complete gamedesign.

In better case I'll do a game. If not, this will remain a playable demo and good experience to complete a further project.

Here is Samurai Slow Down:

https://www.youtube.com/watch?v=EAhgr_ZdtRQ

This is a 32x32 sprite. (chest + legs).
I've started coding basic moves and added an action.

The duck position seems to be a visual problem.
So i've explored the possibility to extend the size of the sprite.



32x32: original design, better proportions, better use in-game considering the game design I keep in mind.
32x40: middle size, could be a good deal
32x48: king size, would modify the game design but would suggest a fine detailed model




My idea is to add a few elements. Enemies and colisions to get immediate in-game sensations. I hope this may help make up my mind on this sprite size stuff.

[Top l'âne]

Hi!


A very few news about Sphere. I've started creating the intro. This will require a serious amount of graphic ressources. Let's go...!


And a very few news about Samurai.
I've started reading the source code of Metal Slug Warfare by french coder Vetea.
Happy to found a couple of ideas I wanted to add to my own code.
As a matter of fact I've re-coded the previous attempt. Pretty much work but I feel better right now.
I've fixed a few issues on the gameplay and the Samurai moves the way I want. (Gravity effect has not been changed though)
I've added a background, obviously, and brought some minor modifications to the main sprite.

https://www.youtube.com/watch?v=jOKjvdzeAEk

[Top l'âne]

Hi all!

Here is an update of this project.
First of all, I've been working on an extended move list:
-Double Jump:
may lead to: -Diving Blow
-Wall Jump (if you've reached the edge of the screen), it allows you to perform:
-Heavy Diving Blow

-Heavy Ground Attack (disable any other move until the end of the animation but has a better range than the original Quick Slash).

-Slide, using down diagonals, refrains you from attacking but gives you escape facilities with extended speed and invulnerability state.

I felt glad performing this gameplay. Nothing definitive, be sure.

As a matter of fact I added an enemy, hitboxes and collides effect then.
The sword kills the enemy (the more he dies better his life points, by the way).
The enemy kills the cat.


https://youtu.be/kJ3pj5Rp4aY

[Chilly Willy]

Jumping looks like it only effects the height of the player. It still moves like walking in the horizontal directions, which makes the jump look floaty. But it's coming along nicely.

[Top l'âne]

That's right Willy.
First, I confess many difficulties to code juming effects. What you see in the latest demo remains quite... acceptable.
Then, I do not spend time on gfx/animation until I feel much more satisfied by the gameplay. Top priority. What you see there are only a few rough visual elements to work with.
I'm re-doing the gameplay right now, trying to bring more fluidity to the controls.
I'll try to unify all displayed actions on a single button.
This will free the third button. I'd like to use it to add more elements to make this gameplay more interesting with punch and/or tactical dimension.


Stay tuned.

[SegaTim]

The hardest part is the collision maps. And their scrolling. Take care of it...

[Top l'âne]

I'm a coward, I do not deal with map collision and map scrolling...

To go through this very first game project, I was much more aiming to create a board game (mainly).

To be true, this is a good opportunity to work on a small map collsion engine, at least. I should make some effort this way.


Thanks for your advice.

[Top l'âne]

Hey Friends,

here is a cool update of the Samurai project.

It brings you a large move list using a 3 buttons pad:
-quick slash / heavy blow / counter attack
-slide attack / ram attack
-double jump / wall jump
-diving blow / diving blows combo

This demo also presents 4 enemies on the same ground, with their own weapon.
All collision processes are fully working.

I added a few combat effects such as blood shots, wounds (to specify imminent death) or weapons knock.

I added a "breath bars" system (up left), to support the gameplay. This has been seen on Bare Knuckle 3 for example.
This feature refrains the player from abusing of hard blows.
Almost every non basic move costs 1 or two bars.
You gain 1 bar back every X tic or two bars every kill.
The idea is to open technical fight dimension.

To last with, I have introduced a survival mode features. Every time he gets killed, an enemy comes back with one additionnal life point.


No bug to notice at this point and the program does not slow down at all.
(One bug to be true. Due to the Cat respawn process. It should have pushed away the surrounding enemies but this summoned corrupted behaviors so I've cut the process for the moment.)

I've spent pretty much time re-writting part of the code to make it much more functional.
I'll try to match my idea of an engine when coding.


To conclude, I'm happy to tell you I've identified most of my technical needs and I should be able to perform a (small^^) complete game.

During the next step I'll work on a single, complete level.


https://youtu.be/9-4MrU8eHnw