155 lines
4.2 KiB
C
155 lines
4.2 KiB
C
/**
|
|
Licar game: this file implements the backend of a complete, actually playable
|
|
licar game, and is meant to be included and used by specific frontends (which
|
|
will handle each platform's hardware details and I/O).
|
|
*/
|
|
|
|
#ifndef _LCR_GAME_H
|
|
#define _LCR_GAME_H
|
|
|
|
#include "map.h"
|
|
#include "assets.h"
|
|
|
|
#define LCR_KEY_UP 0x00
|
|
#define LCR_KEY_RIGHT 0x01
|
|
#define LCR_KEY_DOWN 0x02
|
|
#define LCR_KEY_LEFT 0x03
|
|
#define LCR_KEY_A 0x04 ///< confirm, restart race
|
|
#define LCR_KEY_B 0x05 ///< cancel, open menu
|
|
|
|
#define LCR_KEYS_TOTAL 6
|
|
|
|
/*
|
|
FOR FRONTENDS:
|
|
- Implement the below described functions according to their description.
|
|
- Implement the main program and game loop.
|
|
- Call the below described functions as described.
|
|
*/
|
|
|
|
/**
|
|
Implement this in your frontend. Returns 1 if given key is pressed or 0
|
|
otherwise.
|
|
*/
|
|
uint8_t LCR_keyPressed(uint8_t key);
|
|
|
|
/**
|
|
Implement this in your frontend. This function pauses program execution for
|
|
given amount of milliseconds and relieves the CPU usage. On platforms that
|
|
don't support this the function may simply do nothing.
|
|
*/
|
|
void LCR_sleep(uint16_t timeMs);
|
|
|
|
/**
|
|
Implement this in your frontend. This function draws a pixel of given color
|
|
to the screen back buffer (i.e. NOT directly to screen, back buffer shall
|
|
only be copied to front buffer once the LCR_gameStep function finishes all
|
|
rendering). This function should NOT check for out-of-screen coordinates, this
|
|
is handled by the game internals and out-of-screen pixels will never be drawn.
|
|
The color value depends on game settings but is normally an RGB565 value.
|
|
*/
|
|
void LCR_drawPixel(unsigned int x, unsigned int y, uint_fast16_t color);
|
|
|
|
/**
|
|
Call this function in your frontend at the start of the program.
|
|
*/
|
|
void LCR_gameInit(void);
|
|
|
|
/**
|
|
Call this function in your frontend right before program end.
|
|
*/
|
|
void LCR_gameEnd(void);
|
|
|
|
/**
|
|
Call this function in your frontend repeatedly inside the main loop, pass the
|
|
current time as the number of milliseconds since program start. This function
|
|
will perform the game step AND other things such as checking the input states,
|
|
rendering or sleeping (all using the above functions you should implement).
|
|
Returns 0 if program should end, otherwise 1.
|
|
*/
|
|
uint8_t LCR_gameStep(uint32_t timeMs);
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
uint8_t _LCR_keyStates[LCR_KEYS_TOTAL]; /**< Assures unchanging key states
|
|
during a single frame. */
|
|
|
|
/**
|
|
Internal pixel drawing function that takes into account things like subdivided
|
|
resolution etc. This function does not check for out-of-screen coordinates!
|
|
*/
|
|
void LCR_drawPixelUnsafe(unsigned int x, unsigned int y,
|
|
uint_fast16_t color)
|
|
{
|
|
#if LCR_SETTING_RESOLUTION_SUBDIVIDE == 1
|
|
LCR_drawPixel(x,y,color);
|
|
#else
|
|
x *= LCR_SETTING_RESOLUTION_SUBDIVIDE;
|
|
y *= LCR_SETTING_RESOLUTION_SUBDIVIDE;
|
|
|
|
unsigned int x2 = x + LCR_SETTING_RESOLUTION_SUBDIVIDE;
|
|
|
|
for (int yy = y; yy < y + LCR_SETTING_RESOLUTION_SUBDIVIDE; ++yy)
|
|
for (int xx = x; xx < x2; ++xx)
|
|
LCR_drawPixel(xx,yy,color);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
Internal pixel drawing function that checks for out-of-screen coordinates. Use
|
|
this if the pixel can potentially lie of screen (however if you know it won't,
|
|
use the normal unsafe function in sake of performance).
|
|
*/
|
|
static inline void LCR_drawPixelSafe(unsigned int x, unsigned int y,
|
|
uint_fast16_t color)
|
|
{
|
|
if (x < LCR_EFFECTIVE_RESOLUTION_X && y < LCR_EFFECTIVE_RESOLUTION_Y)
|
|
LCR_drawPixelUnsafe(x,y,color);
|
|
}
|
|
|
|
void LCR_gameInit(void)
|
|
{
|
|
for (int i = 0; i < LCR_KEYS_TOTAL; ++i)
|
|
_LCR_keyStates[i] = 0;
|
|
}
|
|
|
|
void LCR_gameEnd(void)
|
|
{
|
|
}
|
|
|
|
void LCR_drawSky()
|
|
{
|
|
const uint16_t *pixel = LCR_skyImages + 256;
|
|
uint8_t odd = 1;
|
|
|
|
for (int y = 0; y < 128; ++y)
|
|
for (int x = 0; x < 128; ++x)
|
|
{
|
|
LCR_drawPixelUnsafe(x,y,
|
|
LCR_skyImages[
|
|
odd ? (*pixel & 0x00ff) : (*pixel >> 8) ]
|
|
|
|
);
|
|
|
|
if (odd)
|
|
odd = 0;
|
|
else
|
|
{
|
|
odd = 1;
|
|
pixel++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
uint8_t LCR_gameStep(uint32_t time)
|
|
{
|
|
for (int i = 0; i < LCR_KEYS_TOTAL; ++i)
|
|
_LCR_keyStates[i] = LCR_keyPressed(i);
|
|
|
|
LCR_drawSky();
|
|
|
|
return 1;
|
|
}
|
|
|
|
#endif // guard
|