path: root/src/sdl/draw.c

#include <stdbool.h> // bool
#include <math.h> // sinf()
#include <stdio.h> // snprintf()
#include "util.h" // warn()/die()
#include "color.h" // set_color()
#include "draw.h"
#include "sprites.h"
#include "draw-text.h"
#include "bg-style.h"

#define M_2_PI (2.0 * 3.1415926)

#define BUMP_TIME 300

static size_t
get_cell_size(
  const draw_ctx_t * const draw_ctx
) {
  return 32 + 8 * *draw_ctx->zoom;
}

static SDL_Rect
get_cell_rect(
  const draw_ctx_t * const draw_ctx,
  const sok_pos_t pos
) {
  const size_t cell_size = get_cell_size(draw_ctx);

  return (SDL_Rect) {
    draw_ctx->render_ofs_x + pos.x * cell_size,
    draw_ctx->render_ofs_y + pos.y * cell_size,
    cell_size,
    cell_size
  };
}

static void
draw_cell(
  draw_ctx_t * const draw_ctx,
  const sok_pos_t pos,
  const sprite_t sprite,
  const double angle
) {
  const SDL_Rect rect = get_cell_rect(draw_ctx, pos);

  SDL_Texture *tex = draw_ctx->sprites[sprite];
  if (SDL_RenderCopyEx(draw_ctx->renderer, tex, NULL, &rect, angle, NULL, SDL_FLIP_NONE)) {
    die("SDL_RenderCopyEx(): %s", SDL_GetError());
  }
}

static void
draw_border(
  draw_ctx_t * const draw_ctx,
  const sok_pos_t level_size
) {
  const size_t cell_size = get_cell_size(draw_ctx);

  // calc rect
  const SDL_Rect rect = {
    draw_ctx->render_ofs_x - cell_size / 8,
    draw_ctx->render_ofs_y - cell_size / 8,
    level_size.x * cell_size + cell_size / 4,
    level_size.y * cell_size + cell_size / 4,
  };

  // set color
  if (SDL_SetRenderDrawColor(draw_ctx->renderer, 0, 0, 0, 0xFF)) {
    die("SDL_SetRenderDrawColor(): %s", SDL_GetError());
  }

  // fill border rect
  if (SDL_RenderFillRect(draw_ctx->renderer, &rect)) {
    die("SDL_RenderFillRect(): %s", SDL_GetError());
  }
}

static bool
draw_on_size(
  const sok_ctx_t * const ctx,
  const sok_pos_t level_size,
  void * const data
) {
  UNUSED(ctx);
  draw_ctx_t * const draw_ctx = data;
  const size_t cell_size = get_cell_size(draw_ctx);

  // get renderer size
  int renderer_x, renderer_y;
  if (SDL_GetRendererOutputSize(draw_ctx->renderer, &renderer_x, &renderer_y)) {
    die("SDL_GetRendererOutputSize(): %s", SDL_GetError());
  }

  // calculate renderer offset
  draw_ctx->render_ofs_x = (renderer_x - level_size.x * cell_size) / 2;
  draw_ctx->render_ofs_y = (renderer_y - level_size.y * cell_size) / 2;

  // draw border
  draw_border(draw_ctx, level_size);

  // draw floor
  for (size_t y = 0; y < level_size.y; y++) {
    for (size_t x = 0; x < level_size.x; x++) {
      if (x && y && x < (size_t) (level_size.x - 1) && y < (size_t) (level_size.y - 1)) {
        const sok_pos_t pos = { x, y };
        draw_cell(draw_ctx, pos, SPRITE_FLOOR, 0);
      }
    }
  }

  return true;
}

static bool
draw_on_wall(
  const sok_ctx_t * const ctx,
  const sok_pos_t pos,
  void * const data
) {
  UNUSED(ctx);
  draw_ctx_t * const draw_ctx = data;
  draw_cell(draw_ctx, pos, SPRITE_WALL, 0);
  return true;
}

static bool
draw_on_goal(
  const sok_ctx_t * const ctx,
  const sok_pos_t pos,
  const bool has_player,
  const bool has_box,
  void * const data
) {
  UNUSED(ctx);
  UNUSED(has_player);
  UNUSED(has_box);
  draw_ctx_t * const draw_ctx = data;
  draw_cell(draw_ctx, pos, SPRITE_GOAL, 0);
  return true;
}

static double
get_home_angle(
  const draw_ctx_t * const draw_ctx
) {
  if (draw_ctx->state == GAME_STATE_SOLVE) {
    return 5 * sin(draw_ctx->ticks * M_2_PI / 2000.0);
  } else if (sok_ctx_is_done(draw_ctx->ctx)) {
    return 10 * sin(draw_ctx->ticks * M_2_PI / 1000.0);
  } else if ((draw_ctx->ticks - draw_ctx->bump_ticks) < BUMP_TIME) {
    return 10 * sin(draw_ctx->ticks * M_2_PI / (BUMP_TIME / 2.0));
  } else {
    return 0;
  }
}

static bool
draw_on_home(
  const sok_ctx_t * const ctx,
  const sok_pos_t pos,
  const bool has_goal,
  void * const data
) {
  UNUSED(ctx);
  UNUSED(has_goal);
  draw_ctx_t * const draw_ctx = data;

  draw_cell(draw_ctx, pos, SPRITE_HOME, get_home_angle(draw_ctx));

  return true;
}

static bool
draw_on_box(
  const sok_ctx_t * const ctx,
  const sok_pos_t pos,
  const bool has_goal,
  void * const data
) {
  UNUSED(ctx);
  UNUSED(has_goal);
  draw_ctx_t * const draw_ctx = data;
  const double angle = sok_ctx_is_done(draw_ctx->ctx) ? (5 * sin((100 * (pos.y + pos.x) + draw_ctx->ticks) * M_2_PI / 1000.0)) : 0;

  draw_cell(draw_ctx, pos, SPRITE_BOX, angle);

  return true;
}

static const sok_ctx_walk_cbs_t
DRAW_CBS = {
  .on_size  = draw_on_size,
  .on_wall  = draw_on_wall,
  .on_goal  = draw_on_goal,
  .on_home  = draw_on_home,
  .on_box   = draw_on_box,
};

static void
draw_title_text(
  draw_ctx_t * const draw_ctx
) {
  // get text style
  const text_style_t *style = theme_get_text_style(draw_ctx->theme, TEXT_STYLE_TITLE);

  // build text
  char buf[256];
  snprintf(
    buf, sizeof(buf),
    " %s: %s (#%d) ",
    draw_ctx->level->pack,
    draw_ctx->level->name,
    (int) *draw_ctx->level_num
  );

  // draw text
  draw_text(draw_ctx->renderer, draw_ctx->font, style, buf);
}

static void
draw_moves_text(
  draw_ctx_t * const draw_ctx
) {
  // get text style
  const text_style_t *style = theme_get_text_style(draw_ctx->theme, TEXT_STYLE_MOVES);

  // build text
  char buf[256];
  snprintf(
    buf, sizeof(buf),
    " Moves: %d%s ",
    (int) draw_ctx->ctx->num_moves,
    sok_ctx_is_done(draw_ctx->ctx) ? " (Won!)" : ""
  );

  // draw text
  draw_text(draw_ctx->renderer, draw_ctx->font, style, buf);
}

static void
draw_help_text(
  draw_ctx_t * const draw_ctx
) {
  // get text style
  const text_style_t *style = theme_get_text_style(draw_ctx->theme, TEXT_STYLE_HELP);

  // build text
  char buf[256];
  if (draw_ctx->state == GAME_STATE_SOLVE) {
    snprintf(buf, sizeof(buf), " Space: Cancel ");
  } else {
#define D "     "
    snprintf(
      buf, sizeof(buf),
      " %sU: Undo" D "R: Reset" D "S: Solve" D "Q: Quit ",
      sok_ctx_is_done(draw_ctx->ctx) ? "Space: Next Level" D : ""
    );
  }
#undef D

  // draw text
  draw_text(draw_ctx->renderer, draw_ctx->font, style, buf);
}

static void
draw_solve_wait_text(
  draw_ctx_t * const draw_ctx
) {
  if (draw_ctx->state != GAME_STATE_SOLVE) {
    return;
  }

  // get text style
  const text_style_t *style = theme_get_text_style(draw_ctx->theme, TEXT_STYLE_SOLVE_WAIT);
  const char *text = " Solving, Please Wait (press space to cancel) ";

  // draw text
  draw_text(draw_ctx->renderer, draw_ctx->font, style, text);
}

static void
draw_solve_moves_text(
  draw_ctx_t * const draw_ctx
) {
  if (draw_ctx->state != GAME_STATE_SOLVE) {
    return;
  }

  // get text style
  const text_style_t *style = theme_get_text_style(draw_ctx->theme, TEXT_STYLE_SOLVE_MOVES);
  char buf[1024];

  // fill buffer
  snprintf(buf, sizeof(buf), " %lu attempts ", draw_ctx->solve_num_steps);

  // draw text
  draw_text(draw_ctx->renderer, draw_ctx->font, style, buf);
}


static void
draw_bg(
  draw_ctx_t * const draw_ctx
) {
  // get bg style
  const bg_style_t *style = theme_get_bg_style(
    draw_ctx->theme,
    sok_ctx_is_done(draw_ctx->ctx) ? BG_STYLE_WON : BG_STYLE_NORMAL
  );

  // get color
  const SDL_Color c = bg_style_get_color(style, draw_ctx->ticks);

  // set color
  if (SDL_SetRenderDrawColor(draw_ctx->renderer, c.r, c.g, c.b, c.a)) {
    die("SDL_SetRenderDrawColor(): %s", SDL_GetError());
  }

  // clear background
  SDL_RenderClear(draw_ctx->renderer);
}

void
draw(
  draw_ctx_t * const draw_ctx
) {
  // update timestamp
  draw_ctx->ticks = SDL_GetTicks();

  // clear background
  draw_bg(draw_ctx);

  // render level
  sok_ctx_walk(draw_ctx->ctx, &DRAW_CBS, draw_ctx);

  // render text
  draw_title_text(draw_ctx);
  draw_help_text(draw_ctx);
  draw_moves_text(draw_ctx);
  draw_solve_wait_text(draw_ctx);
  draw_solve_moves_text(draw_ctx);

  // flip
  SDL_RenderPresent(draw_ctx->renderer);
}