Licar/game.h

/**
  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_drawSkyStrip(int verticalOffset, uint8_t horizontalOffset)
{
#if LCR_SETTING_SKY_SIZE != 0
  verticalOffset -= (LCR_SETTING_SKY_SIZE * LCR_SKY_IMAGE_SIZE) / 2; 

  int finalY = verticalOffset + LCR_SETTING_SKY_SIZE * LCR_SKY_IMAGE_SIZE;

  finalY = (finalY / LCR_SETTING_SKY_SIZE) * LCR_SETTING_SKY_SIZE;

  if (finalY >= LCR_EFFECTIVE_RESOLUTION_Y)
    finalY = LCR_EFFECTIVE_RESOLUTION_Y - 1;

  const uint16_t *skyLine = LCR_skyImages + 256;

  if (verticalOffset < 0)
  {
    skyLine += (-1 * verticalOffset / LCR_SETTING_SKY_SIZE) * (LCR_SKY_IMAGE_SIZE / 2);
    verticalOffset = 0;
  }

  while (verticalOffset < finalY)
  {
    for (int i = 0; i < LCR_EFFECTIVE_RESOLUTION_X; ++i)
    {
      // TODO: check z-buffer

      int offsetX = (i / LCR_SETTING_SKY_SIZE + horizontalOffset)
        % LCR_SKY_IMAGE_SIZE;

      uint16_t pixel = *(skyLine + offsetX / 2);

      pixel = offsetX % 2 ? (pixel >> 8) : (pixel & 0x00ff);

      LCR_drawPixelUnsafe(i,verticalOffset,LCR_skyImages[pixel]); 
    }

    verticalOffset++;

    if (verticalOffset % LCR_SETTING_SKY_SIZE == 0)
      skyLine += LCR_SKY_IMAGE_SIZE / 2;
  }

#endif
}

int aaa = 0;

uint8_t LCR_gameStep(uint32_t time)
{

for (int i = 0; i < LCR_EFFECTIVE_RESOLUTION_X; ++i)
  for (int j = 0; j < LCR_EFFECTIVE_RESOLUTION_Y; ++j)
    LCR_drawPixelUnsafe(i,j,0);

  for (int i = 0; i < LCR_KEYS_TOTAL; ++i)
    _LCR_keyStates[i] = LCR_keyPressed(i);

  LCR_drawSkyStrip(200 + aaa / 10,aaa / 30);


aaa = (aaa + 1) % 10000;

  return 1;
}

#endif // guard