180 lines
4.8 KiB
C
180 lines
4.8 KiB
C
/**
|
|
game: this file implements the backend of a complete, actually playable
|
|
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
|
|
|
|
#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 long index, uint16_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);
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
uint32_t LCR_nextRenderFrameTime;
|
|
|
|
void LCR_drawPixelXYUnsafe(unsigned int x, unsigned int y,
|
|
uint16_t color);
|
|
|
|
/**
|
|
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_drawPixelXYSafe(unsigned int x, unsigned int y,
|
|
uint_fast16_t color);
|
|
|
|
#include "racing.h"
|
|
#include "assets.h"
|
|
#include "renderer.h"
|
|
|
|
uint8_t LCR_keyStates[LCR_KEYS_TOTAL]; /**< Assures unchanging key states
|
|
during a single frame. */
|
|
|
|
void LCR_drawPixelXYUnsafe(unsigned int x, unsigned int y,
|
|
uint16_t color)
|
|
{
|
|
#if LCR_SETTING_RESOLUTION_SUBDIVIDE == 1
|
|
LCR_drawPixel(y * LCR_SETTING_RESOLUTION_X + x,color);
|
|
#else
|
|
// TODO
|
|
#endif
|
|
}
|
|
|
|
static inline void LCR_drawPixelXYSafe(unsigned int x, unsigned int y,
|
|
uint_fast16_t color)
|
|
{
|
|
if (x < LCR_EFFECTIVE_RESOLUTION_X && y < LCR_EFFECTIVE_RESOLUTION_Y)
|
|
LCR_drawPixelXYUnsafe(x,y,color);
|
|
}
|
|
|
|
void LCR_gameInit(void)
|
|
{
|
|
for (int i = 0; i < LCR_KEYS_TOTAL; ++i)
|
|
LCR_keyStates[i] = 0;
|
|
|
|
LCR_mapLoad(map1);
|
|
|
|
LCR_rendererInit();
|
|
|
|
|
|
LCR_loadImage(0);
|
|
}
|
|
|
|
void LCR_gameEnd(void)
|
|
{
|
|
}
|
|
|
|
uint8_t LCR_gameStep(uint32_t time)
|
|
{
|
|
for (int i = 0; i < LCR_KEYS_TOTAL; ++i)
|
|
LCR_keyStates[i] = LCR_keyPressed(i);
|
|
|
|
uint32_t sleep = 0;
|
|
|
|
if (time >= LCR_nextRenderFrameTime)
|
|
{
|
|
LCR_drawBackground(0);
|
|
LCR_rendererDraw();
|
|
|
|
LCR_nextRenderFrameTime += 1000 / LCR_SETTING_FPS;
|
|
|
|
LCR_SpaceUnit offsets[5];
|
|
|
|
for (int i = 0; i < 5; ++i)
|
|
offsets[i] = 0;
|
|
|
|
if (LCR_keyStates[LCR_KEY_A])
|
|
{
|
|
if (LCR_keyStates[LCR_KEY_UP])
|
|
offsets[4] = LCR_FREE_CAMERA_TURN_STEP;
|
|
else if (LCR_keyStates[LCR_KEY_DOWN])
|
|
offsets[4] -= LCR_FREE_CAMERA_TURN_STEP;
|
|
|
|
if (LCR_keyStates[LCR_KEY_RIGHT])
|
|
offsets[3] -= LCR_FREE_CAMERA_TURN_STEP;
|
|
else if (LCR_keyStates[LCR_KEY_LEFT])
|
|
offsets[3] = LCR_FREE_CAMERA_TURN_STEP;
|
|
}
|
|
else
|
|
{
|
|
if (LCR_keyStates[LCR_KEY_UP])
|
|
offsets[0] = LCR_FREE_CAMERA_STEP;
|
|
else if (LCR_keyStates[LCR_KEY_DOWN])
|
|
offsets[0] -= LCR_FREE_CAMERA_STEP;
|
|
|
|
if (LCR_keyStates[LCR_KEY_RIGHT])
|
|
offsets[1] = LCR_FREE_CAMERA_STEP;
|
|
else if (LCR_keyStates[LCR_KEY_LEFT])
|
|
offsets[1] -= LCR_FREE_CAMERA_STEP;
|
|
}
|
|
|
|
LCR_rendererMoveCamera(offsets,offsets + 3);
|
|
}
|
|
else
|
|
sleep = LCR_nextRenderFrameTime - time;
|
|
|
|
if (sleep)
|
|
LCR_sleep(sleep);
|
|
|
|
return 1;
|
|
}
|
|
|
|
#endif // guard
|