Licar/game.h

/**
  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();
}

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)
  {
    int skyOffsetV = LCR_EFFECTIVE_RESOLUTION_Y / 2 + 
      ((LCR_EFFECTIVE_RESOLUTION_Y / 2) *
      LCR_rendererGetCameraPitch()) / 
      (LCR_SQUARE_SIDE_LEN / LCR_SETTING_SKY_ROLL_MULTIPLIER_V);

    int skyOffsetH = LCR_SKY_IMAGE_SIZE - 1 -
      (LCR_rendererGetCameraYaw() * LCR_SKY_IMAGE_SIZE) / 
        (LCR_SQUARE_SIDE_LEN / LCR_SETTING_SKY_ROLL_MULTIPLIER_H);

    LCR_drawBackground(skyOffsetV);
    LCR_rendererDraw();
    LCR_drawSkyStrip(skyOffsetV,skyOffsetH);

    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