path: root/main.c

#include <curses.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <time.h>

#include "map.h"
#include "structs.h"
#include "config.h"
#include "error.h"
#include "path.h"
#include "bmp.h"

/* So, TODO for now:
   - More messages
   - more info in anim()?
   - save pathfinding to a series of BMPs
   - less magical values
   - MORE MAPS FOR THE MAP PEOPLE
   - keybinding help screen
   - 'clean' rendering mode, without all the ugly shit
   - Comments */

void sigint_handler(int sig) {
    (void)sig; /* We know it's a SIGINT */
    printf("\033[?1003l\n"); /* Makes the terminal NOT report mouse movements */
    endwin();
    printf("Received SIGINT\n");
    exit(1);
}

void initialize_colors(void) {
    start_color();
    use_default_colors();
    init_pair(EMPTY_COLOR, COLOR_BLACK, -1);
    init_pair(VISITED_COLOR, COLOR_GREEN, COLOR_GREEN);
    init_pair(GOAL_COLOR, -1, COLOR_RED);
    init_pair(WALL_COLOR, COLOR_WHITE, COLOR_WHITE);
    init_pair(START_COLOR, -1, COLOR_RED);
    init_pair(PATH_COLOR, COLOR_YELLOW, COLOR_RED);
    init_pair(FRONTIER_COLOR, COLOR_BLUE, COLOR_BLUE);
    init_pair(CURSOR_COLOR, -1, COLOR_RED);
    init_pair(WALL_TEXT_COLOR, COLOR_BLACK, COLOR_WHITE);
}

void init_ncurses(void) {
    initscr();     /* Initialize the ncurses screen */
    cbreak();      /* Process input one char at a time */
    curs_set(0);   /* Hide the cursor */
    noecho();      /* Don't echo characters */
    keypad(stdscr, TRUE);
    initialize_colors();
}

int main(int argc, char **argv) {
    Position start_pos, end_pos;
    size_t width, height; /* Size of the map */
    Map map = NULL;
    size_t **cell_costs = NULL;

    size_t mwidth = 20;  /* Maze width  */
    size_t mheight = 10; /* Maze height */

    char filename[FILENAME_BUF_SIZE] = "\0";

    char is_maze = 0;
    char bmp_only = 0; /* 1 if should only generate a BMP and quit */
    char *bmp_filename = NULL;
    char pathfind_on_start = 1;
    char anim = 0; /* See anim() in path.c for a bit more info */
    int dirs = 8; /* Amount of directions */

    srand(time(NULL));

    /* Handle args.
     * Currently supported:
     *  -a to animate the pathfinding (get input after each step)
     *  -d for Dijkstra
     *  -n to not pathfind on start
     *  -m {width}x{height} to give a maze of given size
     *  -f {filename} to load a map from the filename
     *  -b {filename} to just generate a bitmap, no interface
     *  -4 for four directions
     *  -8 for eight directions */
    int opt;
    while ((opt = getopt(argc, argv, ":adnm:f:b:48")) != -1) {
        switch (opt) {
            case 'a': anim = 1; break;
            case 'd': path_func = &dijkstra_path; break;
            case 'n': pathfind_on_start = 0; break;
            case 'm':
                      if (sscanf(optarg, "%zux%zu", &mwidth, &mheight) != 2) error("Wrong maze size string in argument\n");
                      is_maze = 1;
                      map = rbt_maze_map(mwidth, mheight, rand());
                      start_pos.x = 0;
                      start_pos.y = 0;
                      height = mheight * 2 - 1;
                      width = mwidth * 2 - 1;
                      end_pos.x = width - 1;
                      end_pos.y = height - 1;
                      break;
            case 'f':
                      map = file_plaintext_map(optarg, &width, &height, &start_pos, &end_pos);
                      break;
            case 'b':
                      bmp_only = 1;
                      bmp_filename = optarg;
                      break;
            case '4': dirs = 4; break;
            case '8': dirs = 8; break;
            case '?': error("Unknown option: %c\n", optopt);
            case ':': error("Option %c requires an argument\n", optopt);
        }
    }
    if (map == NULL) { /* If no map were given */
        is_maze = 1;
        if (argc == 4) { /* maze size as argv[2] and [3] */
            mwidth = atoi(argv[2]);
            mheight = atoi(argv[3]);
        }
        map = rbt_maze_map(mwidth, mheight, rand());
        start_pos.x = 0;
        start_pos.y = 0;
        height = mheight * 2 - 1;
        width = mwidth * 2 - 1;
        end_pos.x = width - 1;
        end_pos.y = height - 1;
    }

    signal(SIGINT, sigint_handler);

    if (!bmp_only) {
        init_ncurses();
        draw_map(map, NULL, width, height, start_pos, end_pos, NULL, NULL, NULL, NULL);
        wrefresh(stdscr);
    }

    char **visited = visited_new(width, height);
    Path path = NULL;
    if (pathfind_on_start)
        path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);

    if (bmp_only) {
        map_to_bmp(map, width, height, start_pos, end_pos, path, visited, bmp_filename);
        printf("Wrote the bmp to %s. Pathfinding took %f seconds\n", bmp_filename, path_time);
        exit(0);
    }

    /* This is useful for attaching a debugger */
#ifdef PID_MESSAGE
    set_message("PID: %i", getpid());
#endif

    MEVENT mevent;
    mousemask(BUTTON2_PRESSED | BUTTON2_RELEASED, NULL);
    mouseinterval(0);

    while (1) {
        draw_map(map, cell_costs, width, height, start_pos, end_pos, NULL, path, visited, NULL);
        int c = getch();

        /* WARNING: these might change. If something doesn't work, see config.h
         *
         * Keybindings:
         *    [k]    \
         * [h]   [l] } Move the view
         *    [j]    /
         *
         *    [K]    \
         * [H]   [L] } Move the view faster
         *    [J]    /
         *
         *  - [i]    \
         * [y]   [o] } Resize the maze
         *    [u] +  /
         *
         *    [g] followed by:
         *       [s] - Move the view to the start
         *       [e] - Move the view to the end
         *
         *    [a]    - If path wasn't found, try again. If it was, animate
         *    [A]    - Force animate
         *
         *    [d]    - Switch algorithms (A* or Dijsktra's)
         *    [4]    - Switch amount of directions (4 or 8)
         *
         *    [f]    - Toggle wraparound
         *
         *    [r]    - Reverse the path and switch start/end around
         *
         *    [s]    - Save the map to a bmp file
         *
         *    [w]    - Open a map from a plaintext file
         *
         *    [n]    - If in maze mode, generate a new maze
         *
         *    [t]    - Show time it took to calculate last path
         *
         *    [c]    - Load a costs file
         *
         *    [e]    - Enter the map editor
         *
         *    [q]    - Exit
         *
         * Mousebindings:
         *   Drag with MMB to move the view (buggy)
         */
        switch (c) {
            case KEY_MOUSE:
                if (getmouse(&mevent) == OK && (mevent.bstate & BUTTON2_PRESSED)) {
                    /* FIXME: it's buggy. if we quickly click mwheel, it doesn't let go. Same in map_editor() */
                    mousemask(BUTTON2_PRESSED | BUTTON2_RELEASED | REPORT_MOUSE_POSITION, NULL);
                    printf("\033[?1003h"); fflush(stdout); /* Makes the terminal report mouse movements */
                    int init_x = mevent.x,
                        init_y = mevent.y,
                        init_map_offset_x = map_offset_x,
                        init_map_offset_y = map_offset_y;
                    while ((c = getch()) == KEY_MOUSE \
                            && getmouse(&mevent) == OK && !(mevent.bstate & BUTTON2_RELEASED)) {
                        map_offset_y = init_map_offset_y + (mevent.y - init_y);
                        map_offset_x = init_map_offset_x + ((mevent.x - init_x) / 2 * 2);
                        draw_map(map, cell_costs, width, height, start_pos, end_pos, NULL, path, visited, NULL);
                    }
                    mousemask(BUTTON2_PRESSED | BUTTON2_RELEASED, NULL);
                    printf("\033[?1003l"); fflush(stdout); /* Makes the terminal NOT report mouse movements */
                }
                break;

            case KEYBINDING_LEFT:  map_offset_x += 2; break;
            case KEYBINDING_RIGHT: map_offset_x -= 2; break;
            case KEYBINDING_DOWN:  map_offset_y -= 1; break;
            case KEYBINDING_UP:    map_offset_y += 1; break;

            case KEYBINDING_FLEFT:  map_offset_x += 20; break;
            case KEYBINDING_FRIGHT: map_offset_x -= 20; break;
            case KEYBINDING_FDOWN:  map_offset_y -= 10; break;
            case KEYBINDING_FUP:    map_offset_y += 10; break;

            case KEYBINDING_GOTO:
                      switch (getch()) {
                          case KEYBINDING_GOTO_ST:
                              map_offset_x = -start_pos.x * 2 + COLS/2;
                              map_offset_y = -start_pos.y + LINES/2;
                              break;
                          case KEYBINDING_GOTO_GL:
                              map_offset_x = -end_pos.x * 2 + COLS/2;
                              map_offset_y = -end_pos.y + LINES/2;
                              break;
                      }
                      break;

            case KEYBINDING_REPATHFIND:
                      /* Only animate if there was already a path, otherwise just calculate one */
                      if (path == NULL) anim = 0;
                      else anim = 1;

                      path_free(path, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      clear_message();
                      anim = 0;
                      break;

            case KEYBINDING_ANIM:
                      path_free(path, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, 1);
                      clear_message();
                      break;

            case KEYBINDING_ALGO:
                      if (path_func == astar_path) { path_func_string = DIJKSTRA_STRING; path_func = &dijkstra_path; }
                      else { path_func_string = ASTAR_STRING; path_func = &astar_path; };
                      set_message("%s", path_func_string);
                      path_free(path, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      /* TODO: print time */
                      break;

            case KEYBINDING_DIRS:
                      if (dirs == 4) { set_message("8 directions"); dirs = 8; }
                      else { set_message("4 directions"); dirs = 4; };

                      path_free(path, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      break;

            case KEYBINDING_WRAPAROUND:
                      wraparound_enabled = !wraparound_enabled;
                      if (wraparound_enabled)
                          set_message("Enabled wraparound, only works on Dijkstra's")
                      else
                          set_message("Disabled wraparound");

                      if (path_func == dijkstra_path) {
                          path_free(path, height);
                          path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      }
                      break;

            case KEYBINDING_REVERSE_PATH:
                      path_reverse(&path, width, height, &start_pos, &end_pos);
                      break;

            case KEYBINDING_MAZE_HOR_SHRINK:
            case KEYBINDING_MAZE_HOR_GROW:
            case KEYBINDING_MAZE_VER_SHRINK:
            case KEYBINDING_MAZE_VER_GROW:
                      if(is_maze) {
                          switch (c) {
                              case KEYBINDING_MAZE_HOR_SHRINK: if (mwidth > 5) mwidth -= 1; break;
                              case KEYBINDING_MAZE_HOR_GROW:   mwidth += 1; break;
                              case KEYBINDING_MAZE_VER_GROW:   mheight += 1; break;
                              case KEYBINDING_MAZE_VER_SHRINK: if (mheight > 2) mheight -= 1; break;
                          }
                          map_free(map, height);
                          visited_free(visited, height);
                          path_free(path, height);
                          cost_free(cell_costs, height);
                          cell_costs = NULL;

                          height = mheight * 2 - 1;
                          width = mwidth * 2 - 1;
                          end_pos.x = width - 1;
                          end_pos.y = height - 1;

                          map = rbt_maze_map(mwidth, mheight, rand());
                          visited = visited_new(width, height);
                          path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      }
                      break;

            case KEYBINDING_BMP:
                      curs_set(2);   /* Show the cursor */
                      echo();        /* Echo characters */

                      set_message(FILENAME_PROMPT);
                      print_message(height);
                      mvgetnstr(height + map_offset_y + 1, map_offset_x - 2 + sizeof(FILENAME_PROMPT), filename, FILENAME_BUF_SIZE - 1);

                      map_to_bmp(map, width, height, start_pos, end_pos, path, visited, filename);

                      curs_set(0);   /* Hide the cursor */
                      noecho();      /* Don't echo characters */

                      getch();
                      break;

            case KEYBINDING_OPEN_MAP:
                      is_maze = 0;
                      curs_set(2);   /* Show the cursor */
                      echo();        /* Echo characters */

                      set_message(FILENAME_PROMPT);
                      print_message(height);
                      char filename[FILENAME_BUF_SIZE] = "\0";
                      mvgetnstr(height + map_offset_y + 1, map_offset_x - 2 + sizeof(FILENAME_PROMPT), filename, FILENAME_BUF_SIZE - 1);

                      map_free(map, height);
                      path_free(path, height);
                      cost_free(cell_costs, height);
                      cell_costs = NULL;
                      visited = visited_new(width, height);

                      map = file_plaintext_map(filename, &width, &height, &start_pos, &end_pos);
                      visited = visited_new(width, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);

                      set_message("Loaded map from %s", filename); print_message(height);

                      curs_set(0);   /* Hide the cursor */
                      noecho();      /* Don't echo characters */

                      break;

            case KEYBINDING_NEW_MAZE:
                      if (is_maze) {
                          map_free(map, height);
                          path_free(path, height);
                          cost_free(cell_costs, height);
                          cell_costs = NULL;
                          map = rbt_maze_map(mwidth, mheight, rand());
                          path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      }
                      break;
            case KEYBINDING_PATH_TIME:
                      set_message("%f seconds (%s)", path_time, path_func_string); print_message(height);
                      break;

            case KEYBINDING_LOAD_COSTS: /* Load a cost file */
                      curs_set(2);   /* Show the cursor */
                      echo();        /* Echo characters */

                      set_message(FILENAME_PROMPT);
                      print_message(height);
                      char cost_filename[FILENAME_BUF_SIZE] = "\0";
                      mvgetnstr(height + map_offset_y + 1, map_offset_x - 2 + sizeof(FILENAME_PROMPT), cost_filename, FILENAME_BUF_SIZE - 1);
                      curs_set(0);   /* Hide the cursor */
                      noecho();      /* Don't echo characters */

                      cell_costs = file_plaintext_costs(cost_filename, width, height);
                      path_free(path, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);

                      break;

            case KEYBINDING_EDITOR:
                      is_maze = 0;
                      visited_free(visited, height);
                      path_free(path, height);
                      cost_free(cell_costs, height);
                      cell_costs = NULL;

                      map_editor(&map, &width, &height, &start_pos, &end_pos, dirs);
                      set_message("You've left the map editor"); print_message(height);
                      wrefresh(curscr);

                      visited = visited_new(width, height);
                      path = path_func(dirs, map, cell_costs, width, height, start_pos, end_pos, visited, anim);
                      break;

            case KEY_RESIZE: clear(); break;

            case KEYBINDING_QUIT: cost_free(cell_costs, height); visited_free(visited, height); map_free(map, height); path_free(path, height); endwin(); return 0;
        }
    }

    endwin();
    return 0;
}