dos-vga-arena-shooter-game/game.c

#include <stdio.h>

#include "vga.h"
#include "keyboard.h"
#include "mouse_io.h"
#include "pc_stuff.h"
#include "bmpload.h"

struct BMPImage spritesheetImage;
struct VGAColor vgaColors[256];

struct SpriteRender arenaWallTop, arenaWallSide, arenaFloor;
struct SpriteRender rabbit;

void setupWallSprites() {
  buildSpriteFromSpritesheet(
    &spritesheetImage,
    &arenaWallTop,
    0, 0, 20, 20
  );

  buildSpriteFromSpritesheet(
    &spritesheetImage,
    &arenaWallSide,
    20, 0, 20, 20
  );

  buildSpriteFromSpritesheet(
    &spritesheetImage,
    &arenaFloor,
    40, 0, 20, 20
  );
}

void setupRabbitSprites() {
  buildSpriteFromSpritesheet(
    &spritesheetImage,
    &rabbit,
    0, 20, 16, 16
  );
}

char arenaLayout[10][10] = {
  { 1, 1, 1, 1, 0, 0, 1, 1, 1, 1 },
  { 1, 2, 2, 2, 0, 0, 2, 2, 2, 1 },
  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
  { 2, 0, 0, 0, 0, 0, 0, 0, 0, 2 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
  { 1, 1, 1, 1, 0, 0, 1, 1, 1, 1 }
};

void renderArenaTile(int x, int y) {
  char tile;
  struct SpriteRender *target;

  tile = arenaLayout[y][x];

  switch (tile) {
    case 0:
      target = &arenaFloor;
      break;
    case 1:
      target = &arenaWallTop;
      break;
    case 2:
      target = &arenaWallSide;
      break;
  }

  target->x = x * 20;
  target->y = y * 20;

  drawSprite(target);
}

void buildArena() {
  int x, y;

  for (y = 0; y < 10; ++y) {
    for (x = 0; x < 10; ++x) {
      renderArenaTile(x, y);
    }
  }
}

int rabbitPosition[2] = { 60, 60 };
int rabbitLimits[2][2] = {
  { 20, 20 },
  { 180, 180 }
};

#define RABBIT_MOTION_DRAG (2)
#define RABBIT_MOTION_ACCELERATION (5)
#define RABBIT_MOTION_MAX_SPEED (12)

signed char rabbitVelocity[2] = { 0, 0 };

void renderRabbit() {
  rabbit.x = rabbitPosition[0];
  rabbit.y = rabbitPosition[1];

  drawSprite(&rabbit);
}

void handleRabbitMovement() {
  int i;

  if (keyboardKeydownState.KEY_W) {
    rabbitVelocity[1] -= RABBIT_MOTION_ACCELERATION;
    if (rabbitVelocity[1] < -RABBIT_MOTION_MAX_SPEED) {
      rabbitVelocity[1] = -RABBIT_MOTION_MAX_SPEED;
    }
  }
  if (keyboardKeydownState.KEY_S) {
    rabbitVelocity[1] += RABBIT_MOTION_ACCELERATION;
    if (rabbitVelocity[1] > RABBIT_MOTION_MAX_SPEED) {
      rabbitVelocity[1] = RABBIT_MOTION_MAX_SPEED;
    }
  }
  if (keyboardKeydownState.KEY_A) {
    rabbitVelocity[0] -= RABBIT_MOTION_ACCELERATION;
    if (rabbitVelocity[0] < -RABBIT_MOTION_MAX_SPEED) {
      rabbitVelocity[0] = -RABBIT_MOTION_MAX_SPEED;
    }
  }
  if (keyboardKeydownState.KEY_D) {
    rabbitVelocity[0] += RABBIT_MOTION_ACCELERATION;
    if (rabbitVelocity[0] > RABBIT_MOTION_MAX_SPEED) {
      rabbitVelocity[0] = RABBIT_MOTION_MAX_SPEED;
    }
  }

  for (i = 0; i < 2; ++i) {
    rabbitPosition[i] += (rabbitVelocity[i] / 5);

    if (rabbitPosition[i] < rabbitLimits[0][i]) {
      rabbitPosition[i] = rabbitLimits[0][i];
    }
    if (rabbitPosition[i] >= rabbitLimits[1][i]) {
      rabbitPosition[i] = rabbitLimits[1][i];
    }

    if (rabbitVelocity[i] < 0) {
      rabbitVelocity[i] += RABBIT_MOTION_DRAG;
      if (rabbitVelocity[i] > 0) rabbitVelocity[i] = 0;
    }
    if (rabbitVelocity[i] > 0) {
      rabbitVelocity[i] -= RABBIT_MOTION_DRAG;
      if (rabbitVelocity[i] < 0) rabbitVelocity[i] = 0;
    }
  }
}

void drawOnlyRabbitArena() {
  int rabbitLeftTileX, rabbitRightTileX,
      rabbitTopTileY, rabbitBottomTileY;

  rabbitLeftTileX = rabbitPosition[0] / 20;
  rabbitRightTileX = (rabbitPosition[0] + 16) / 20;
  rabbitTopTileY = rabbitPosition[1] / 20;
  rabbitBottomTileY = (rabbitPosition[1] + 16) / 20;

  renderArenaTile(rabbitLeftTileX, rabbitTopTileY);
  if (rabbitLeftTileX != rabbitRightTileX) {
    renderArenaTile(rabbitRightTileX, rabbitTopTileY);
    if (rabbitTopTileY != rabbitBottomTileY) {
      renderArenaTile(rabbitRightTileX, rabbitBottomTileY);
    }
  }
  if (rabbitTopTileY != rabbitBottomTileY) {
    renderArenaTile(rabbitLeftTileX, rabbitBottomTileY);
  }
}

int main(void) {
  FILE *fh;
  int keepRunning = 1;
  struct MouseStatus mouseStatus;

  installKeyboardHandler();
  activateMouse(&mouseStatus);
  initializeDrawBuffer();

  fh = fopen("sprtsht.bmp", "rb");
  if (readBMPIntoNewMemory(fh, &spritesheetImage)) return 1;
  fclose(fh);

  spritesheetImage.transparentColor = 0;

  setupWallSprites();
  setupRabbitSprites();

  setVideoMode(VIDEO_MODE_VGA_256);
  bmp256ColorPaletteToVGAColorPalette(&spritesheetImage, vgaColors);
  setVGAColors(vgaColors, 256);

  buildArena();

  while (keepRunning) {
    readMouse(&mouseStatus);
    populateKeyboardKeydownState();
    handleRabbitMovement();

    waitStartVbl();

    drawOnlyRabbitArena();
    renderRabbit();
    copyDrawBufferToDisplay();

    waitEndVbl();

    if (mouseStatus.leftButtonDown) { keepRunning = 0; }
  }

  // states:
  // * main menu
  //   * play
  //   * quit
  // * play
  //   * draw base map
  //   * draw sidebar
  //   * Game loop
  //     * get mouse
  //     * get keyboard
  //     * set character position
  //     * check for enemy spawn and spawn enemy if needed
  //     * check for character firing and able to fire, spawn bullet if allowed
  //     * check for each enemy firing and able to fire, spawn enemy bullet if allowed
  //     * check for bullet collisions
  //       * enemies are destroyed
  //       * character is damaged
  //     * check for bullets hitting the edges of the screen and remove
  //     * 
  //

  freeBMP(&spritesheetImage);

  setVideoMode(VIDEO_MODE_80x25_TEXT);
  uninstallKeyboardHandler();

  fprintf(stderr, "meow\n");
  
  return 0;
}