Forums

NOTICE: this tutorial is (almost) two years old but it's still mostly valid.
-
assets2banks is now the suggested tool to manage assets instead of the older folder2c. It's way more powerful.
- SMS_finalizeSprites has been deprecated and will be removed. You can already stop using it as it's useless now.

****----****----****----****----****----****----****----****----****----****

Here's a simple tutorial on how to use devkitSMS/SMSlib. We'll do a two players only squash game, similar to Pong. It should be easy enough to do that in a couple days, in a couple of 'lessons'. Please forgive the appearance of the game, I really suck at drawing.
I'll assume you properly installed SDCC and devkitSMS, and you know how to use the tools I name, Maxim's BMP2Tile, for instance.

Lesson 1: the game field
In my plan, both the players will be on the right side of the screen and bouncing the ball on the wall on the left, top and bottom of the screen.
'Port A' player will be 'Red' player and 'Port B' player will be 'Green' player. So the field simply feature the three walls and a scorekeeper, see the attached image.

We take field.png, which is a 16 colors image, and generate three files from it, using BMP2Tile:
- field (tiles).psgcompr - the tiles that make up the background, duplicates removed, in PSGaiden compressed format
- field (tilemap).stmcompr - the tilemap (how to place the tiles to 'build' the background) in STM compressed format
- field (palette).bin - the palette for the background in binary form
and we place these files into a subfolder of our project, called 'assets'.

Using devkitSMS' folder2c we will generate a .C and a header file from these data.

Then let's start coding the source. Create a main.c and place this inside:

#include "SMSlib.h" // we're including the library with the functions we will use
#include "assets.h" // we're including the assets we created before

then let's code the function that will load our assets to Video RAM (and palette):

#define BG_TILES 0
void loadAssets (void) {
SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES);
SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr);
SMS_loadBGPalette(field__palette__bin);
}

With SMS_loadPSGaidencompressedTiles we're loading our tiles into VRAM starting from tile 0. Since we might decide to relocate that later, let's use a #define. Then, with SMS_loadSTMcompressedTileMap we're loading the tilemap on the upper left corner (0,0) of the map, filling the whole screen. Then we load the used colors, with SMS_loadBGPalette. Note that the name of all the pointers (array or char) used are the names of the files you placed in assets folder, replacing each space, dot and bracket with an underscore.

Then let's write our main():

void main (void) {
loadAssets();
SMS_displayOn();
for (;;);
}

For now, we're simply going to call our asset loading function and turn on the screen, then there's an infinite loop to 'freeze' everything.

Copying the following contents into a batch file (I call it "build.bat") you'll have an easy way to build the asset source file, compile it, compile the main program and link it and create the final output.sms file in one go:

@echo off
echo Build assets.c and assets.h from assets folder
folder2c assets assets
sdcc -c -mz80 assets.c
if %errorlevel% NEQ 0 goto :EOF
echo Build Main
sdcc -c -mz80 main.c
if %errorlevel% NEQ 0 goto :EOF
echo Linking
sdcc -o output.ihx -mz80 --data-loc 0xC000 --no-std-crt0 crt0_sms.rel main.rel SMSlib.lib assets.rel
if %errorlevel% NEQ 0 goto :EOF
ihx2sms output.ihx output.sms

Run output.sms on your favorite emulator (I suggest Emulicious and MEKA). You'll see the playing field appear.

P.S. ... if someone wants to provide better graphics for this small tutorial it's very welcome :)

edit: I forgot to mention that BMP2Tile doesn't come with the ability to create .stmcompr file out-of-the-box.
You should download the plug-in here (on my github repo) and copy the file in your BMP2Tile program folder.

field.png (363 B)

the playing field (yeah, it really sucks)

Lesson 2: the paddles
Let's add the paddles. We're going to use (8x16 pixel) sprites.
The attached image sprites.png contains the two paddles (red and green) and the ball, which we'll use later.

Again, we convert that image to assets we'll use in our code:
- sprites (tiles).psgcompr - the tiles for the sprites, no removing of duplicates and created using 'treat as 8x16' (even if in this case it didn't change anything) in PSGaiden compressed format.
- sprites (palette).bin - the palette for the sprites in binary form
we place these files into assets subfolder, together with the other stuff there.

Now we need to add a few more #defines and to load the new assets into VRAM

#define SPRITE_TILES 256
#define RED_PADDLE_TILES SPRITE_TILES
#define GREEN_PADDLE_TILES (SPRITE_TILES+4)
#define BALL_TILES (SPRITE_TILES+8)

void loadAssets (void) {
SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES);
SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr);
SMS_loadBGPalette(field__palette__bin);
SMS_loadPSGaidencompressedTiles(sprites__tiles__psgcompr, SPRITE_TILES);
SMS_loadSpritePalette(sprites__palette__bin);
}

(notice how we added SMS_loadPSGaidencompressedTiles for sprite tiles and SMS_loadSpritePalette for sprite palette to our loadAssets function)

We then need a few variables to keep player's paddle position and which player is supposed to hit the ball next:

unsigned char playerPosition[2];
unsigned char turn;

of course we need a function to initialize these variables when the game starts:

void initGame (void) {
playerPosition[0]=44;
playerPosition[1]=114;
turn=0;
}

Then finally the important parts: first we need to read user input, and change paddles' Y position according to the pressed keypad keys. We then write a function for this:

void movePaddles (void) {
#define MINPADDLEY 8
#define MAXPADDLEY (192-8-32-1)
unsigned int ks=SMS_getKeysStatus();
if ((ks & PORT_A_KEY_UP) && (playerPosition[0]>MINPADDLEY)) {
playerPosition[0]-=2;
} else if ((ks & PORT_A_KEY_DOWN) && (playerPosition[0]<MAXPADDLEY)) {
playerPosition[0]+=2;
}
if ((ks & PORT_B_KEY_UP) && (playerPosition[1]>MINPADDLEY)) {
playerPosition[1]-=2;
} else if ((ks & PORT_B_KEY_DOWN) && (playerPosition[1]<MAXPADDLEY)) {
playerPosition[1]+=2;
}
}

SMS_getKeysStatus returns a value that can be masked against constant values to see which keys are being pressed. So ks & PORT_A_KEY_UP is true if the UP key on the pad connected on port A is pressed.

The second important part is the function that 'declares' where the paddle sprites should be placed. As each paddle is 32 pixel in height and our sprites are 16 pixel in height only, we need to use two sprites per paddle.
Also, since the sprites are drawn front to back in the order we declare them, we should make sure that the player who'll need to hit the ball is drawn on top of the other player.

void drawPaddles (void) {
#define PADDLEX 244
SMS_addSprite (PADDLEX, playerPosition[turn], (turn?GREEN_PADDLE_TILES:RED_PADDLE_TILES));
SMS_addSprite (PADDLEX, playerPosition[turn]+16, (turn?GREEN_PADDLE_TILES:RED_PADDLE_TILES)+2);
SMS_addSprite (PADDLEX, playerPosition[1-turn], (turn?RED_PADDLE_TILES:GREEN_PADDLE_TILES));
SMS_addSprite (PADDLEX, playerPosition[1-turn]+16, (turn?RED_PADDLE_TILES:GREEN_PADDLE_TILES)+2);
}

So, finally, here's our new main:

void main (void) {
SMS_setSpriteMode (SPRITEMODE_TALL);
loadAssets();
initGame();
SMS_displayOn();
for (;;) {
movePaddles();
SMS_initSprites();
drawPaddles();
SMS_finalizeSprites();
SMS_waitForVBlank();
SMS_copySpritestoSAT();
}
}

First we tell the hardware we're going to always use 8x16 sprites, using SMS_setSpriteMode.
Then, in our still endless for loop, we have to remember that before declaring the first sprite we should instruct the library we're going to do that, using SMS_initSprites and also tell the library when done, using SMS_finalizeSprites.

Then we have to wait for a very important moment to come: when the screen will be in VBlank phase, which is when we will update sprites. So SMS_waitForVBlank will ensure our program will wait for the right moment and SMS_copySpritestoSAT will move our previously declared sprites to the hardware SAT (Sprite Attribute Table) so that our VDP will be able to display them.

sprites.png (266 B)

sprites - paddles and ball

Lesson 3: the ball
It's time to add the bouncing ball. The simpler ball I can think of. This ball just bounces at 45° diagonal against walls and paddles.
We start defining the 4 possible directions:

#define DIR_NE 0
#define DIR_SE 1
#define DIR_SW 2
#define DIR_NW 3

and we add some other constants to define ball speed and size and wall positions:

#define BALL_SPEED 2
#define BALL_RADIUS 2
#define LEFT_WALL 15
#define RIGHT_WALL (256-4)
#define TOP_WALL 7
#define BOTTOM_WALL (192-8)

#define PADDLEX 244

(I also moved the defined PADDLEX to top of source, as it was misplaced where it was in drawPaddles function.)

We need some variables now:

unsigned char BallX, BallY, BallDir;

and we of course need to update the function that initializes them:

void initGame (void) {
playerPosition[0]=44;
playerPosition[1]=114;
turn=0;
BallX=230;
BallY=96;
BallDir=DIR_NW;
}

Now let's define the function that will handle the ball movement:

void moveBall (void) {
switch (BallDir) {
case DIR_NE:BallX+=BALL_SPEED; BallY-=BALL_SPEED; break;
case DIR_SE:BallX+=BALL_SPEED; BallY+=BALL_SPEED; break;
case DIR_SW:BallX-=BALL_SPEED; BallY+=BALL_SPEED; break;
case DIR_NW:BallX-=BALL_SPEED; BallY-=BALL_SPEED; break;
}

if ((BallY-BALL_RADIUS)<=TOP_WALL) {
// top wall collisions
if (BallDir==DIR_NW) BallDir=DIR_SW;
else if (BallDir==DIR_NE) BallDir=DIR_SE;
} else if ((BallY+BALL_RADIUS)>=BOTTOM_WALL) {
// bottom wall collisions
if (BallDir==DIR_SW) BallDir=DIR_NW;
else if (BallDir==DIR_SE) BallDir=DIR_NE;
}

if ((BallX-BALL_RADIUS)<=LEFT_WALL) {
// left wall collisions
if (BallDir==DIR_NW) BallDir=DIR_NE;
else if (BallDir==DIR_SW) BallDir=DIR_SE;
// and it's next player turn!
turn=1-turn;
}

if (((BallX+BALL_RADIUS)>=PADDLEX) && ((BallX+BALL_RADIUS)<=(PADDLEX+6))) {
// check if we're hitting the active player's paddle
if (((BallY+BALL_RADIUS)>=playerPosition[turn]) && ((BallY-BALL_RADIUS)<=playerPosition[turn]+32)) {
if (BallDir==DIR_NE) BallDir=DIR_NW;
else if (BallDir==DIR_SE) BallDir=DIR_SW;
}
}
}

The switch on top will calculate the new position of the ball according on current position and direction, then we will check if we need to change the current direction, which will happen if the ball hits a wall or a paddle. We are also starting next player's turn when the ball hits the left (distant) wall, but we're still not addressing when players miss the ball, we'll see that later.

Then, of course, we also need a function to draw the ball:

void drawBall (void) {
SMS_addSprite (BallX-BALL_RADIUS, BallY-BALL_RADIUS, BALL_TILES);
}

Finally, it's time to update our main:

void main (void) {
SMS_setSpriteMode (SPRITEMODE_TALL);
loadAssets();
initGame();
SMS_displayOn();
for (;;) {
movePaddles();
moveBall();
SMS_initSprites();
drawPaddles();
drawBall();
SMS_finalizeSprites();
SMS_waitForVBlank();
SMS_copySpritestoSAT();
}
}

we just had to add moveBall (right after movePaddles) and drawBall, which I placed after drawPaddles but of course if you prefer the ball 'over' the paddles you can swap them. You'll hardly notice any difference, though.

A small gift for the lazy ones among the readers ;)

main.c (3.69 KB)

complete source as of lesson #3

Lesson 4: the scorekeeper
Now we're going to add the scorekeeper. The attached score.png contains the score from 0 to 15 as an array of 16 32x32 pixel images. We're going to convert them (using BMP2Tile) to tiles and tilemap:

- score (tiles).psgcompr - the tiles, duplicates removed, in PSGaiden compressed format
- score (tilemap).bin - the tilemap, in uncompressed format, because we need to access the data with random access

We should load the tiles somewhere in Video RAM, so we define a suitable location:

#define SCORE_TILES 24

and we update our loadAssets function so that it loads the tiles:

void loadAssets (void) {
SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES);
SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr);
SMS_loadBGPalette(field__palette__bin);
SMS_loadPSGaidencompressedTiles(sprites__tiles__psgcompr, SPRITE_TILES);
SMS_loadSpritePalette(sprites__palette__bin);
SMS_loadPSGaidencompressedTiles(score__tiles__psgcompr, SCORE_TILES);
SMS_setBGPaletteColor(4, RGB(3,3,3));
}

(we're also setting background palette color 4 to a color we like, say white, because color 4 is what our image uses)

Then we need two variables for keeping the players scores:

unsigned char playerPoints[2];

and of course we should reset them when starting, so we update our initGame:

void initGame (void) {
playerPosition[0]=44;
playerPosition[1]=114;
turn=0;
BallX=230;
BallY=96;
BallDir=DIR_NW;
playerPoints[0]=0;
playerPoints[1]=0;
}

Then we define where the score should appear on screen, for both players. We're going to update screen map, so these values are in chars, not in pixel:

#define SCOREKEEPERY 2
#define SCOREKEEPERX_0 9
#define SCOREKEEPERX_1 15

and of course we need a function that updates the score when it changes:

void updateScore (unsigned char player) {
unsigned int x,y;
const unsigned int *pnt;
for (y=0;y<4;y++) {
SMS_setNextTileatXY ((player==0)?SCOREKEEPERX_0:SCOREKEEPERX_1,SCOREKEEPERY+y);
pnt=&score__tilemap__bin[playerPoints[player]*32+y*8];
for (x=0;x<4;x++) {
SMS_setTile (*pnt+++SCORE_TILES);
}
}
}

To update the screen map, we use SMS_setNextTileatXY and SMS_setTile. The former sets at which position (column, row) we're going to update a tile and the latter sets the new tile value to be written there. Upon setting a new value, the SMS hardware will set the 'screen update pointer' to the next tile, that is the tile that comes on the right (or the first of the next line when line is over) so we can update four adjoining tiles without reissuing any set new position command in between.
(in specific detail: this function it's using the map we generated thru BMP2Tile as a reference map, and it's updating 16 tiles (4 lines of 4 tiles) on screen according to which player score we should update and its current points)

Of course we still need to add the part that adds a point to a player when the other misses the ball. In moveBall, we need to add checking for the 'right wall', which isn't really there but you get the point:

[...]
if ((BallX-BALL_RADIUS)<=LEFT_WALL) {
// left wall collisions
if (BallDir==DIR_NW) BallDir=DIR_NE;
else if (BallDir==DIR_SW) BallDir=DIR_SE;
// and it's next player turn!
turn=1-turn;
} else if ((BallX+BALL_RADIUS)>=RIGHT_WALL) {
// right wall is missing, so collision here means the ball escaped, so
// the other player scores a point:
if (playerPoints[1-turn]<15) {
playerPoints[1-turn]++;
updateScore(1-turn);
}
// restart ball
BallX=230;
BallY=96;
BallDir=DIR_NW;
}
[...]

(the added code is the 'else' branch...)

Finally, we should make sure that the game starts with displaying the starting score 0 - 0: we update the main and we call our updateScore for each player right before turning on the screen:

void main (void) {
SMS_setSpriteMode (SPRITEMODE_TALL);
loadAssets();
initGame();
updateScore(0);
updateScore(1);
SMS_displayOn();
[...]

score.png (1.03 KB)

points 0 to 15

In case you want to test the outcome...

output.rar (3.13 KB)

squash ROM, after lesson #4

Lesson 5: start a new game
Of course you might want to play once more after some of the two players reached 15 points, so we're going to make the SMS pause key act as a global reset.

We simply modify our main, adding a few lines at the end of our endless for loop:

void main (void) {
SMS_setSpriteMode (SPRITEMODE_TALL);
loadAssets();
initGame();
updateScore(0);
updateScore(1);
SMS_displayOn();
for (;;) {
movePaddles();
moveBall();
SMS_initSprites();
drawPaddles();
drawBall();
SMS_finalizeSprites();
SMS_waitForVBlank();
SMS_copySpritestoSAT();
if (SMS_queryPauseRequested()) {
SMS_resetPauseRequest();
initGame();
updateScore(0);
updateScore(1);
}
}
}

We're going to query if pause key has been pressed since last frame - SMS_queryPauseRequested returns a boolean, and if so we will init the game again, resetting score and scorekeeper appearance. Of course we also need to 'acknowledge' the pause request, so we use SMS_resetPauseRequest (which simply resets the flag).

This one was simple, uh? :)

Lesson 6: background music
We're now going to add a background music to our game, using PSGlib.
First, you need to prepare a .PSG file, which is simply a converted VGM. You can track your music in Mod2Psg2, DefleMask, or VGM Music Maker, and export your tune in VGM. Then you have to optimize it and convert to PSG using vgm2psg tool, which is part of PSGlib.

So you've got your music file, theTune.psg and you put it into your asset folder.

In your source, include the header file for the library:

#include "PSGlib.h"

then in your code you should start your tune and ensure that the PSG hardware gets updated with proper data each frame, so you change your main:

void main (void) {
SMS_setSpriteMode (SPRITEMODE_TALL);
loadAssets();
initGame();
updateScore(0);
updateScore(1);
PSGPlay (theTune_psg);
SMS_displayOn();
for (;;) {
movePaddles();
moveBall();
SMS_initSprites();
drawPaddles();
drawBall();
SMS_finalizeSprites();
SMS_waitForVBlank();
SMS_copySpritestoSAT();
PSGFrame();
if (SMS_queryPauseRequested()) {
SMS_resetPauseRequest();
initGame();
updateScore(0);
updateScore(1);
}
}
}

PSGPlay will tell the library which tune you'll play and PSGFrame will actually make the 'magic' happen. It's important that this function it's called at a constant pace, so it's right after the SMS_waitForVBlank and SMS_copySpritestoSAT calls.

Of course you should tell the linker you're going to use the library, so you should modify the call to the linker in your batch that does the work:

[...]
echo Linking
sdcc -o output.ihx -mz80 --data-loc 0xC000 --no-std-crt0 crt0_sms.rel main.rel SMSlib.lib PSGlib.rel assets.rel
[...]

Lesson 7: sound effects
Now we will add SFXs, one when the ball hits a wall and another when it hits a paddle. We prepare two VGM tunes, using only PSG channel 2 and/or 3 (noise) and we convert them to PSG files using vgm2psg, remembering that we should tell the converter which channels are used by the sound effect we're converting.

So we got our sfx_1.psg and sfx_2.psg and we put them in our asset folder.

Then we're going to modify our code to call PSGSFXPlay when we want to fire a SFX:

void moveBall (void) {
switch (BallDir) {
case DIR_NE:BallX+=BALL_SPEED; BallY-=BALL_SPEED; break;
case DIR_SE:BallX+=BALL_SPEED; BallY+=BALL_SPEED; break;
case DIR_SW:BallX-=BALL_SPEED; BallY+=BALL_SPEED; break;
case DIR_NW:BallX-=BALL_SPEED; BallY-=BALL_SPEED; break;
}

if ((BallY-BALL_RADIUS)<=TOP_WALL) {
// top wall collisions
if (BallDir==DIR_NW) BallDir=DIR_SW;
else if (BallDir==DIR_NE) BallDir=DIR_SE;
PSGSFXPlay(sfx_1_psg,SFX_CHANNEL2);
} else if ((BallY+BALL_RADIUS)>=BOTTOM_WALL) {
// bottom wall collisions
if (BallDir==DIR_SW) BallDir=DIR_NW;
else if (BallDir==DIR_SE) BallDir=DIR_NE;
PSGSFXPlay(sfx_1_psg,SFX_CHANNEL2);
}

if ((BallX-BALL_RADIUS)<=LEFT_WALL) {
// left wall collisions
if (BallDir==DIR_NW) BallDir=DIR_NE;
else if (BallDir==DIR_SW) BallDir=DIR_SE;
// and it's next player turn!
turn=1-turn;
PSGSFXPlay(sfx_1_psg,SFX_CHANNEL2);
} else if ((BallX+BALL_RADIUS)>=RIGHT_WALL) {
// right wall is missing, so collision here means the ball escaped, so
// the other player scores a point:
if (playerPoints[1-turn]<15) {
playerPoints[1-turn]++;
updateScore(1-turn);
}
// restart ball
BallX=230;
BallY=96;
BallDir=DIR_NW;
}

if (((BallX+BALL_RADIUS)>=PADDLEX) && ((BallX+BALL_RADIUS)<=(PADDLEX+6))) {
// check if we're hitting the active player's paddle
if (((BallY+BALL_RADIUS)>=playerPosition[turn]) && ((BallY-BALL_RADIUS)<=playerPosition[turn]+32)) {
if (BallDir==DIR_NE) BallDir=DIR_NW;
else if (BallDir==DIR_SE) BallDir=DIR_SW;
PSGSFXPlay(sfx_2_psg,SFX_CHANNELS2AND3);
}
}
}

on each call we need to tell the audio engine which channels the SFX will use. Possible values are SFX_CHANNEL2, SFX_CHANNEL3 and SFX_CHANNELS2AND3 if the SFX uses both.

Then, we also need to modify our main so that it calls PSGSFXFrame after each PSGFrame call, this way the tune and the SFXs will be processed correctly in sync.

[...]
SMS_waitForVBlank();
SMS_copySpritestoSAT();
PSGFrame();
PSGSFXFrame();
[...]

Addendum: SEGA ROM header and SDSC header
This doesn't deal with programming, really. It's also not compulsory as long as you play with emulators OR you run your game using Master EverDrive / EverDriveGG.
SEGA ROM header is compulsory if you want to burn your own ROM and build your cartridge, as the Master System BIOS will check your ROM to see if it's 'legit' (there's a text written in a specific location) and if it's 'undamaged' (there's a CRC to be validated).

To add a SEGA ROM header to your ROM you can use the specific macro:

SMS_EMBED_SEGA_ROM_HEADER(9999,0);

This adds the ROM header, the first parameter is the ROM ID (each game in SEGA catalog has one, 9999 should be free and I guess it's a nice number for the homebrew releases) and the second parameter is the revision (0 to 15), so you might want to increment it if by chance you release a revision of your game. Whatever the values anyway the ROM header and the CRC field will be fitted in the correct place (and ihx2sms will take care of setting the correct value)

SDSC header, on the other hand, is something invented here and now a standard for SMS/GG homebrew tagging. You can place information about the software, the version, the author, the release date and even comments into the ROM. Emulators will display these.

To add a SDSC tag you can use:

SMS_EMBED_SDSC_HEADER_AUTO_DATE(1, 0, "sverx\\2016", "Squash", "a small SEGA Master System game tutorial\nBuilt using devkitSMS & SMSlib");

The first parameter is the major version, the second is the minor - from 0 to 99 (so this is 1.00), the third parameter is the author field, then comes the software name and finally the description/notes. Current date will be automatically fitted by ihx2sms tool when it finalizes your ROM.

I like placing both of them at the end of my main source file, but they can be placed anywhere you like. Just be aware that if your ROM would fit into 16 KB without these, these will make your ROM 32 KB.

Epilogue: everything else
Of course in this tutorial I really didn't use all the SMSlib function/features, so here's a list of what has been left out.

Functions to activate/deactivate VDP features:

void SMS_VDPturnOnFeature (unsigned int feature);
void SMS_VDPturnOffFeature (unsigned int feature);

Features you can turn on/off are:

VDPFEATURE_EXTRAHEIGHT
VDPFEATURE_SHIFTSPRITES
VDPFEATURE_HIDEFIRSTCOL ( or VDPFEATURE_LEFTCOLBLANK )
VDPFEATURE_LOCKHSCROLL
VDPFEATURE_LOCKVSCROLL
VDPFEATURE_240LINES
VDPFEATURE_224LINES

(those controlled by other function/macros are removed from this list)

Also, macro and functions are provided to configure VDP parameters/mode:

SMS_displayOn(); /* macro - turns on screen */
SMS_displayOff(); /* macro - turns off screen */
void SMS_setBGScrollX (int scrollX); /* scroll the background horizontally */
void SMS_setBGScrollY (int scrollY); /* scroll the background vertically */
void SMS_setBackdropColor (unsigned char entry); /* set which sprite palette entry will be used for backdrop */
void SMS_useFirstHalfTilesforSprites (_Bool usefirsthalf); /* use tiles 0-255 for sprites if true, 256-511 if false */
void SMS_setSpriteMode (unsigned char mode);

modes for SMS_setSpriteMode are:

SPRITEMODE_NORMAL
SPRITEMODE_TALL
SPRITEMODE_ZOOMED
SPRITEMODE_TALL_ZOOMED

there are other functions to load uncompressed tiles/tilemaps/tilemap areas to VRAM:

void SMS_loadTiles (void *src, unsigned int Tilefrom, unsigned int len);
void SMS_loadTileMap (unsigned char x, unsigned char y, void *src, unsigned int len);
void SMS_loadTileMapArea (unsigned char x, unsigned char y, unsigned int *src, unsigned char width, unsigned char height);

There are sprite clipping/windowing functions (you can define a window and make all the sprite outside the window disappear):

void SMS_setClippingWindow (unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1); /* set the sprite window. sprites completely outside the window will be clipped */
_Bool SMS_addSpriteClipping (int x, int y, unsigned char tile); /* declare a sprite inside the window - returns false if sprite isn't added */

You can query keypad according to current status compared to previous status, to recognize when a key has just been pressed or released, or if a key is held pressed:

unsigned int SMS_getKeysStatus (void); /* the current status of the keys */
unsigned int SMS_getKeysPressed (void); /* the keys that were up last frame and down now */
unsigned int SMS_getKeysHeld (void); /* the keys that were down last frame and still down now */
unsigned int SMS_getKeysReleased (void); /* the keys that were down last frame and up now */

The same for a Genesis/MegaDrive pad additional buttons (Port A only):

unsigned int SMS_getMDKeysStatus (void); /* the current status of the extended keys on a MD controller */
unsigned int SMS_getMDKeysPressed (void); /* the extended keys that were up last frame and down now on a MD controller */
unsigned int SMS_getMDKeysHeld (void); /* the extended keys that were down last frame and still down now on a MD controller */
unsigned int SMS_getMDKeysReleased (void); /* the extended keys that were down last frame and up now on a MD controller */

There are also functions/macros to handle line interrupts:

void SMS_setLineInterruptHandler (void (*theHandlerFunction)(void)); /* link your own handler to the line interrupt */
void SMS_setLineCounter (unsigned char count); /* choose on which line trigger the IRQ */
SMS_enableLineInterrupt() /* macro - turns on line IRQ */
SMS_disableLineInterrupt() /* macro - turns off line IRQ */

Finally, there are low level functions, which you might want to use for dirty tricks:

void SMS_VRAMmemcpy (unsigned int dst, void *src, unsigned int size); /* memcpy to VRAM */
void SMS_VRAMmemcpy_brief (unsigned int dst, void *src, unsigned char size); /* memcpy to VRAM (256 bytes max) */
void SMS_VRAMmemset (unsigned int dst, unsigned char value, unsigned int size); /* memset to VRAM */

and functions/macros to move data to VRAM as fast as possible, which means that screen should be blanked (off or in vBlank phase) or you'll experience screen corruption:

void UNSAFE_SMS_copySpritestoSAT (void); /* copy sprites to Sprites Attribute Table */
void UNSAFE_SMS_VRAMmemcpy32 (unsigned int dst, void *src); /* copy 32 bytes to VRAM */
void UNSAFE_SMS_VRAMmemcpy64 (unsigned int dst, void *src); /* copy 64 bytes to VRAM */
void UNSAFE_SMS_VRAMmemcpy128 (unsigned int dst, void *src); /* copy 128 bytes to VRAM */
UNSAFE_SMS_load1Tile(src,theTile) /* copy ONE tile to VRAM */
UNSAFE_SMS_load2Tiles(src,tilefrom) /* copy TWO tiles to VRAM */
UNSAFE_SMS_load4Tiles(src,tilefrom) /* copy FOUR tiles to VRAM */

PSGlib functions that weren't used in the tutorial are:

void PSGCancelLoop (void);
void PSGPlayNoRepeat (void *song);
void PSGStop (void);
unsigned char PSGGetStatus (void);

void PSGSFXPlayLoop (void *sfx, unsigned char channels);
void PSGSFXCancelLoop (void);
void PSGSFXStop (void);
unsigned char PSGSFXGetStatus (void);

you can read more details on PSGlib functions and how it works here.

I hope you enjoyed the read! :) Comments/feedback welcome! :)

Thanks for this great tutorial, sverx! I think it is clear, well-structured and convincing. You should link to it from within Development>Getting Started>Tutorials. I'm very happy with assembler for now, so even though I'm not fiddling with devkitSMS and the C language, I've got a lot of inspiration from your tutorial regarding how to structure a small game (the elements in the for-loop, initialization, etc.)

Question: Should the for-loop not start with waiting for v-blank, then gfx-processing and then the rest (updating positions, etc.)?

hang-on wrote

Should the for-loop not start with waiting for v-blank, then gfx-processing and then the rest (updating positions, etc.)?

As long as gfx processing comes right after vblank has been hit, it really doesn't matter if the logic is before or after those, as you're anyway inside an endless loop and you're repeating just three parts: waiting for vblank, gfx processing, game logic (there are only two ways to endlessly repeat three parts, the other way is the wrong one ;) )

is in C? imposibre!!

Chicho wrote

is in C? imposibre!!

I'll take that as a compliment ;)

Hi, friends!

I am a new user here and I have completed the activities of this brilliant tutorial (until now).

Please, could you help me to write an example with a larger background (bigger than 256x192 pixels) and a scrolling screen in this background?

For example, we could consider the hockey ring of the game "Slap Shot". The rink is bigger than the screen size, so the screen only shows a part of the rink and we could use left, right, up or down buttons of the joystick to see other parts of the rink.

Thank you so much!

SlapShot-SMS-Rink.png (4.19 KB)

Hockey Rink of the game "Slap Shot"

I quickly made a very simple example, which scrolls only vertically, but I guess you'll get the point and add the horizontal scroll by yourself.
We're here to help anyway! :)

The point is: you update an offscreen row of tiles each time you're very close to displaying it. Update a row is of course simpler than update a column, but that can be done too :)

#include "SMSlib.h"
#include "assets.h"

unsigned int scroll=0;

void loadAssets (void) {
SMS_loadPSGaidencompressedTiles(MM__tiles__psgcompr, 0);
SMS_loadTileMap(0, 0, MM__tilemap__bin, 32*25*2); // 32 tiles * 25 lines * 2 bytes each
SMS_loadBGPalette(MM__palette__bin);
}

void main (void) {
unsigned int ks;
loadAssets();
SMS_displayOn();
for (;;) {
SMS_waitForVBlank();
ks=SMS_getKeysStatus();
if ((ks & PORT_A_KEY_DOWN) && (scroll<32*8-1)) {
scroll++;
SMS_setBGScrollY(scroll);
if ((scroll % 8)==0) {
SMS_loadTileMap(0,(24+(scroll/8))%28,&MM__tilemap__bin[(24+(scroll/8))*32*2],32*2); // 32 tiles * 2 bytes each
}
} else if ((ks & PORT_A_KEY_UP) && (scroll>0)) {
scroll--;
SMS_setBGScrollY(scroll);
if ((scroll % 8)==0) {
SMS_loadTileMap(0,(27+(scroll/8))%28,&MM__tilemap__bin[((scroll/8)-1)*32*2],32*2); // 32 tiles * 2 bytes each
}
}
}
}

in asset folder you should place the three files:
- MM (tiles).psgcompr: the tiles (PSGaiden compressed format)
- MM (tilemap).bin: the tilemap (uncompressed binary format)
- MM (palette).bin: the palette (binary)

that you can generate using BMP2Tile on the attached image.

MM.png (5.45 KB)

MM background

side note: coding this example I realized the current implementation of

SMS_setBGScrollY()

works correctly only between -255 and +255. I'll fix that in the next release of the library, where I'll make both functions

SMS_setBGScrollY()
SMS_setBGScrollX()

accept an unsigned byte instead of a (signed) int. It may seem weird, but it's closer to how the hardware works (and anyway I *have* to fix it somehow, uh?)

Thank you, sverx!

Your example envolving vertical scrooling is great!

I have tried to make another example for horizontal scrolling. By the way, it is necessary for a beat 'n up and the future second "Double Dragon" game for Master System. :)

I am really new in Master System programming. So, I don't know if my example is a good one. Since now, I thank everyone who gives more tips.

In this example, I took the background of the game "Great Volleyball":

The width of the image from this site (smspower) is 374 pixels, I have changed it to 368 pixels (multiple of 8), removing the last 6 pixels on the right.

I have tried to convert the changed PNG image using BMP2Tile but this program gave me this message:

"Image format not supported. Can't process it."

I don't know why BMP2Tile doesn't accept my PNG file. So I have converted the image for BMP format (the colors are different from the original because Paint program for Windows has changed the colors, but it is not important now).

The files generated by BMP2Tile are:

- volleyball (tiles).psgcompr: the tiles (PSGaiden compressed format)
- volleyball (tilemap).bin: the tilemap (Raw uncompressed binary format)
- volleyball (palette).bin: the palette (binary)

Trying the horizontal scrolling, I have noticed that the first column of the screen has a strange and awful effect. Then I have hidden the first column using the following command:

SMS_VDPturnOnFeature(VDPFEATURE_HIDEFIRSTCOL);

If you want to see the strange effect, comment this line of the code.

In this example, press left or right directions of joystick.

To draw tiles during scrolling

for (ytile=1; ytile<Y_TILE_MAX; ytile++)
{
SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTH*ytile)+(X_TILE_MAX+scrollRightDivided8))*2],2); // 1 tile * 2 bytes
}

I don't know why but I had problems with the first row of tiles. Then I have not changed the first row of the scrolling image. The first index inside "for" loop is 1 (ytile=1) and I have no idea I needed to use "y" minus one (ytile-1) in the second argument of "SMS_loadTileMap" function. Shouldn't be only "y" as second argument of the function?

Full "main.c" file in the next message...

GreatVolleyball-SMS-Match.png (2.92 KB)

#include "SMSlib.h"
#include "assets.h"

#define BG_TILE_WIDTH 46
#define X_TILE_MAX 32
#define Y_TILE_MAX 24

unsigned int scroll=0;
unsigned int scrollDivided8=0;
unsigned int scrollRight=0;
unsigned int scrollRightDivided8=0;
unsigned int xtile=0;
unsigned int ytile=0;

void loadAssets(void)
{
SMS_loadPSGaidencompressedTiles(volleyball__tiles__psgcompr, 0);

for (ytile=1; ytile<Y_TILE_MAX; ytile++)
{
SMS_loadTileMap(0,ytile,&volleyball__tilemap__bin[BG_TILE_WIDTH*ytile*2],X_TILE_MAX*2); // 32 tiles * 2 bytes each
}

SMS_loadBGPalette(volleyball__palette__bin);
}

void main (void)
{
unsigned int ks;
SMS_VDPturnOnFeature(VDPFEATURE_HIDEFIRSTCOL);
loadAssets();
SMS_displayOn();
for (;;)
{
SMS_waitForVBlank();
ks=SMS_getKeysStatus();
if ((ks & PORT_A_KEY_RIGHT) && ((scrollRightDivided8<(BG_TILE_WIDTH-X_TILE_MAX)) || (scroll==0)))
{
scroll--;
scrollRight++;
scrollRightDivided8=scrollRight/8;
SMS_setBGScrollX(scroll);

if ((scrollRight % 8)==1)
{
for (ytile=1; ytile<Y_TILE_MAX; ytile++)
{
SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTH*ytile)+(X_TILE_MAX+scrollRightDivided8))*2],2); // 1 tile * 2 bytes
}

}
// CONTINUES...

// CONTINUING THE PREVIOUS CODE
}
else if ((ks & PORT_A_KEY_LEFT) && (scrollRight>0))
{
scroll++;
scrollRight--;
scrollRightDivided8=scrollRight/8;
SMS_setBGScrollX(scroll);

if ((scrollRight % 8)==0)
{
for (ytile=1; ytile<Y_TILE_MAX; ytile++)
{
SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTH*ytile)+scrollRightDivided8)*2],2); // 1 tile * 2 bytes
}
}

}
}
}

zenac wrote

I have tried to convert the changed PNG image using BMP2Tile but this program gave me this message:

"Image format not supported. Can't process it."

Weird. As long as it's a 16 colors PNG it should work! :|

zenac wrote

Trying the horizontal scrolling, I have noticed that the first column of the screen has a strange and awful effect. Then I have hidden the first column using the following command:

SMS_VDPturnOnFeature(VDPFEATURE_HIDEFIRSTCOL);

Correct. Since the VRAM tilemap is 256 pixel wide (32 tiles of 8 pixel each) and the screen has the same width, you are actually showing the whole width of the map on the screen so you really can't update offscreen parts, as I did with my vertical scroll example. Hiding the first column on screen is the correct approach for smooth horizontal scroll :)

zenac wrote

for (ytile=1; ytile<Y_TILE_MAX; ytile++)
{
SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTH*ytile)+(X_TILE_MAX+scrollRightDivided8))*2],2); // 1 tile * 2 bytes
}

I don't know why but I had problems with the first row of tiles. Then I have not changed the first row of the scrolling image. The first index inside "for" loop is 1 (ytile=1) and I have no idea I needed to use "y" minus one (ytile-1) in the second argument of "SMS_loadTileMap" function. Shouldn't be only "y" as second argument of the function?

First row of tile is row 0, so you should change your loop into

for (ytile=0; ytile<Y_TILE_MAX; ytile++)

also, since you're loading a single tile, you could use

SMS_setNextTileatXY (unsigned char x, unsigned char y);
SMS_setTile (unsigned int tile);

instead of SMS_loadTileMap... but that's just a small optimization anyway :)

I just realized I always forgot to mention that using ConTEXT editor user defined function keys you can speed up things making it run your build.bat or your emulators of choice at the pressing of a key: here are three images explaining that.

F9.png (11.57 KB)

F9 to build your ROM

F10.png (12.06 KB)

F10 to run your ROM in MEKA

F11.png (12.06 KB)

F11 to run your ROM in Emulicious

How do i remove what's drawn on screen, and load/display the next background and sprites?

What i am looking to do is, go from the title screen to the play field screen.

Ninja Edit

Never mind, i fixed it with the help of Calindro. Thanks though! 8)

You do exactly the same: load tiles, tilemap and palettes. If you switch from title screen to play screen I suggest you turn off the display in between.

edit: good Calindro :)

Hi, I went through the lessons and the lesson 4 dont work for me this is the ouput console:

> Executing: C:\Archivos de programa\ConTEXT\ConExec.exe "C:\Archivos de programa\ConTEXT\build.bat"

Build assets.c and assets.h from assets folder
*** sverx's folder2c converter ***
Info: converting field (palette).bin ...
Info: converting field (tilemap).stmcompr ...
Info: converting field (tiles).psgcompr ...
Info: converting score (tilemap).bin ...
Info: converting score (tiles).psgcompr ...
Info: converting sprites (palette).bin ...
Info: converting sprites (tiles).psgcompr ...
Info: conversion completed. File "assets.c" defines 1926 total bytes.
Build Main
main.c:41: warning 112: function 'loadAssets' implicit declaration
main.c:42: warning 112: function 'initGame' implicit declaration
main.c:43: warning 112: function 'updateScore' implicit declaration
main.c:44: warning 112: function 'updateScore' implicit declaration
main.c:47: warning 112: function 'movePaddles' implicit declaration
main.c:48: warning 112: function 'moveBall' implicit declaration
main.c:50: warning 112: function 'drawPaddles' implicit declaration
main.c:51: warning 112: function 'drawBall' implicit declaration
main.c:43: error 101: too many parameters
main.c:44: error 101: too many parameters
main.c:132: warning 112: function 'updateScore' implicit declaration
main.c:132: error 101: too many parameters
> Execution finished.

I dont know what is wrong I already tested SDCC installation, the main.c is attached

main.c (4.82 KB)

In C one has to declare the functions before using them, so usually

void main (void)

is the last one. Try moving it at the end of the source file.

in general, if you still get a

Quote

warning 112: function 'somefunc' implicit declaration

it means you're using (calling) a function before its declaration. Move up its declaration and you fix that.

Thank you I did as you said now the source is like this:

void loadAssets (void)
void initGame (void)
void movePaddles (void)
void drawPaddles (void)
void updateScore (unsigned char player)
void moveBall (void)
void drawBall (void)
void main (void)

I dont know if it's well structured but It works I'm moving to the lesson 5.
thanks.

How wonderful this kit is, I was wondering how could I show sprites of 3 frames moving in an infinite loop like a gif image??, but in the sms screen, they are 2h x 4v and 4h x 6v in tiles.

Either put all the tiles in video memory and change the indexes every N frames, or upload new tiles for the sprite every N frames. The size of the sprite, length of any loop (or other animation) and so forth are entirely up to you, which also means the framework won't do it all for you.

Also, if you don't need to move these images over a background, you could use the background itself, changing the tiles according to your frame. That's what I would call an 'animated background', e.g. a torch burning while hanging on a wall, as in Prince of Persia for instance...

Really, it everything depends on how many tiles you need. If you can cram everything into VRAM at loading stage, it's easy then. If you can't fit everything into VRAM, then you'll be 'streaming' tiles...

Thanks for your suggestions, I'm in trouble I cant display the complete sprite 40x48 I was only able to add the tiles 8x16 over the line that the paddles (tutorial) must be so I cant change the horizontal position to show the 40x48 sprite properly, and I dont know how to use the SMS_addSprite() function, could anyone explain me the syntaxis, please?

First parameter is the X position, second is Y and third is image (tile).
So you probably want to place your 8x16 sprites to:

1) x,y
2) x+8,y
3) x+16,y
4) x+24,y
5) x+32, y
6) x+40, y
7) x,y+16
8) x+8,y+16
9) x+16,y+16
10) x+24, y+16

... and so on :)

[quote="sverx"]

#define BG_TILES 0
void loadAssets (void) {
SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES);
SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr);
SMS_loadBGPalette(field__palette__bin);
}

Hi people. A question, I'm new to sms development. And I'm really enjoying this SMSLib. A lot easier than what I started out with. Z80 ASM is not really my forté.

Anyways. I was having trouble displaying the background correctly.

The image and the emulator view are attached. The code and rom are here: https://github.com/fritzvd/melancholy-sweats

title.png (716 B)

the input image

bgsms.png (15.33 KB)

background in the emulator

It seems that the way you converted your graphics is not compatible with the way you are loading them.

How did you convert your pattern data?

I see you're using BMP2Tile command line... make sure STM plugin dll is present...

edit: ... or it may easily be the -8x16 option, which is usually meaningful for 8x16 sprites only. Try removing that from the conversion of title.png

sverx wrote

I see you're using BMP2Tile command line... make sure STM plugin dll is present...

edit: ... or it may easily be the -8x16 option, which is usually meaningful for 8x16 sprites only. Try removing that from the conversion of title.png

Ah. man. How could I have missed that. That was it. Thanks so much!

Edit:
Something else though. How would you go about creating sidescrolling WITH compression? Sverx, you created an example with uncompressed data. I'd there a way to do it with compressed data?

And another thing is how would you go about checking for collisions with background tiles? Do you created another tilemap that tracks that?

Anyways. I'm really enjoying this library and this community. Thanks in advance.

yes.png (14.62 KB)

now it works

scrolling a compressed map isn't impossible per se, but you'll need a custom compression that will support accessing the slice of data you need (either a column or a row, according to the way you're going to scroll). Anyway you could store uncompressed maps in RAM that comes from compressed data in ROM, but you'll probably eat your whole RAM quickly, if the map is large.

collision with background: there are a few approaches to that. One is to have a collision map in RAM, of course, another is to store collision information in VRAM tiles, but I'm not suggesting that as it involves reading from VRAM...

I personally assign a "behaviour byte" to each tile index. In most of the cases, this is enough. A rock is always a rock and will always be an obstacle.

To calculate collision I just read the correct metatile index from the map in ROM and then look up the associated behaviour in my table of behaviours. You can use individual bits for different stuff, or do your own arbitrary values-based encoding.

Hi, need help how could I made the sprites to move horizontally I made something like this :

#include "SMSlib.h" // we're including the library with the functions we will use
#include "assets.h" // we're including the assets we created before

#define BG_TILES 0
#define SPRITE_TILES 256
#define CHAR_A SPRITE_TILES
#define CHAR_B (SPRITE_TILES+24)
#define CHAR_C (SPRITE_TILES+48)
//2x2 sprites 8x16 pixels
#define xtiles 2
#define ytiles 2

void loadAssets (void) {
.....
}
unsigned char playerPosition[2];
unsigned char turn;

void initGame (void) {
playerPosition[0]=44;
playerPosition[1]=114;

}

void moveCharacters (void) {
#define MINCHARACTERX 8
#define MAXCHARACTERX (256-8-32-1) // 192 before 256 now, UP->LEFT, DOWN->RIGHT
unsigned int ks=SMS_getKeysStatus();
if ((ks & PORT_A_KEY_LEFT) && (playerPosition[0]>MINCHARACTERX)) {
playerPosition[0]-=2;
} else if ((ks & PORT_A_KEY_RIGHT) && (playerPosition[0]<MAXCHARACTERX)) {
playerPosition[0]+=2;
}
if ((ks & PORT_B_KEY_LEFT) && (playerPosition[1]>MINCHARACTERX)) {
playerPosition[1]-=2;
} else if ((ks & PORT_B_KEY_RIGHT) && (playerPosition[1]<MAXCHARACTERX)) {
playerPosition[1]+=2;
}
}

void drawFrame_CA (void){
int x=0;
int y=0;
int i;
int j;
int tile=0;

for (j=0;j<ytiles;j++){
for(i=0;i<xtiles;i++){
SMS_addSprite(8+x,y+128,tile);
x=x+8;
tile=tile+2;
}
x=0;
y=y+16;
}
}

void drawFrame_CB (void){
int x=0;
int y=0;
int i;
int j;
int tile=xtiles*ytiles*2;

for (j=0;j<ytiles;j++){
for(i=0;i<xtiles;i++){
SMS_addSprite(80+x,y+128,tile);
x=x+8;
tile=tile+2;
}
x=0;
y=y+16;
}

void main (void) {
SMS_setSpriteMode (SPRITEMODE_TALL);
loadAssets();
initGame();
SMS_displayOn();
for (;;) {
moveCharacters();
SMS_initSprites();
drawFrame_CA();
drawFrame_CB();
SMS_finalizeSprites();
SMS_waitForVBlank();
SMS_copySpritestoSAT();
}
}

I used the tutorial's movePaddles() function and edited to pretend the characters to move horizontally and I made my own drawFrame_CA,_CB() functions to draw the characters, but pressing the left or right doesn't have effect, I used the tutorial's initGame() even though I dont know how this function works in my program.

na_th_an wrote

I personally assign a "behaviour byte" to each tile index. In most of the cases, this is enough. A rock is always a rock and will always be an obstacle.

In (the beta of the porting -test- of) Anguna there was an even simpler approach: all the (meta)tiles above a given number are passable, the others were obstacles. Or the other way around, but you get the point.

@FeRcHuLeS: you're changing the value of playerPosition[0] and playerPosition[1], according to pressed keys... but you're not using these values when drawing the sprites. The whole point of having sprites placed freely on screen is to place them where your variables tell you to draw them :)

@sverx thank you, I improved my function to draw sprites and they move no matter the size they are they move as I'm pressing left or right, and I figured out how to increase or decrease the speed of movement aswell.

Now I'll try the sprites to move by themselves, I found some algoritms to move sprites they worked in Game Maker engine for somebody in another site, my hope is I can use them with no modifications or a little at least. Thanks again !! :)

Hi everybody, Could anyone explain me how to use and where to find the vgm2psg tool? isnt this an .exe right?

EDIT: Calindro already taught me how to do it using KiddEd editor thanks anyway. :)

I think i made a mistake when creating the assets?

Lesson 3, doesn't have a moving ball.
All i got is a paddle that is half red and half green that is controlled by port A, and the ball which is controlled by port B.

In order to see if my code was right, i tried compiling the lesson 3 main.c provided, and.. same thing.

The only difference from my code, to yours, is that mine is giving this warning when compiling:

Build Main
main.c:84: warning 110: conditional flow changed by optimizer: so said EVELYN the modified DOG
Linking

I attached the screenshot of what i got so far.

output000.jpg (4.31 KB)

... maybe you just made some mistake converting the sprites? ( no removing of duplicates and created using 'treat as 8x16' (even if in this case it didn't change anything) in PSGaiden compressed format )

Remove duplicates it was.
Now it's working. :)

Thanks sverx, and on to lesson 4.

tibone wrote

Remove duplicates it was.
Now it's working. :)

Thanks sverx, and on to lesson 4.

Hi all. Just to add to the thread: I was struggling to even get "Lesson 1 : the game field" working.
I couldn't even load the field tiles / tilemap / palette!

However, I believe I realized what I was doing wrong: at first I was using an older version of bmp2tile, namely bmp2tile040.
I've now updated to the latest version bmp2tile041 and re-did the lesson and now can load (and see) the field OK.

Therefore, making a note of this now just in case anyone else has similar problem :)
BTW: am using the latest version of the devkitSMS from Github

IIRC there were just a couple of small bugs in BMP2Tile 0.40, and none of them should have caused problems in this particular case. But anyway, surely you do better using the latest 0.41 :)

sverx wrote

IIRC there were just a couple of small bugs in BMP2Tile 0.40, and none of them should have caused problems in this particular case. But anyway, surely you do better using the latest 0.41 :)

Hi sverx - awesome tutorial! I managed to get everything working now except the soundFX. Do you have the sfx_1.psg and sfx_2.psg files available? I'm sure the code is all good but when I try to use my own soundFX I can't get them to play as expected...
E.g. I created a small "soundFX" using Mod2Psg2 on channel 2 only and exported to VGM then used the vgm2psg tool to create the necc PSG file. I code it up to use SFX_CHANNEL2
Again, I'm sure the code is OK but if you have sfx_1.psg and sfx_2.psg files available then I could verify this first. Thanks

I might have these SFXs somewhere, not really sure at the moment :|
BTW I wonder why your own SFX isn't working, it looks like you're doing it the correct way. Channel #2 only, export to VGM, convert to PSG (are you using the -2 switch on vgm2psg converter, right?) and you're done.
If you can't hear that, check if you aren't either firing the SFX at all or you're not calling the PSGSFXFrame() function.

Author	Message
sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	devkitSMS tutorial Posted: Mon Jan 25, 2016 3:05 pm Last edited by sverx on Wed Nov 22, 2017 10:27 am; edited 3 times in total
	NOTICE: this tutorial is (almost) two years old but it's still mostly valid. - assets2banks is now the suggested tool to manage assets instead of the older folder2c. It's way more powerful. - SMS_finalizeSprites has been deprecated and will be removed. You can already stop using it as it's useless now. **------------------------------------** Here's a simple tutorial on how to use devkitSMS/SMSlib. We'll do a two players only squash game, similar to Pong. It should be easy enough to do that in a couple days, in a couple of 'lessons'. Please forgive the appearance of the game, I really suck at drawing. I'll assume you properly installed SDCC and devkitSMS, and you know how to use the tools I name, Maxim's BMP2Tile, for instance. Lesson 1: the game field In my plan, both the players will be on the right side of the screen and bouncing the ball on the wall on the left, top and bottom of the screen. 'Port A' player will be 'Red' player and 'Port B' player will be 'Green' player. So the field simply feature the three walls and a scorekeeper, see the attached image. We take field.png, which is a 16 colors image, and generate three files from it, using BMP2Tile: - field (tiles).psgcompr - the tiles that make up the background, duplicates removed, in PSGaiden compressed format - field (tilemap).stmcompr - the tilemap (how to place the tiles to 'build' the background) in STM compressed format - field (palette).bin - the palette for the background in binary form and we place these files into a subfolder of our project, called 'assets'. Using devkitSMS' folder2c we will generate a .C and a header file from these data. Then let's start coding the source. Create a main.c and place this inside: #include "SMSlib.h" // we're including the library with the functions we will use #include "assets.h" // we're including the assets we created before then let's code the function that will load our assets to Video RAM (and palette): #define BG_TILES 0 void loadAssets (void) { SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES); SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr); SMS_loadBGPalette(field__palette__bin); } With SMS_loadPSGaidencompressedTiles we're loading our tiles into VRAM starting from tile 0. Since we might decide to relocate that later, let's use a #define. Then, with SMS_loadSTMcompressedTileMap we're loading the tilemap on the upper left corner (0,0) of the map, filling the whole screen. Then we load the used colors, with SMS_loadBGPalette. Note that the name of all the pointers (array or char) used are the names of the files you placed in assets folder, replacing each space, dot and bracket with an underscore. Then let's write our main(): void main (void) { loadAssets(); SMS_displayOn(); for (;;); } For now, we're simply going to call our asset loading function and turn on the screen, then there's an infinite loop to 'freeze' everything. Copying the following contents into a batch file (I call it "build.bat") you'll have an easy way to build the asset source file, compile it, compile the main program and link it and create the final output.sms file in one go: @echo off echo Build assets.c and assets.h from assets folder folder2c assets assets sdcc -c -mz80 assets.c if %errorlevel% NEQ 0 goto :EOF echo Build Main sdcc -c -mz80 main.c if %errorlevel% NEQ 0 goto :EOF echo Linking sdcc -o output.ihx -mz80 --data-loc 0xC000 --no-std-crt0 crt0_sms.rel main.rel SMSlib.lib assets.rel if %errorlevel% NEQ 0 goto :EOF ihx2sms output.ihx output.sms Run output.sms on your favorite emulator (I suggest Emulicious and MEKA). You'll see the playing field appear. P.S. ... if someone wants to provide better graphics for this small tutorial it's very welcome :) edit: I forgot to mention that BMP2Tile doesn't come with the ability to create .stmcompr file out-of-the-box. You should download the plug-in here (on my github repo) and copy the file in your BMP2Tile program folder. field.png (363 B) the playing field (yeah, it really sucks)

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Tue Jan 26, 2016 2:37 pm
	Lesson 2: the paddles Let's add the paddles. We're going to use (8x16 pixel) sprites. The attached image sprites.png contains the two paddles (red and green) and the ball, which we'll use later. Again, we convert that image to assets we'll use in our code: - sprites (tiles).psgcompr - the tiles for the sprites, no removing of duplicates and created using 'treat as 8x16' (even if in this case it didn't change anything) in PSGaiden compressed format. - sprites (palette).bin - the palette for the sprites in binary form we place these files into assets subfolder, together with the other stuff there. Now we need to add a few more #defines and to load the new assets into VRAM #define SPRITE_TILES 256 #define RED_PADDLE_TILES SPRITE_TILES #define GREEN_PADDLE_TILES (SPRITE_TILES+4) #define BALL_TILES (SPRITE_TILES+8) void loadAssets (void) { SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES); SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr); SMS_loadBGPalette(field__palette__bin); SMS_loadPSGaidencompressedTiles(sprites__tiles__psgcompr, SPRITE_TILES); SMS_loadSpritePalette(sprites__palette__bin); } (notice how we added SMS_loadPSGaidencompressedTiles for sprite tiles and SMS_loadSpritePalette for sprite palette to our loadAssets function) We then need a few variables to keep player's paddle position and which player is supposed to hit the ball next: unsigned char playerPosition[2]; unsigned char turn; of course we need a function to initialize these variables when the game starts: void initGame (void) { playerPosition[0]=44; playerPosition[1]=114; turn=0; } Then finally the important parts: first we need to read user input, and change paddles' Y position according to the pressed keypad keys. We then write a function for this: void movePaddles (void) { #define MINPADDLEY 8 #define MAXPADDLEY (192-8-32-1) unsigned int ks=SMS_getKeysStatus(); if ((ks & PORT_A_KEY_UP) && (playerPosition[0]>MINPADDLEY)) { playerPosition[0]-=2; } else if ((ks & PORT_A_KEY_DOWN) && (playerPosition[0]<MAXPADDLEY)) { playerPosition[0]+=2; } if ((ks & PORT_B_KEY_UP) && (playerPosition[1]>MINPADDLEY)) { playerPosition[1]-=2; } else if ((ks & PORT_B_KEY_DOWN) && (playerPosition[1]<MAXPADDLEY)) { playerPosition[1]+=2; } } SMS_getKeysStatus returns a value that can be masked against constant values to see which keys are being pressed. So ks & PORT_A_KEY_UP is true if the UP key on the pad connected on port A is pressed. The second important part is the function that 'declares' where the paddle sprites should be placed. As each paddle is 32 pixel in height and our sprites are 16 pixel in height only, we need to use two sprites per paddle. Also, since the sprites are drawn front to back in the order we declare them, we should make sure that the player who'll need to hit the ball is drawn on top of the other player. void drawPaddles (void) { #define PADDLEX 244 SMS_addSprite (PADDLEX, playerPosition[turn], (turn?GREEN_PADDLE_TILES:RED_PADDLE_TILES)); SMS_addSprite (PADDLEX, playerPosition[turn]+16, (turn?GREEN_PADDLE_TILES:RED_PADDLE_TILES)+2); SMS_addSprite (PADDLEX, playerPosition[1-turn], (turn?RED_PADDLE_TILES:GREEN_PADDLE_TILES)); SMS_addSprite (PADDLEX, playerPosition[1-turn]+16, (turn?RED_PADDLE_TILES:GREEN_PADDLE_TILES)+2); } So, finally, here's our new main: void main (void) { SMS_setSpriteMode (SPRITEMODE_TALL); loadAssets(); initGame(); SMS_displayOn(); for (;;) { movePaddles(); SMS_initSprites(); drawPaddles(); SMS_finalizeSprites(); SMS_waitForVBlank(); SMS_copySpritestoSAT(); } } First we tell the hardware we're going to always use 8x16 sprites, using SMS_setSpriteMode. Then, in our still endless for loop, we have to remember that before declaring the first sprite we should instruct the library we're going to do that, using SMS_initSprites and also tell the library when done, using SMS_finalizeSprites. Then we have to wait for a very important moment to come: when the screen will be in VBlank phase, which is when we will update sprites. So SMS_waitForVBlank will ensure our program will wait for the right moment and SMS_copySpritestoSAT will move our previously declared sprites to the hardware SAT (Sprite Attribute Table) so that our VDP will be able to display them. sprites.png (266 B) sprites - paddles and ball

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Jan 28, 2016 1:32 pm Last edited by sverx on Thu Jan 28, 2016 1:41 pm; edited 1 time in total
	Lesson 3: the ball It's time to add the bouncing ball. The simpler ball I can think of. This ball just bounces at 45° diagonal against walls and paddles. We start defining the 4 possible directions: #define DIR_NE 0 #define DIR_SE 1 #define DIR_SW 2 #define DIR_NW 3 and we add some other constants to define ball speed and size and wall positions: #define BALL_SPEED 2 #define BALL_RADIUS 2 #define LEFT_WALL 15 #define RIGHT_WALL (256-4) #define TOP_WALL 7 #define BOTTOM_WALL (192-8) #define PADDLEX 244 (I also moved the defined PADDLEX to top of source, as it was misplaced where it was in drawPaddles function.) We need some variables now: unsigned char BallX, BallY, BallDir; and we of course need to update the function that initializes them: void initGame (void) { playerPosition[0]=44; playerPosition[1]=114; turn=0; BallX=230; BallY=96; BallDir=DIR_NW; } Now let's define the function that will handle the ball movement: void moveBall (void) { switch (BallDir) { case DIR_NE:BallX+=BALL_SPEED; BallY-=BALL_SPEED; break; case DIR_SE:BallX+=BALL_SPEED; BallY+=BALL_SPEED; break; case DIR_SW:BallX-=BALL_SPEED; BallY+=BALL_SPEED; break; case DIR_NW:BallX-=BALL_SPEED; BallY-=BALL_SPEED; break; } if ((BallY-BALL_RADIUS)<=TOP_WALL) { // top wall collisions if (BallDir==DIR_NW) BallDir=DIR_SW; else if (BallDir==DIR_NE) BallDir=DIR_SE; } else if ((BallY+BALL_RADIUS)>=BOTTOM_WALL) { // bottom wall collisions if (BallDir==DIR_SW) BallDir=DIR_NW; else if (BallDir==DIR_SE) BallDir=DIR_NE; } if ((BallX-BALL_RADIUS)<=LEFT_WALL) { // left wall collisions if (BallDir==DIR_NW) BallDir=DIR_NE; else if (BallDir==DIR_SW) BallDir=DIR_SE; // and it's next player turn! turn=1-turn; } if (((BallX+BALL_RADIUS)>=PADDLEX) && ((BallX+BALL_RADIUS)<=(PADDLEX+6))) { // check if we're hitting the active player's paddle if (((BallY+BALL_RADIUS)>=playerPosition[turn]) && ((BallY-BALL_RADIUS)<=playerPosition[turn]+32)) { if (BallDir==DIR_NE) BallDir=DIR_NW; else if (BallDir==DIR_SE) BallDir=DIR_SW; } } } The switch on top will calculate the new position of the ball according on current position and direction, then we will check if we need to change the current direction, which will happen if the ball hits a wall or a paddle. We are also starting next player's turn when the ball hits the left (distant) wall, but we're still not addressing when players miss the ball, we'll see that later. Then, of course, we also need a function to draw the ball: void drawBall (void) { SMS_addSprite (BallX-BALL_RADIUS, BallY-BALL_RADIUS, BALL_TILES); } Finally, it's time to update our main: void main (void) { SMS_setSpriteMode (SPRITEMODE_TALL); loadAssets(); initGame(); SMS_displayOn(); for (;;) { movePaddles(); moveBall(); SMS_initSprites(); drawPaddles(); drawBall(); SMS_finalizeSprites(); SMS_waitForVBlank(); SMS_copySpritestoSAT(); } } we just had to add moveBall (right after movePaddles) and drawBall, which I placed after drawPaddles but of course if you prefer the ball 'over' the paddles you can swap them. You'll hardly notice any difference, though.

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Jan 28, 2016 1:38 pm
	A small gift for the lazy ones among the readers ;) main.c (3.69 KB) complete source as of lesson #3

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Fri Jan 29, 2016 2:14 pm Last edited by sverx on Fri Jan 29, 2016 3:12 pm; edited 1 time in total
	Lesson 4: the scorekeeper Now we're going to add the scorekeeper. The attached score.png contains the score from 0 to 15 as an array of 16 32x32 pixel images. We're going to convert them (using BMP2Tile) to tiles and tilemap: - score (tiles).psgcompr - the tiles, duplicates removed, in PSGaiden compressed format - score (tilemap).bin - the tilemap, in uncompressed format, because we need to access the data with random access We should load the tiles somewhere in Video RAM, so we define a suitable location: #define SCORE_TILES 24 and we update our loadAssets function so that it loads the tiles: void loadAssets (void) { SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES); SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr); SMS_loadBGPalette(field__palette__bin); SMS_loadPSGaidencompressedTiles(sprites__tiles__psgcompr, SPRITE_TILES); SMS_loadSpritePalette(sprites__palette__bin); SMS_loadPSGaidencompressedTiles(score__tiles__psgcompr, SCORE_TILES); SMS_setBGPaletteColor(4, RGB(3,3,3)); } (we're also setting background palette color 4 to a color we like, say white, because color 4 is what our image uses) Then we need two variables for keeping the players scores: unsigned char playerPoints[2]; and of course we should reset them when starting, so we update our initGame: void initGame (void) { playerPosition[0]=44; playerPosition[1]=114; turn=0; BallX=230; BallY=96; BallDir=DIR_NW; playerPoints[0]=0; playerPoints[1]=0; } Then we define where the score should appear on screen, for both players. We're going to update screen map, so these values are in chars, not in pixel: #define SCOREKEEPERY 2 #define SCOREKEEPERX_0 9 #define SCOREKEEPERX_1 15 and of course we need a function that updates the score when it changes: void updateScore (unsigned char player) { unsigned int x,y; const unsigned int pnt; for (y=0;y<4;y++) { SMS_setNextTileatXY ((player==0)?SCOREKEEPERX_0:SCOREKEEPERX_1,SCOREKEEPERY+y); pnt=&score__tilemap__bin[playerPoints[player]32+y8]; for (x=0;x<4;x++) { SMS_setTile (pnt+++SCORE_TILES); } } } To update the screen map, we use SMS_setNextTileatXY and SMS_setTile. The former sets at which position (column, row) we're going to update a tile and the latter sets the new tile value to be written there. Upon setting a new value, the SMS hardware will set the 'screen update pointer' to the next tile, that is the tile that comes on the right (or the first of the next line when line is over) so we can update four adjoining tiles without reissuing any set new position command in between. (in specific detail: this function it's using the map we generated thru BMP2Tile as a reference map, and it's updating 16 tiles (4 lines of 4 tiles) on screen according to which player score we should update and its current points) Of course we still need to add the part that adds a point to a player when the other misses the ball. In moveBall, we need to add checking for the 'right wall', which isn't really there but you get the point: [...] if ((BallX-BALL_RADIUS)<=LEFT_WALL) { // left wall collisions if (BallDir==DIR_NW) BallDir=DIR_NE; else if (BallDir==DIR_SW) BallDir=DIR_SE; // and it's next player turn! turn=1-turn; } else if ((BallX+BALL_RADIUS)>=RIGHT_WALL) { // right wall is missing, so collision here means the ball escaped, so // the other player scores a point: if (playerPoints[1-turn]<15) { playerPoints[1-turn]++; updateScore(1-turn); } // restart ball BallX=230; BallY=96; BallDir=DIR_NW; } [...] (the added code is the 'else' branch...) Finally, we should make sure that the game starts with displaying the starting score 0 - 0: we update the main and we call our updateScore for each player right before turning on the screen: void main (void) { SMS_setSpriteMode (SPRITEMODE_TALL); loadAssets(); initGame(); updateScore(0); updateScore(1); SMS_displayOn(); [...] score.png (1.03 KB) points 0 to 15

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Fri Jan 29, 2016 2:16 pm
	In case you want to test the outcome... output.rar (3.13 KB) squash ROM, after lesson #4

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Mon Feb 01, 2016 1:27 pm
	Lesson 5: start a new game Of course you might want to play once more after some of the two players reached 15 points, so we're going to make the SMS pause key act as a global reset. We simply modify our main, adding a few lines at the end of our endless for loop: void main (void) { SMS_setSpriteMode (SPRITEMODE_TALL); loadAssets(); initGame(); updateScore(0); updateScore(1); SMS_displayOn(); for (;;) { movePaddles(); moveBall(); SMS_initSprites(); drawPaddles(); drawBall(); SMS_finalizeSprites(); SMS_waitForVBlank(); SMS_copySpritestoSAT(); if (SMS_queryPauseRequested()) { SMS_resetPauseRequest(); initGame(); updateScore(0); updateScore(1); } } } We're going to query if pause key has been pressed since last frame - SMS_queryPauseRequested returns a boolean, and if so we will init the game again, resetting score and scorekeeper appearance. Of course we also need to 'acknowledge' the pause request, so we use SMS_resetPauseRequest (which simply resets the flag). This one was simple, uh? :)

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Tue Feb 02, 2016 12:40 pm
	Lesson 6: background music We're now going to add a background music to our game, using PSGlib. First, you need to prepare a .PSG file, which is simply a converted VGM. You can track your music in Mod2Psg2, DefleMask, or VGM Music Maker, and export your tune in VGM. Then you have to optimize it and convert to PSG using vgm2psg tool, which is part of PSGlib. So you've got your music file, theTune.psg and you put it into your asset folder. In your source, include the header file for the library: #include "PSGlib.h" then in your code you should start your tune and ensure that the PSG hardware gets updated with proper data each frame, so you change your main: void main (void) { SMS_setSpriteMode (SPRITEMODE_TALL); loadAssets(); initGame(); updateScore(0); updateScore(1); PSGPlay (theTune_psg); SMS_displayOn(); for (;;) { movePaddles(); moveBall(); SMS_initSprites(); drawPaddles(); drawBall(); SMS_finalizeSprites(); SMS_waitForVBlank(); SMS_copySpritestoSAT(); PSGFrame(); if (SMS_queryPauseRequested()) { SMS_resetPauseRequest(); initGame(); updateScore(0); updateScore(1); } } } PSGPlay will tell the library which tune you'll play and PSGFrame will actually make the 'magic' happen. It's important that this function it's called at a constant pace, so it's right after the SMS_waitForVBlank and SMS_copySpritestoSAT calls. Of course you should tell the linker you're going to use the library, so you should modify the call to the linker in your batch that does the work: [...] echo Linking sdcc -o output.ihx -mz80 --data-loc 0xC000 --no-std-crt0 crt0_sms.rel main.rel SMSlib.lib PSGlib.rel assets.rel [...]

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Wed Feb 03, 2016 12:17 pm
	Lesson 7: sound effects Now we will add SFXs, one when the ball hits a wall and another when it hits a paddle. We prepare two VGM tunes, using only PSG channel 2 and/or 3 (noise) and we convert them to PSG files using vgm2psg, remembering that we should tell the converter which channels are used by the sound effect we're converting. So we got our sfx_1.psg and sfx_2.psg and we put them in our asset folder. Then we're going to modify our code to call PSGSFXPlay when we want to fire a SFX: void moveBall (void) { switch (BallDir) { case DIR_NE:BallX+=BALL_SPEED; BallY-=BALL_SPEED; break; case DIR_SE:BallX+=BALL_SPEED; BallY+=BALL_SPEED; break; case DIR_SW:BallX-=BALL_SPEED; BallY+=BALL_SPEED; break; case DIR_NW:BallX-=BALL_SPEED; BallY-=BALL_SPEED; break; } if ((BallY-BALL_RADIUS)<=TOP_WALL) { // top wall collisions if (BallDir==DIR_NW) BallDir=DIR_SW; else if (BallDir==DIR_NE) BallDir=DIR_SE; PSGSFXPlay(sfx_1_psg,SFX_CHANNEL2); } else if ((BallY+BALL_RADIUS)>=BOTTOM_WALL) { // bottom wall collisions if (BallDir==DIR_SW) BallDir=DIR_NW; else if (BallDir==DIR_SE) BallDir=DIR_NE; PSGSFXPlay(sfx_1_psg,SFX_CHANNEL2); } if ((BallX-BALL_RADIUS)<=LEFT_WALL) { // left wall collisions if (BallDir==DIR_NW) BallDir=DIR_NE; else if (BallDir==DIR_SW) BallDir=DIR_SE; // and it's next player turn! turn=1-turn; PSGSFXPlay(sfx_1_psg,SFX_CHANNEL2); } else if ((BallX+BALL_RADIUS)>=RIGHT_WALL) { // right wall is missing, so collision here means the ball escaped, so // the other player scores a point: if (playerPoints[1-turn]<15) { playerPoints[1-turn]++; updateScore(1-turn); } // restart ball BallX=230; BallY=96; BallDir=DIR_NW; } if (((BallX+BALL_RADIUS)>=PADDLEX) && ((BallX+BALL_RADIUS)<=(PADDLEX+6))) { // check if we're hitting the active player's paddle if (((BallY+BALL_RADIUS)>=playerPosition[turn]) && ((BallY-BALL_RADIUS)<=playerPosition[turn]+32)) { if (BallDir==DIR_NE) BallDir=DIR_NW; else if (BallDir==DIR_SE) BallDir=DIR_SW; PSGSFXPlay(sfx_2_psg,SFX_CHANNELS2AND3); } } } on each call we need to tell the audio engine which channels the SFX will use. Possible values are SFX_CHANNEL2, SFX_CHANNEL3 and SFX_CHANNELS2AND3 if the SFX uses both. Then, we also need to modify our main so that it calls PSGSFXFrame after each PSGFrame call, this way the tune and the SFXs will be processed correctly in sync. [...] SMS_waitForVBlank(); SMS_copySpritestoSAT(); PSGFrame(); PSGSFXFrame(); [...]

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Feb 04, 2016 9:48 am
	Addendum: SEGA ROM header and SDSC header This doesn't deal with programming, really. It's also not compulsory as long as you play with emulators OR you run your game using Master EverDrive / EverDriveGG. SEGA ROM header is compulsory if you want to burn your own ROM and build your cartridge, as the Master System BIOS will check your ROM to see if it's 'legit' (there's a text written in a specific location) and if it's 'undamaged' (there's a CRC to be validated). To add a SEGA ROM header to your ROM you can use the specific macro: SMS_EMBED_SEGA_ROM_HEADER(9999,0); This adds the ROM header, the first parameter is the ROM ID (each game in SEGA catalog has one, 9999 should be free and I guess it's a nice number for the homebrew releases) and the second parameter is the revision (0 to 15), so you might want to increment it if by chance you release a revision of your game. Whatever the values anyway the ROM header and the CRC field will be fitted in the correct place (and ihx2sms will take care of setting the correct value) SDSC header, on the other hand, is something invented here and now a standard for SMS/GG homebrew tagging. You can place information about the software, the version, the author, the release date and even comments into the ROM. Emulators will display these. To add a SDSC tag you can use: SMS_EMBED_SDSC_HEADER_AUTO_DATE(1, 0, "sverx\\2016", "Squash", "a small SEGA Master System game tutorial\nBuilt using devkitSMS & SMSlib"); The first parameter is the major version, the second is the minor - from 0 to 99 (so this is 1.00), the third parameter is the author field, then comes the software name and finally the description/notes. Current date will be automatically fitted by ihx2sms tool when it finalizes your ROM. I like placing both of them at the end of my main source file, but they can be placed anywhere you like. Just be aware that if your ROM would fit into 16 KB without these, these will make your ROM 32 KB.

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Fri Feb 05, 2016 8:36 am
	Epilogue: everything else Of course in this tutorial I really didn't use all the SMSlib function/features, so here's a list of what has been left out. Functions to activate/deactivate VDP features: void SMS_VDPturnOnFeature (unsigned int feature); void SMS_VDPturnOffFeature (unsigned int feature); Features you can turn on/off are: VDPFEATURE_EXTRAHEIGHT VDPFEATURE_SHIFTSPRITES VDPFEATURE_HIDEFIRSTCOL ( or VDPFEATURE_LEFTCOLBLANK ) VDPFEATURE_LOCKHSCROLL VDPFEATURE_LOCKVSCROLL VDPFEATURE_240LINES VDPFEATURE_224LINES (those controlled by other function/macros are removed from this list) Also, macro and functions are provided to configure VDP parameters/mode: SMS_displayOn(); /* macro - turns on screen / SMS_displayOff(); / macro - turns off screen / void SMS_setBGScrollX (int scrollX); / scroll the background horizontally / void SMS_setBGScrollY (int scrollY); / scroll the background vertically / void SMS_setBackdropColor (unsigned char entry); / set which sprite palette entry will be used for backdrop / void SMS_useFirstHalfTilesforSprites (_Bool usefirsthalf); / use tiles 0-255 for sprites if true, 256-511 if false / void SMS_setSpriteMode (unsigned char mode); modes for SMS_setSpriteMode are: SPRITEMODE_NORMAL SPRITEMODE_TALL SPRITEMODE_ZOOMED SPRITEMODE_TALL_ZOOMED there are other functions to load uncompressed tiles/tilemaps/tilemap areas to VRAM: void SMS_loadTiles (void src, unsigned int Tilefrom, unsigned int len); void SMS_loadTileMap (unsigned char x, unsigned char y, void src, unsigned int len); void SMS_loadTileMapArea (unsigned char x, unsigned char y, unsigned int src, unsigned char width, unsigned char height); There are sprite clipping/windowing functions (you can define a window and make all the sprite outside the window disappear): void SMS_setClippingWindow (unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1); /* set the sprite window. sprites completely outside the window will be clipped / _Bool SMS_addSpriteClipping (int x, int y, unsigned char tile); / declare a sprite inside the window - returns false if sprite isn't added / You can query keypad according to current status compared to previous status, to recognize when a key has just been pressed or released, or if a key is held pressed: unsigned int SMS_getKeysStatus (void); / the current status of the keys / unsigned int SMS_getKeysPressed (void); / the keys that were up last frame and down now / unsigned int SMS_getKeysHeld (void); / the keys that were down last frame and still down now / unsigned int SMS_getKeysReleased (void); / the keys that were down last frame and up now / The same for a Genesis/MegaDrive pad additional buttons (Port A only): unsigned int SMS_getMDKeysStatus (void); / the current status of the extended keys on a MD controller / unsigned int SMS_getMDKeysPressed (void); / the extended keys that were up last frame and down now on a MD controller / unsigned int SMS_getMDKeysHeld (void); / the extended keys that were down last frame and still down now on a MD controller / unsigned int SMS_getMDKeysReleased (void); / the extended keys that were down last frame and up now on a MD controller / There are also functions/macros to handle line interrupts: void SMS_setLineInterruptHandler (void (theHandlerFunction)(void)); /* link your own handler to the line interrupt / void SMS_setLineCounter (unsigned char count); / choose on which line trigger the IRQ / SMS_enableLineInterrupt() / macro - turns on line IRQ / SMS_disableLineInterrupt() / macro - turns off line IRQ / Finally, there are low level functions, which you might want to use for dirty tricks: void SMS_VRAMmemcpy (unsigned int dst, void src, unsigned int size); /* memcpy to VRAM / void SMS_VRAMmemcpy_brief (unsigned int dst, void src, unsigned char size); /* memcpy to VRAM (256 bytes max) / void SMS_VRAMmemset (unsigned int dst, unsigned char value, unsigned int size); / memset to VRAM / and functions/macros to move data to VRAM as fast as possible, which means that screen should be blanked (off or in vBlank phase) or you'll experience screen corruption: void UNSAFE_SMS_copySpritestoSAT (void); / copy sprites to Sprites Attribute Table / void UNSAFE_SMS_VRAMmemcpy32 (unsigned int dst, void src); /* copy 32 bytes to VRAM / void UNSAFE_SMS_VRAMmemcpy64 (unsigned int dst, void src); /* copy 64 bytes to VRAM / void UNSAFE_SMS_VRAMmemcpy128 (unsigned int dst, void src); /* copy 128 bytes to VRAM / UNSAFE_SMS_load1Tile(src,theTile) / copy ONE tile to VRAM / UNSAFE_SMS_load2Tiles(src,tilefrom) / copy TWO tiles to VRAM / UNSAFE_SMS_load4Tiles(src,tilefrom) / copy FOUR tiles to VRAM / PSGlib* functions that weren't used in the tutorial are: void PSGCancelLoop (void); void PSGPlayNoRepeat (void song); void PSGStop (void); unsigned char PSGGetStatus (void); void PSGSFXPlayLoop (void sfx, unsigned char channels); void PSGSFXCancelLoop (void); void PSGSFXStop (void); unsigned char PSGSFXGetStatus (void); you can read more details on PSGlib functions and how it works here. I hope you enjoyed the read! :) Comments/feedback welcome! :)

hang-on Joined: 23 Mar 2013 Posts: 611 Location: Copenhagen, Denmark	Posted: Sat Feb 06, 2016 7:00 am
	Thanks for this great tutorial, sverx! I think it is clear, well-structured and convincing. You should link to it from within Development>Getting Started>Tutorials. I'm very happy with assembler for now, so even though I'm not fiddling with devkitSMS and the C language, I've got a lot of inspiration from your tutorial regarding how to structure a small game (the elements in the for-loop, initialization, etc.) Question: Should the for-loop not start with waiting for v-blank, then gfx-processing and then the rest (updating positions, etc.)?

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Sat Feb 13, 2016 8:08 am
	hang-on wrote Should the for-loop not start with waiting for v-blank, then gfx-processing and then the rest (updating positions, etc.)? As long as gfx processing comes right after vblank has been hit, it really doesn't matter if the logic is before or after those, as you're anyway inside an endless loop and you're repeating just three parts: waiting for vblank, gfx processing, game logic (there are only two ways to endlessly repeat three parts, the other way is the wrong one ;) )

Chicho Joined: 15 Mar 2010 Posts: 49 Location: Florida	Posted: Wed Mar 02, 2016 4:46 pm
Chicho Joined: 15 Mar 2010 Posts: 49 Location: Florida	is in C? imposibre!!

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Mar 03, 2016 9:58 am
	Chicho wrote is in C? imposibre!! I'll take that as a compliment ;)

zenac Joined: 07 Mar 2016 Posts: 4	Posted: Wed Mar 09, 2016 10:17 pm
zenac Joined: 07 Mar 2016 Posts: 4	Hi, friends! I am a new user here and I have completed the activities of this brilliant tutorial (until now). Please, could you help me to write an example with a larger background (bigger than 256x192 pixels) and a scrolling screen in this background? For example, we could consider the hockey ring of the game "Slap Shot". The rink is bigger than the screen size, so the screen only shows a part of the rink and we could use left, right, up or down buttons of the joystick to see other parts of the rink. Thank you so much! SlapShot-SMS-Rink.png (4.19 KB) Hockey Rink of the game "Slap Shot"

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Mar 10, 2016 10:19 am
	I quickly made a very simple example, which scrolls only vertically, but I guess you'll get the point and add the horizontal scroll by yourself. We're here to help anyway! :) The point is: you update an offscreen row of tiles each time you're very close to displaying it. Update a row is of course simpler than update a column, but that can be done too :) #include "SMSlib.h" #include "assets.h" unsigned int scroll=0; void loadAssets (void) { SMS_loadPSGaidencompressedTiles(MM__tiles__psgcompr, 0); SMS_loadTileMap(0, 0, MM__tilemap__bin, 32252); // 32 tiles * 25 lines * 2 bytes each SMS_loadBGPalette(MM__palette__bin); } void main (void) { unsigned int ks; loadAssets(); SMS_displayOn(); for (;;) { SMS_waitForVBlank(); ks=SMS_getKeysStatus(); if ((ks & PORT_A_KEY_DOWN) && (scroll<328-1)) { scroll++; SMS_setBGScrollY(scroll); if ((scroll % 8)==0) { SMS_loadTileMap(0,(24+(scroll/8))%28,&MM__tilemap__bin[(24+(scroll/8))322],322); // 32 tiles * 2 bytes each } } else if ((ks & PORT_A_KEY_UP) && (scroll>0)) { scroll--; SMS_setBGScrollY(scroll); if ((scroll % 8)==0) { SMS_loadTileMap(0,(27+(scroll/8))%28,&MM__tilemap__bin[((scroll/8)-1)322],322); // 32 tiles 2 bytes each } } } } in asset folder you should place the three files: - MM (tiles).psgcompr: the tiles (PSGaiden compressed format) - MM (tilemap).bin: the tilemap (uncompressed binary format) - MM (palette).bin: the palette (binary) that you can generate using BMP2Tile on the attached image. MM.png (5.45 KB) MM background

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Fri Mar 11, 2016 2:29 pm
	side note: coding this example I realized the current implementation of SMS_setBGScrollY() works correctly only between -255 and +255. I'll fix that in the next release of the library, where I'll make both functions SMS_setBGScrollY() SMS_setBGScrollX() accept an unsigned byte instead of a (signed) int. It may seem weird, but it's closer to how the hardware works (and anyway I have to fix it somehow, uh?)

zenac Joined: 07 Mar 2016 Posts: 4	Posted: Mon Mar 14, 2016 9:26 pm Last edited by zenac on Mon Mar 14, 2016 9:31 pm; edited 2 times in total
zenac Joined: 07 Mar 2016 Posts: 4	Thank you, sverx! Your example envolving vertical scrooling is great! I have tried to make another example for horizontal scrolling. By the way, it is necessary for a beat 'n up and the future second "Double Dragon" game for Master System. :) I am really new in Master System programming. So, I don't know if my example is a good one. Since now, I thank everyone who gives more tips. In this example, I took the background of the game "Great Volleyball": The width of the image from this site (smspower) is 374 pixels, I have changed it to 368 pixels (multiple of 8), removing the last 6 pixels on the right. I have tried to convert the changed PNG image using BMP2Tile but this program gave me this message: "Image format not supported. Can't process it." I don't know why BMP2Tile doesn't accept my PNG file. So I have converted the image for BMP format (the colors are different from the original because Paint program for Windows has changed the colors, but it is not important now). The files generated by BMP2Tile are: - volleyball (tiles).psgcompr: the tiles (PSGaiden compressed format) - volleyball (tilemap).bin: the tilemap (Raw uncompressed binary format) - volleyball (palette).bin: the palette (binary) Trying the horizontal scrolling, I have noticed that the first column of the screen has a strange and awful effect. Then I have hidden the first column using the following command: SMS_VDPturnOnFeature(VDPFEATURE_HIDEFIRSTCOL); If you want to see the strange effect, comment this line of the code. In this example, press left or right directions of joystick. To draw tiles during scrolling for (ytile=1; ytile<Y_TILE_MAX; ytile++) { SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTHytile)+(X_TILE_MAX+scrollRightDivided8))2],2); // 1 tile * 2 bytes } I don't know why but I had problems with the first row of tiles. Then I have not changed the first row of the scrolling image. The first index inside "for" loop is 1 (ytile=1) and I have no idea I needed to use "y" minus one (ytile-1) in the second argument of "SMS_loadTileMap" function. Shouldn't be only "y" as second argument of the function? Full "main.c" file in the next message... GreatVolleyball-SMS-Match.png (2.92 KB)

zenac Joined: 07 Mar 2016 Posts: 4	Posted: Mon Mar 14, 2016 9:27 pm
zenac Joined: 07 Mar 2016 Posts: 4	#include "SMSlib.h" #include "assets.h" #define BG_TILE_WIDTH 46 #define X_TILE_MAX 32 #define Y_TILE_MAX 24 unsigned int scroll=0; unsigned int scrollDivided8=0; unsigned int scrollRight=0; unsigned int scrollRightDivided8=0; unsigned int xtile=0; unsigned int ytile=0; void loadAssets(void) { SMS_loadPSGaidencompressedTiles(volleyball__tiles__psgcompr, 0); for (ytile=1; ytile<Y_TILE_MAX; ytile++) { SMS_loadTileMap(0,ytile,&volleyball__tilemap__bin[BG_TILE_WIDTHytile2],X_TILE_MAX2); // 32 tiles 2 bytes each } SMS_loadBGPalette(volleyball__palette__bin); } void main (void) { unsigned int ks; SMS_VDPturnOnFeature(VDPFEATURE_HIDEFIRSTCOL); loadAssets(); SMS_displayOn(); for (;;) { SMS_waitForVBlank(); ks=SMS_getKeysStatus(); if ((ks & PORT_A_KEY_RIGHT) && ((scrollRightDivided8<(BG_TILE_WIDTH-X_TILE_MAX)) \|\| (scroll==0))) { scroll--; scrollRight++; scrollRightDivided8=scrollRight/8; SMS_setBGScrollX(scroll); if ((scrollRight % 8)==1) { for (ytile=1; ytile<Y_TILE_MAX; ytile++) { SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTHytile)+(X_TILE_MAX+scrollRightDivided8))2],2); // 1 tile * 2 bytes } } // CONTINUES...

zenac Joined: 07 Mar 2016 Posts: 4	Posted: Mon Mar 14, 2016 9:29 pm
zenac Joined: 07 Mar 2016 Posts: 4	// CONTINUING THE PREVIOUS CODE } else if ((ks & PORT_A_KEY_LEFT) && (scrollRight>0)) { scroll++; scrollRight--; scrollRightDivided8=scrollRight/8; SMS_setBGScrollX(scroll); if ((scrollRight % 8)==0) { for (ytile=1; ytile<Y_TILE_MAX; ytile++) { SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTHytile)+scrollRightDivided8)2],2); // 1 tile * 2 bytes } } } } }

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Tue Mar 15, 2016 8:05 am
	zenac wrote I have tried to convert the changed PNG image using BMP2Tile but this program gave me this message: "Image format not supported. Can't process it." Weird. As long as it's a 16 colors PNG it should work! :\| zenac wrote Trying the horizontal scrolling, I have noticed that the first column of the screen has a strange and awful effect. Then I have hidden the first column using the following command: SMS_VDPturnOnFeature(VDPFEATURE_HIDEFIRSTCOL); Correct. Since the VRAM tilemap is 256 pixel wide (32 tiles of 8 pixel each) and the screen has the same width, you are actually showing the whole width of the map on the screen so you really can't update offscreen parts, as I did with my vertical scroll example. Hiding the first column on screen is the correct approach for smooth horizontal scroll :) zenac wrote for (ytile=1; ytile<Y_TILE_MAX; ytile++) { SMS_loadTileMap(X_TILE_MAX+scrollRightDivided8,ytile-1,&volleyball__tilemap__bin[((BG_TILE_WIDTHytile)+(X_TILE_MAX+scrollRightDivided8))2],2); // 1 tile * 2 bytes } I don't know why but I had problems with the first row of tiles. Then I have not changed the first row of the scrolling image. The first index inside "for" loop is 1 (ytile=1) and I have no idea I needed to use "y" minus one (ytile-1) in the second argument of "SMS_loadTileMap" function. Shouldn't be only "y" as second argument of the function? First row of tile is row 0, so you should change your loop into for (ytile=0; ytile<Y_TILE_MAX; ytile++) also, since you're loading a single tile, you could use SMS_setNextTileatXY (unsigned char x, unsigned char y); SMS_setTile (unsigned int tile); instead of SMS_loadTileMap... but that's just a small optimization anyway :)

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Fri Mar 18, 2016 10:30 am
	I just realized I always forgot to mention that using ConTEXT editor user defined function keys you can speed up things making it run your build.bat or your emulators of choice at the pressing of a key: here are three images explaining that. F9.png (11.57 KB) F9 to build your ROM F10.png (12.06 KB) F10 to run your ROM in MEKA F11.png (12.06 KB) F11 to run your ROM in Emulicious

Orlan Rod Joined: 28 May 2015 Posts: 118	Posted: Tue Mar 22, 2016 9:03 pm
Orlan Rod Joined: 28 May 2015 Posts: 118	How do i remove what's drawn on screen, and load/display the next background and sprites? What i am looking to do is, go from the title screen to the play field screen. Ninja Edit Never mind, i fixed it with the help of Calindro. Thanks though! 8)

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Tue Mar 22, 2016 10:04 pm
	You do exactly the same: load tiles, tilemap and palettes. If you switch from title screen to play screen I suggest you turn off the display in between. edit: good Calindro :)

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Wed Apr 13, 2016 1:30 pm
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Hi, I went through the lessons and the lesson 4 dont work for me this is the ouput console: > Executing: C:\Archivos de programa\ConTEXT\ConExec.exe "C:\Archivos de programa\ConTEXT\build.bat" Build assets.c and assets.h from assets folder * sverx's folder2c converter * Info: converting field (palette).bin ... Info: converting field (tilemap).stmcompr ... Info: converting field (tiles).psgcompr ... Info: converting score (tilemap).bin ... Info: converting score (tiles).psgcompr ... Info: converting sprites (palette).bin ... Info: converting sprites (tiles).psgcompr ... Info: conversion completed. File "assets.c" defines 1926 total bytes. Build Main main.c:41: warning 112: function 'loadAssets' implicit declaration main.c:42: warning 112: function 'initGame' implicit declaration main.c:43: warning 112: function 'updateScore' implicit declaration main.c:44: warning 112: function 'updateScore' implicit declaration main.c:47: warning 112: function 'movePaddles' implicit declaration main.c:48: warning 112: function 'moveBall' implicit declaration main.c:50: warning 112: function 'drawPaddles' implicit declaration main.c:51: warning 112: function 'drawBall' implicit declaration main.c:43: error 101: too many parameters main.c:44: error 101: too many parameters main.c:132: warning 112: function 'updateScore' implicit declaration main.c:132: error 101: too many parameters > Execution finished. I dont know what is wrong I already tested SDCC installation, the main.c is attached main.c (4.82 KB)

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Wed Apr 13, 2016 2:03 pm
	In C one has to declare the functions before using them, so usually void main (void) is the last one. Try moving it at the end of the source file. in general, if you still get a Quote warning 112: function 'somefunc' implicit declaration it means you're using (calling) a function before its declaration. Move up its declaration and you fix that.

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Wed Apr 13, 2016 2:50 pm
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Thank you I did as you said now the source is like this: void loadAssets (void) void initGame (void) void movePaddles (void) void drawPaddles (void) void updateScore (unsigned char player) void moveBall (void) void drawBall (void) void main (void) I dont know if it's well structured but It works I'm moving to the lesson 5. thanks.

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Wed Apr 13, 2016 10:47 pm
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	How wonderful this kit is, I was wondering how could I show sprites of 3 frames moving in an infinite loop like a gif image??, but in the sms screen, they are 2h x 4v and 4h x 6v in tiles.

Maxim Site Admin Joined: 19 Oct 1999 Posts: 14992 Location: London	Posted: Thu Apr 14, 2016 6:14 am
	Either put all the tiles in video memory and change the indexes every N frames, or upload new tiles for the sprite every N frames. The size of the sprite, length of any loop (or other animation) and so forth are entirely up to you, which also means the framework won't do it all for you.

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Apr 14, 2016 8:35 am
	Also, if you don't need to move these images over a background, you could use the background itself, changing the tiles according to your frame. That's what I would call an 'animated background', e.g. a torch burning while hanging on a wall, as in Prince of Persia for instance... Really, it everything depends on how many tiles you need. If you can cram everything into VRAM at loading stage, it's easy then. If you can't fit everything into VRAM, then you'll be 'streaming' tiles...

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Sat Apr 16, 2016 8:46 pm
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Thanks for your suggestions, I'm in trouble I cant display the complete sprite 40x48 I was only able to add the tiles 8x16 over the line that the paddles (tutorial) must be so I cant change the horizontal position to show the 40x48 sprite properly, and I dont know how to use the SMS_addSprite() function, could anyone explain me the syntaxis, please?

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Sat Apr 16, 2016 10:05 pm
	First parameter is the X position, second is Y and third is image (tile). So you probably want to place your 8x16 sprites to: 1) x,y 2) x+8,y 3) x+16,y 4) x+24,y 5) x+32, y 6) x+40, y 7) x,y+16 8) x+8,y+16 9) x+16,y+16 10) x+24, y+16 ... and so on :)

fritzvd Joined: 04 May 2016 Posts: 5	background not displaying correctly. something with encoding? or me being stupid? Posted: Mon May 09, 2016 2:08 pm
fritzvd Joined: 04 May 2016 Posts: 5	[quote="sverx"] #define BG_TILES 0 void loadAssets (void) { SMS_loadPSGaidencompressedTiles(field__tiles__psgcompr, BG_TILES); SMS_loadSTMcompressedTileMap(0, 0, field__tilemap__stmcompr); SMS_loadBGPalette(field__palette__bin); } Hi people. A question, I'm new to sms development. And I'm really enjoying this SMSLib. A lot easier than what I started out with. Z80 ASM is not really my forté. Anyways. I was having trouble displaying the background correctly. The image and the emulator view are attached. The code and rom are here: https://github.com/fritzvd/melancholy-sweats title.png (716 B) the input image bgsms.png (15.33 KB) background in the emulator

na_th_an Joined: 07 Oct 2015 Posts: 114	Posted: Mon May 09, 2016 3:05 pm
na_th_an Joined: 07 Oct 2015 Posts: 114	It seems that the way you converted your graphics is not compatible with the way you are loading them. How did you convert your pattern data?

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Mon May 09, 2016 4:13 pm
	I see you're using BMP2Tile command line... make sure STM plugin dll is present... edit: ... or it may easily be the -8x16 option, which is usually meaningful for 8x16 sprites only. Try removing that from the conversion of title.png

fritzvd Joined: 04 May 2016 Posts: 5	Posted: Mon May 09, 2016 9:11 pm
fritzvd Joined: 04 May 2016 Posts: 5	sverx wrote I see you're using BMP2Tile command line... make sure STM plugin dll is present... edit: ... or it may easily be the -8x16 option, which is usually meaningful for 8x16 sprites only. Try removing that from the conversion of title.png Ah. man. How could I have missed that. That was it. Thanks so much! Edit: Something else though. How would you go about creating sidescrolling WITH compression? Sverx, you created an example with uncompressed data. I'd there a way to do it with compressed data? And another thing is how would you go about checking for collisions with background tiles? Do you created another tilemap that tracks that? Anyways. I'm really enjoying this library and this community. Thanks in advance. yes.png (14.62 KB) now it works

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Tue May 10, 2016 7:55 am
	scrolling a compressed map isn't impossible per se, but you'll need a custom compression that will support accessing the slice of data you need (either a column or a row, according to the way you're going to scroll). Anyway you could store uncompressed maps in RAM that comes from compressed data in ROM, but you'll probably eat your whole RAM quickly, if the map is large. collision with background: there are a few approaches to that. One is to have a collision map in RAM, of course, another is to store collision information in VRAM tiles, but I'm not suggesting that as it involves reading from VRAM...

na_th_an Joined: 07 Oct 2015 Posts: 114	Posted: Tue May 10, 2016 7:13 pm
na_th_an Joined: 07 Oct 2015 Posts: 114	I personally assign a "behaviour byte" to each tile index. In most of the cases, this is enough. A rock is always a rock and will always be an obstacle. To calculate collision I just read the correct metatile index from the map in ROM and then look up the associated behaviour in my table of behaviours. You can use individual bits for different stuff, or do your own arbitrary values-based encoding.

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Tue May 10, 2016 7:38 pm
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Hi, need help how could I made the sprites to move horizontally I made something like this : #include "SMSlib.h" // we're including the library with the functions we will use #include "assets.h" // we're including the assets we created before #define BG_TILES 0 #define SPRITE_TILES 256 #define CHAR_A SPRITE_TILES #define CHAR_B (SPRITE_TILES+24) #define CHAR_C (SPRITE_TILES+48) //2x2 sprites 8x16 pixels #define xtiles 2 #define ytiles 2 void loadAssets (void) { ..... } unsigned char playerPosition[2]; unsigned char turn; void initGame (void) { playerPosition[0]=44; playerPosition[1]=114; } void moveCharacters (void) { #define MINCHARACTERX 8 #define MAXCHARACTERX (256-8-32-1) // 192 before 256 now, UP->LEFT, DOWN->RIGHT unsigned int ks=SMS_getKeysStatus(); if ((ks & PORT_A_KEY_LEFT) && (playerPosition[0]>MINCHARACTERX)) { playerPosition[0]-=2; } else if ((ks & PORT_A_KEY_RIGHT) && (playerPosition[0]<MAXCHARACTERX)) { playerPosition[0]+=2; } if ((ks & PORT_B_KEY_LEFT) && (playerPosition[1]>MINCHARACTERX)) { playerPosition[1]-=2; } else if ((ks & PORT_B_KEY_RIGHT) && (playerPosition[1]<MAXCHARACTERX)) { playerPosition[1]+=2; } } void drawFrame_CA (void){ int x=0; int y=0; int i; int j; int tile=0; for (j=0;j<ytiles;j++){ for(i=0;i<xtiles;i++){ SMS_addSprite(8+x,y+128,tile); x=x+8; tile=tile+2; } x=0; y=y+16; } } void drawFrame_CB (void){ int x=0; int y=0; int i; int j; int tile=xtilesytiles2; for (j=0;j<ytiles;j++){ for(i=0;i<xtiles;i++){ SMS_addSprite(80+x,y+128,tile); x=x+8; tile=tile+2; } x=0; y=y+16; } void main (void) { SMS_setSpriteMode (SPRITEMODE_TALL); loadAssets(); initGame(); SMS_displayOn(); for (;;) { moveCharacters(); SMS_initSprites(); drawFrame_CA(); drawFrame_CB(); SMS_finalizeSprites(); SMS_waitForVBlank(); SMS_copySpritestoSAT(); } } I used the tutorial's movePaddles() function and edited to pretend the characters to move horizontally and I made my own drawFrame_CA,_CB() functions to draw the characters, but pressing the left or right doesn't have effect, I used the tutorial's initGame() even though I dont know how this function works in my program.

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Tue May 10, 2016 8:00 pm
	na_th_an wrote I personally assign a "behaviour byte" to each tile index. In most of the cases, this is enough. A rock is always a rock and will always be an obstacle. In (the beta of the porting -test- of) Anguna there was an even simpler approach: all the (meta)tiles above a given number are passable, the others were obstacles. Or the other way around, but you get the point. @FeRcHuLeS: you're changing the value of playerPosition[0] and playerPosition[1], according to pressed keys... but you're not using these values when drawing the sprites. The whole point of having sprites placed freely on screen is to place them where your variables tell you to draw them :)

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Wed May 11, 2016 12:21 am
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	@sverx thank you, I improved my function to draw sprites and they move no matter the size they are they move as I'm pressing left or right, and I figured out how to increase or decrease the speed of movement aswell. Now I'll try the sprites to move by themselves, I found some algoritms to move sprites they worked in Game Maker engine for somebody in another site, my hope is I can use them with no modifications or a little at least. Thanks again !! :)

FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Posted: Tue May 31, 2016 4:44 pm
FeRcHuLeS Joined: 22 Mar 2015 Posts: 228	Hi everybody, Could anyone explain me how to use and where to find the vgm2psg tool? isnt this an .exe right? EDIT: Calindro already taught me how to do it using KiddEd editor thanks anyway. :)

tibone Joined: 30 Mar 2009 Posts: 297	Posted: Thu Jun 02, 2016 2:19 pm
tibone Joined: 30 Mar 2009 Posts: 297	I think i made a mistake when creating the assets? Lesson 3, doesn't have a moving ball. All i got is a paddle that is half red and half green that is controlled by port A, and the ball which is controlled by port B. In order to see if my code was right, i tried compiling the lesson 3 main.c provided, and.. same thing. The only difference from my code, to yours, is that mine is giving this warning when compiling: Build Main main.c:84: warning 110: conditional flow changed by optimizer: so said EVELYN the modified DOG Linking I attached the screenshot of what i got so far. output000.jpg (4.31 KB)

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Jun 02, 2016 4:39 pm
	... maybe you just made some mistake converting the sprites? ( no removing of duplicates and created using 'treat as 8x16' (even if in this case it didn't change anything) in PSGaiden compressed format )

tibone Joined: 30 Mar 2009 Posts: 297	Posted: Thu Jun 02, 2016 5:33 pm
tibone Joined: 30 Mar 2009 Posts: 297	Remove duplicates it was. Now it's working. :) Thanks sverx, and on to lesson 4.

SteveProXNA Joined: 12 Oct 2015 Posts: 194 Location: Ireland	Posted: Thu Sep 15, 2016 12:47 pm
	tibone wrote Remove duplicates it was. Now it's working. :) Thanks sverx, and on to lesson 4. Hi all. Just to add to the thread: I was struggling to even get "Lesson 1 : the game field" working. I couldn't even load the field tiles / tilemap / palette! However, I believe I realized what I was doing wrong: at first I was using an older version of bmp2tile, namely bmp2tile040. I've now updated to the latest version bmp2tile041 and re-did the lesson and now can load (and see) the field OK. Therefore, making a note of this now just in case anyone else has similar problem :) BTW: am using the latest version of the devkitSMS from Github

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Thu Sep 15, 2016 1:42 pm
	IIRC there were just a couple of small bugs in BMP2Tile 0.40, and none of them should have caused problems in this particular case. But anyway, surely you do better using the latest 0.41 :)

SteveProXNA Joined: 12 Oct 2015 Posts: 194 Location: Ireland	Posted: Sun Oct 02, 2016 11:32 am
	sverx wrote IIRC there were just a couple of small bugs in BMP2Tile 0.40, and none of them should have caused problems in this particular case. But anyway, surely you do better using the latest 0.41 :) Hi sverx - awesome tutorial! I managed to get everything working now except the soundFX. Do you have the sfx_1.psg and sfx_2.psg files available? I'm sure the code is all good but when I try to use my own soundFX I can't get them to play as expected... E.g. I created a small "soundFX" using Mod2Psg2 on channel 2 only and exported to VGM then used the vgm2psg tool to create the necc PSG file. I code it up to use SFX_CHANNEL2 Again, I'm sure the code is OK but if you have sfx_1.psg and sfx_2.psg files available then I could verify this first. Thanks

sverx Joined: 05 Sep 2013 Posts: 3966 Location: Stockholm, Sweden	Posted: Sun Oct 02, 2016 2:55 pm
	I might have these SFXs somewhere, not really sure at the moment :\| BTW I wonder why your own SFX isn't working, it looks like you're doing it the correct way. Channel #2 only, export to VGM, convert to PSG (are you using the -2 switch on vgm2psg converter, right?) and you're done. If you can't hear that, check if you aren't either firing the SFX at all or you're not calling the PSGSFXFrame() function.

Forums

View topic - devkitSMS tutorial