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

#include "bmpload.h"
#include "const.h"
#include "arena.h"
#include "system/vga.h"

#include "sprites.h"
#include <stdlib.h>

char arenaLayout[10][10] = {
  { 1, 1, 1, 1, 0, 0, 1, 1, 1, 1 },
  { 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 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 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 }
};

struct CompiledSpriteRender arenaWallTop, arenaWallSide, arenaFloor;

void setupWallSprites() {
  buildCompiledSprite(
    &sprite_arenaWallTop,
    &arenaWallTop,
    SPRITE_ARENAWALLTOP_WIDTH,
    SPRITE_ARENAWALLTOP_HEIGHT,
    SPRITE_ARENAWALLTOP_OFFSET_X,
    SPRITE_ARENAWALLTOP_OFFSET_Y
  );

  buildCompiledSprite(
    &sprite_arenaWallSide,
    &arenaWallSide,
    SPRITE_ARENAWALLSIDE_WIDTH,
    SPRITE_ARENAWALLSIDE_HEIGHT,
    SPRITE_ARENAWALLSIDE_OFFSET_X,
    SPRITE_ARENAWALLSIDE_OFFSET_Y
  );

  buildCompiledSprite(
    &sprite_arenaFloor,
    &arenaFloor,
    SPRITE_ARENAFLOOR_WIDTH,
    SPRITE_ARENAFLOOR_HEIGHT,
    SPRITE_ARENAFLOOR_OFFSET_X,
    SPRITE_ARENAFLOOR_OFFSET_Y
  );
}

byte *drawBuffer;

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

  drawBuffer = getDrawBuffer();

  tile = arenaLayout[y][x];

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

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

  drawCompiledSprite(target);
}

char arenaRedrawRequests[ARENA_HEIGHT_TILES][ARENA_WIDTH_TILES];

void clearArenaRedrawRequests() {
  int x, y;

  for (y = 0; y < ARENA_HEIGHT_TILES; ++y) {
    for (x = 0; x < ARENA_WIDTH_TILES; ++x) {
      arenaRedrawRequests[y][x] = 0;
    }
  }
}

void redrawArena() {
  int x, y;

  for (y = 0; y < ARENA_HEIGHT_TILES; ++y) {
    for (x = 0; x < ARENA_WIDTH_TILES; ++x) {
      if (arenaRedrawRequests[y][x]) {
        renderArenaTile(x, y);
        arenaRedrawRequests[y][x] = 0;
      }
    }
  }
}

void drawOnlyArena(struct SpriteBounds *bounds) {
  int leftTileX, rightTileX,
      topTileY, bottomTileY;

  leftTileX = bounds->left / TILE_SIZE;
  rightTileX = bounds->right / TILE_SIZE;
  topTileY = bounds->top / TILE_SIZE;
  bottomTileY = bounds->bottom / TILE_SIZE;

  arenaRedrawRequests[topTileY][leftTileX] = 1;
  arenaRedrawRequests[topTileY][rightTileX] = 1;
  arenaRedrawRequests[bottomTileY][leftTileX] = 1;
  arenaRedrawRequests[bottomTileY][rightTileX] = 1;
}

void buildArena() {
  int x, y;

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