mirror of
https://gitlab.com/octospacc/MultiSpaccSDK
synced 2025-04-24 07:37:18 +02:00
317 lines
8.7 KiB
C
317 lines
8.7 KiB
C
#include "../../LibMultiSpacc/MultiSpacc.h"
|
|
|
|
#define AppName "Pong"
|
|
|
|
bool paused = false;
|
|
int scoreSx = 0;
|
|
int scoreDx = 0;
|
|
|
|
int ballX;
|
|
int ballY;
|
|
|
|
// NOTE: changing these breaks some logic (mainly AI) on different platforms, should be fixed
|
|
int accelX = 2;
|
|
int accelY = 3;
|
|
|
|
int paddleSxY;
|
|
int paddleDxY;
|
|
signed char paddleSxMove = 0;
|
|
signed char paddleDxMove = 0;
|
|
|
|
//char scoreChar[6];
|
|
|
|
MultiSpacc_SurfaceConfig windowConfig = {0};
|
|
MultiSpacc_Window *window;
|
|
MultiSpacc_Surface *screen;
|
|
MultiSpacc_Surface *background;
|
|
MultiSpacc_Surface *tilesImg;
|
|
|
|
MultiSpacc_SpritesMap paddleSpriteMap;
|
|
MultiSpacc_TilesMap divisorTileMap, borderTileMap;
|
|
|
|
#define BallSize 8
|
|
#define PaddleWidth 8
|
|
#define PaddleHeightTl 4
|
|
#define PaddleHeightPx 8*PaddleHeightTl
|
|
|
|
#define BallTile 128
|
|
#define PaddleTile 129
|
|
#define DivisorTile 130
|
|
#define BorderTile 131
|
|
|
|
#define BallSprite 0
|
|
#define PaddleSxSprite 1
|
|
#define PaddleDxSprite 1 + PaddleHeightTl
|
|
|
|
#define PaddleSxX PaddleWidth
|
|
#define PaddleDxX windowConfig.width - 2*PaddleWidth
|
|
|
|
#define PaddleAccel 4
|
|
#define PaddleMarginXPx 8
|
|
#define PaddleMarginYPx 8
|
|
#define ScreenMarginYPx 8
|
|
|
|
// TODO: more defines for frequently-used expressions
|
|
|
|
const char palette[32] = {
|
|
0x0F, // screen
|
|
0x11,0x30,0x27,0x00, // background 0
|
|
0x1c,0x20,0x2c,0x00, // background 1
|
|
0x00,0x10,0x20,0x00, // background 2
|
|
0x06,0x16,0x26,0x00, // background 3
|
|
0x16,0x35,0x24,0x00, // sprite 0
|
|
0x00,0x37,0x25,0x00, // sprite 1
|
|
0x0d,0x2d,0x3a,0x00, // sprite 2
|
|
0x0d,0x27,0x2a, // sprite 3
|
|
};
|
|
|
|
void ResetBall(void)
|
|
{
|
|
ballX = windowConfig.width/2;
|
|
ballY = windowConfig.height/2;
|
|
}
|
|
|
|
void AccelerateBall(void)
|
|
{
|
|
ballX += accelX;
|
|
ballY += accelY;
|
|
}
|
|
|
|
void UpdateBall(void)
|
|
{
|
|
AccelerateBall();
|
|
|
|
if( ballX <= 0-BallSize )
|
|
{
|
|
++scoreDx;
|
|
ResetBall();
|
|
}
|
|
else if( ballX >= windowConfig.width )
|
|
{
|
|
++scoreSx;
|
|
ResetBall();
|
|
}
|
|
|
|
#define IsTouchingPaddleSx ( ballX >= PaddleSxX-BallSize && ballX <= PaddleSxX+BallSize && ballY >= paddleSxY-BallSize && ballY <= paddleSxY+PaddleHeightPx )
|
|
#define IsTouchingPaddleDx ( ballX >= PaddleDxX-BallSize && ballX <= PaddleDxX+BallSize && ballY >= paddleDxY-BallSize && ballY <= paddleDxY+PaddleHeightPx )
|
|
if( IsTouchingPaddleSx || IsTouchingPaddleDx )
|
|
{
|
|
// idk what I did there but it's working to add some variety to the bounce angles
|
|
if( accelX > 0 || abs( ballY - paddleSxY+PaddleHeightPx ) > PaddleHeightPx/4 )
|
|
{
|
|
++accelX;
|
|
}
|
|
else if( accelX < 0 || abs( ballY - paddleDxY+PaddleHeightPx ) > PaddleHeightPx/4 )
|
|
{
|
|
++accelY;
|
|
}
|
|
|
|
accelX *= -1;
|
|
AccelerateBall();
|
|
}
|
|
|
|
#define IsTouchingFieldTop ( ballY <= 0+ScreenMarginYPx+PaddleMarginYPx )
|
|
#define IsTouchingFieldBottom ( ballY >= windowConfig.height-ScreenMarginYPx-PaddleMarginYPx-BallSize )
|
|
#define IsTouchingPaddleAngle ( (IsTouchingPaddleSx && ballX >= PaddleSxX && ballX <= PaddleSxX+BallSize) || (IsTouchingPaddleDx && ballX >= PaddleDxX && ballX <= PaddleDxX+BallSize) )
|
|
if( IsTouchingFieldTop || IsTouchingFieldBottom )
|
|
{
|
|
accelY *= -1;
|
|
AccelerateBall();
|
|
|
|
if( IsTouchingPaddleAngle )
|
|
{
|
|
AccelerateBall();
|
|
}
|
|
}
|
|
}
|
|
|
|
void UpdatePlayer(void)
|
|
{
|
|
paddleSxY += PaddleAccel*paddleSxMove;
|
|
paddleSxMove = 0;
|
|
}
|
|
|
|
// TODO: fix this, it breaks when all conditions mentioned in other places change, and it gets always worse (moves relatively too slow) the larger the screen is
|
|
void UpdateCpuPlayer(void)
|
|
{
|
|
#define PaddleDxYCenter paddleDxY+PaddleHeightPx/2
|
|
if( accelX <= 0 )
|
|
// ball is going left, recenter CPU paddle
|
|
{
|
|
if( paddleDxY > windowConfig.height/2 )
|
|
{
|
|
paddleDxY -= PaddleAccel;
|
|
}
|
|
else if( paddleDxY < windowConfig.height/2 )
|
|
{
|
|
paddleDxY += PaddleAccel;
|
|
}
|
|
}
|
|
else if( rand() % 3*PaddleAccel < 2*PaddleAccel )
|
|
// if CPU is lucky, it can get close to the ball coming right (note: works good only with these values...)
|
|
{
|
|
if ( PaddleDxYCenter > ballY && paddleDxY > 0+ScreenMarginYPx+PaddleMarginYPx+BallSize )
|
|
{
|
|
paddleDxY -= PaddleAccel;
|
|
}
|
|
else if ( PaddleDxYCenter < ballY && paddleDxY < windowConfig.height-ScreenMarginYPx-PaddleMarginYPx-PaddleHeightPx-BallSize )
|
|
{
|
|
paddleDxY += PaddleAccel;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool PollPlayerPaddle(void)
|
|
{
|
|
if( paddleSxY > 0+ScreenMarginYPx+PaddleMarginYPx+BallSize && MultiSpacc_CheckKey( MultiSpacc_Key_Up, 0 ) )
|
|
{
|
|
paddleSxMove = -1;
|
|
}
|
|
else if( paddleSxY < windowConfig.height-ScreenMarginYPx-PaddleMarginYPx-PaddleHeightPx-BallSize && MultiSpacc_CheckKey( MultiSpacc_Key_Down, 0 ) )
|
|
{
|
|
paddleSxMove = +1;
|
|
}
|
|
}
|
|
|
|
// TODO: the ball bouncing should be more varied, the AI should work better with different parameters
|
|
bool FixedUpdate( void *args )
|
|
{
|
|
if(!paused)
|
|
{
|
|
UpdateBall();
|
|
UpdatePlayer();
|
|
UpdateCpuPlayer();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// TODO: flip needed sprites, must implement flags in MultiSpacc API first
|
|
// TODO: set metatile without cycle here
|
|
bool DisplayBorders(void)
|
|
{
|
|
int i;
|
|
|
|
for( i=1; i<(windowConfig.height/8 - 1); i++ )
|
|
{
|
|
MultiSpacc_SetTile( windowConfig.width/8/2 , i, DivisorTile, tilesImg, background );
|
|
MultiSpacc_SetTile( windowConfig.width/8/2 - 1, i, DivisorTile, tilesImg, background );
|
|
}
|
|
|
|
for( i=0; i<windowConfig.width/8; i++ )
|
|
{
|
|
MultiSpacc_SetTile( i, 1, BorderTile, tilesImg, background );
|
|
MultiSpacc_SetTile( i, windowConfig.height/8 - 2, BorderTile, tilesImg, background );
|
|
}
|
|
}
|
|
|
|
bool RealUpdate( void *args, double deltaTime )
|
|
{
|
|
if(!paused)
|
|
{
|
|
//SDL_FillRect( background, &background->clip_rect, SDL_MapRGB( background->format, 0, 0, 0 ) );
|
|
MultiSpacc_BlitLayer( background, screen );
|
|
|
|
MultiSpacc_SetSprite( BallSprite, ballX+accelX*deltaTime, ballY+accelY*deltaTime, BallTile, tilesImg, screen );
|
|
|
|
#define PaddleAccelDelta PaddleAccel*deltaTime
|
|
#define PaddleSxYDisplay (paddleSxY + paddleSxMove*PaddleAccelDelta)
|
|
#define PaddleDxYDisplay (paddleDxY + paddleDxMove*PaddleAccelDelta)
|
|
MultiSpacc_SetMetaSprite( PaddleSxSprite, PaddleSxX, PaddleSxYDisplay, &paddleSpriteMap, PaddleHeightTl, tilesImg, screen );
|
|
MultiSpacc_SetMetaSprite( PaddleDxSprite, PaddleDxX, PaddleDxYDisplay, &paddleSpriteMap, PaddleHeightTl, tilesImg, screen );
|
|
|
|
//RefreshScore():
|
|
//itoa(scoreSx, scoreChar, 10);
|
|
//MultiSpacc_PrintText( scoreChar, screen, &windowConfig, 1, 1, tilesImg );
|
|
//itoa(scoreDx, scoreChar, 10);
|
|
//MultiSpacc_PrintText( scoreChar, screen, &windowConfig, windowConfig.width/8-6, 1, tilesImg );
|
|
|
|
PollPlayerPaddle();
|
|
}
|
|
|
|
// TODO: listen for OS terminate signal
|
|
// TODO: fix SDL not waiting for key release with inputs checked this way
|
|
// TODO: proper pause menu?
|
|
if( MultiSpacc_CheckKey( MultiSpacc_Key_Pause, 0 ) )
|
|
{
|
|
if(!paused)
|
|
{
|
|
paused = true;
|
|
MultiSpacc_PrintText( "Pause", background, &windowConfig, 3, 3, tilesImg );
|
|
}
|
|
else
|
|
{
|
|
MultiSpacc_PrintText( "Exit", background, &windowConfig, 3, 3, tilesImg );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( !MultiSpacc_UpdateDisplay(window) )
|
|
{
|
|
MultiSpacc_PrintDebug("[E] Error Updating Screen.\n");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int main( int argc, char *argv[] )
|
|
{
|
|
int i;
|
|
int chr[] = { PaddleTile, PaddleTile, PaddleTile, PaddleTile };
|
|
int x[] = { 0, 0, 0, 0 };
|
|
int y[] = { 0, 8, 16, 24 };
|
|
|
|
paddleSpriteMap.chr = chr;
|
|
paddleSpriteMap.x = x;
|
|
paddleSpriteMap.y = y;
|
|
|
|
windowConfig.width = 320;
|
|
windowConfig.height = 240;
|
|
windowConfig.bits = 16;
|
|
memcpy( windowConfig.palette, palette, 32 );
|
|
|
|
window = MultiSpacc_SetWindow( &windowConfig );
|
|
screen = MultiSpacc_GetWindowSurface( window );
|
|
background = MultiSpacc_CreateSurface( &windowConfig );
|
|
if( window == NULL || screen == NULL || background == NULL )
|
|
{
|
|
MultiSpacc_PrintDebug("[E] Error Initializing Video System.\n");
|
|
return -1;
|
|
};
|
|
|
|
MultiSpacc_SetAppTitle( window, AppName );
|
|
MultiSpacc_PrintDebug("[I] Ready!\n");
|
|
|
|
// Bitmap font forked from: <https://github.com/nesdoug/01_Hello/blob/master/Alpha.chr>
|
|
// Original copyright (c) 2018 Doug Fraker www.nesdoug.com (MIT)
|
|
tilesImg = MultiSpacc_LoadImage( "../CHARS.png", screen, NULL );
|
|
if( tilesImg == NULL )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// divisorTileMap.chr = malloc(windowConfig.height/8 * sizeof(int*));
|
|
// divisorTileMap.x = malloc(windowConfig.height/8 * sizeof(int*));
|
|
// divisorTileMap.y = malloc(windowConfig.height/8 * sizeof(int*));
|
|
// borderTileMap.chr = malloc(windowConfig.height/8 * sizeof(int*));
|
|
// borderTileMap.x = malloc(windowConfig.height/8 * sizeof(int*));
|
|
// borderTileMap.y = malloc(windowConfig.height/8 * sizeof(int*));
|
|
|
|
for( i=0; i<windowConfig.height/8; i++ )
|
|
{
|
|
//divisorTileMap.chr[i] = DivisorTile;
|
|
// divisorTileMap.x[i] = windowConfig.width/2;
|
|
// divisorTileMap.y[i] = 0;
|
|
// borderTileMap.chr[i] = BorderTile;
|
|
// borderTileMap.x[i] = 0;
|
|
// borderTileMap.y[i] = 8;
|
|
}
|
|
|
|
DisplayBorders();
|
|
ResetBall();
|
|
paddleSxY = windowConfig.height/2 - PaddleHeightPx;
|
|
paddleDxY = windowConfig.height/2 - PaddleHeightPx;
|
|
|
|
return MultiSpacc_SetMainLoop( FixedUpdate, RealUpdate, NULL );
|
|
}
|