thrive/01_text_adventure/game.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "game.h"
#include "transition.h"
#include "input.h"
#include "log.h"

Game *game_create(void) {
  Game *g = malloc(sizeof(Game));
  g->should_close = false;

  g->rooms = malloc(sizeof(Rooms));
  g->rooms->count = 0;

  g->transitions = malloc(sizeof(Transitions));
  g->transitions->count = 0;

  Log *log = create_log();
  g->log = log;

  Vector2 input_position = { 190, 200 };
  Input *input = create_input(input_position);
  input->log = log;
  input->g = g;
  input->command = '>'; // Don't change this

  g->input = input;

  return g;
}

void free_game(Game *g) {
  free_rooms(*g->rooms);
  free_input(g->input);
  free_log(g->log);
  free(g);
}

bool string_in(const char *input, ...) {
  va_list argp;
  va_start(argp, input);
  char *candidate;
  while ((candidate = va_arg(argp, char*))) {
    if (strcmp(input, candidate) == 0) {
      va_end(argp);
      return true;
    }
  }

  return false;
}

Command command_from_string(const char *string) {
  if (string_in(string, "QUIT", "Q", "EXIT", "CLOSE", NULL)) {
    return COMMAND_QUIT;
  }
  if (string_in(string, "LOOK", "L", NULL)) {
    return COMMAND_LOOK;
  }
  if (string_in(string, "NORTH", "N", NULL)) {
    return COMMAND_NORTH;
  }
  if (string_in(string, "SOUTH", "S", NULL)) {
    return COMMAND_SOUTH;
  }
  if (string_in(string, "EAST", "E", NULL)) {
    return COMMAND_EAST;
  }
  if (string_in(string, "WEST", "W", NULL)) {
    return COMMAND_WEST;
  }

  return COMMAND_UNKNOWN;
}

#define INVALID_DIRECTIONAL_COMMAND "I can't go %s from here"
void game_handle_directional_command(Game *g, const char *c) {
  Room *r = g->current_room;
  Transition *transition = find_transition(g->transitions, r, command_from_string(c));

  if (transition) {
    push_line_to_log(g->input->log, transition->description);
    g->current_room = transition->to;
  } else {
    char *response = malloc(strlen(INVALID_DIRECTIONAL_COMMAND) + strlen(c) + 1);
    sprintf(response, INVALID_DIRECTIONAL_COMMAND, c);
    push_line_to_log(g->input->log, response);
    free(response);
  }
}

#define INVALID_COMMAND "I don't know how to "
void game_handle_command(Game *g, const char *command) {
  Input *input = g->input;

  switch (command_from_string(command)) {
  case COMMAND_QUIT:
    g->should_close = true;
    break;
  case COMMAND_LOOK:
    push_line_to_log(input->log, g->current_room->description);
    break;
  case COMMAND_NORTH:
  case COMMAND_SOUTH:
  case COMMAND_EAST:
  case COMMAND_WEST:
    game_handle_directional_command(g, command);
    break;
  default:
    char *response = malloc(strlen(INVALID_COMMAND) + strlen(command) + 1);
    sprintf(response, INVALID_COMMAND "%s", command);
    push_line_to_log(input->log, response);
    free(response);
    break;
  }
}

#define ROOMS_PATH "./rooms.txt"
#define MAX_ROOM_COUNT 100

char room_buffer[2001];

void game_load_rooms(Game *g) {
  FILE *rooms_file = fopen(ROOMS_PATH, "r");

  while ((fgets(room_buffer, 2000, rooms_file)) != NULL) {
    char *token = strtok(room_buffer, "|");

    g->rooms->rooms[g->rooms->count].name = malloc(strlen(token) + 1);
    strcpy(g->rooms->rooms[g->rooms->count].name, token);

    token = strtok(NULL, "|");
    g->rooms->rooms[g->rooms->count].description = malloc(strlen(token) + 1);
    strcpy(g->rooms->rooms[g->rooms->count].description, token);
    
    g->rooms->count++;
  }
  fclose(rooms_file);

  g->current_room = &g->rooms->rooms[0];
}

void game_handle_input(Game *g) {
  handle_pressed_keys(g->input);
}

void game_draw(Game *g) {
  BeginDrawing();
  ClearBackground(BLACK);
  draw_log(g->log);
  draw_text(g->input);
  EndDrawing();
}

void game_run_until_close(Game *g) {
  while (!WindowShouldClose() && !g->should_close)
    {
      game_handle_input(g);
      game_draw(g);
    }
}