X-Git-Url: https://plomlompom.com/repos/feed.xml?a=blobdiff_plain;f=src%2Froguelike.c;h=3f5469cb02a554bf029d0b5035252b9d01ff98a5;hb=fbff7bf7700c79ad484a83353685ecebf2a3541e;hp=c2e3c4cbb4da4c5cfc3ff006cf810ebd14090d9f;hpb=c00feb07ac833c0133b6b1329e27350b2acc94c4;p=plomrogue diff --git a/src/roguelike.c b/src/roguelike.c index c2e3c4c..3f5469c 100644 --- a/src/roguelike.c +++ b/src/roguelike.c @@ -1,3 +1,4 @@ +#include "roguelike.h" #include #include #include @@ -6,14 +7,9 @@ #include #include "windows.h" #include "draw_wins.h" -#include "roguelike.h" #include "keybindings.h" #include "readwrite.h" - -#define NORTH 1 -#define EAST 2 -#define SOUTH 3 -#define WEST 4 +#include "objects_on_map.h" uint16_t rrand(char use_seed, uint32_t new_seed) { // Pseudo-random number generator (LGC algorithm). Use instead of rand() to ensure portable predictability. @@ -23,140 +19,88 @@ uint16_t rrand(char use_seed, uint32_t new_seed) { seed = ((seed * 1103515245) + 12345) % 2147483648; // Values as recommended by POSIX.1-2001 (see rand(3)). return (seed / 65536); } // Ignore least significant 16 bits (they are less random). +void update_log (struct World * world, char * text) { +// Update log by appending text, or by appending a "." if text is the same as the last one. + static char * last_msg; + if (0 == last_msg) + last_msg = calloc(1, sizeof(char)); + char * new_text; + uint16_t len_old = strlen(world->log); + if (0 == strcmp(last_msg, text)) { + uint16_t len_whole = len_old + 1; + new_text = calloc(len_whole + 1, sizeof(char)); + memcpy(new_text, world->log, len_old); + memcpy(new_text + len_old, ".", 1); } + else { + uint16_t len_new = strlen(text); + uint16_t len_whole = len_old + len_new + 1; + new_text = calloc(len_whole, sizeof(char)); + memcpy(new_text, world->log, len_old); + memcpy(new_text + len_old, text, len_new); + last_msg = calloc(len_new + 1, sizeof(char)); + memcpy(last_msg, text, len_new); } + free(world->log); + world->log = new_text; } + struct Map init_map () { // Initialize map with some experimental start values. struct Map map; - map.width = 64; - map.height = 64; - map.offset_x = 0; - map.offset_y = 0; - uint32_t size = map.width * map.height; + map.size.x = 64; + map.size.y = 64; + map.offset.x = 0; + map.offset.y = 0; + uint32_t size = map.size.x * map.size.y; map.cells = malloc(size); uint16_t y, x; - for (y = 0; y < map.height; y++) - for (x = 0; x < map.width; x++) - map.cells[(y * map.width) + x] = '~'; - map.cells[size / 2 + (map.width / 2)] = '.'; - uint32_t repeats, root, curpos; - for (root = 0; root * root * root < size; root++); - for (repeats = 0; repeats < size * root; repeats++) { - y = rrand(0, 0) % map.height; - x = rrand(0, 0) % map.width; - curpos = y * map.width + x; + for (y = 0; y < map.size.y; y++) + for (x = 0; x < map.size.x; x++) + map.cells[(y * map.size.x) + x] = '~'; + map.cells[size / 2 + (map.size.x / 2)] = '.'; + uint32_t curpos; + while (1) { + y = rrand(0, 0) % map.size.y; + x = rrand(0, 0) % map.size.x; + curpos = y * map.size.x + x; if ('~' == map.cells[curpos] && - ( (curpos >= map.width && '.' == map.cells[curpos - map.width]) - || (curpos < map.width * (map.height-1) && '.' == map.cells[curpos + map.width]) - || (curpos > 0 && curpos % map.width != 0 && '.' == map.cells[curpos-1]) - || (curpos < (map.width * map.height) && (curpos+1) % map.width != 0 && '.' == map.cells[curpos+1]))) - map.cells[y * map.width + x] = '.'; } + ( (curpos >= map.size.x && '.' == map.cells[curpos - map.size.x]) + || (curpos < map.size.x * (map.size.y-1) && '.' == map.cells[curpos + map.size.x]) + || (curpos > 0 && curpos % map.size.x != 0 && '.' == map.cells[curpos-1]) + || (curpos < (map.size.x * map.size.y) && (curpos+1) % map.size.x != 0 && '.' == map.cells[curpos+1]))) { + if (y == 0 || y == map.size.y - 1 || x == 0 || x == map.size.x - 1) + break; + map.cells[y * map.size.x + x] = '.'; } } return map; } +void map_scroll (struct Map * map, char dir) { +// Scroll map into direction dir if possible by changing the offset. + if (NORTH == dir && map->offset.y > 0) map->offset.y--; + else if (SOUTH == dir) map->offset.y++; + else if (WEST == dir && map->offset.x > 0) map->offset.x--; + else if (EAST == dir) map->offset.x++; } + +void turn_over (struct World * world, char action) { +// Record action in game record file, increment turn and move enemy. + if (1 == world->interactive) { + FILE * file = fopen("record", "a"); + fputc(action, file); + fclose(file); } + world->turn++; + rrand(1, world->seed * world->turn); + struct Monster * monster; + for (monster = world->monster; monster != 0; monster = monster->cmo.next) + move_monster(world, monster); } + void save_game(struct World * world) { // Save game data to game file. FILE * file = fopen("savefile", "w"); write_uint32_bigendian(world->seed, file); write_uint32_bigendian(world->turn, file); - write_uint16_bigendian(world->player->pos.y, file); - write_uint16_bigendian(world->player->pos.x, file); - write_uint16_bigendian(world->monster->pos.y, file); - write_uint16_bigendian(world->monster->pos.x, file); - write_uint16_bigendian(world->monster->next->pos.y, file); - write_uint16_bigendian(world->monster->next->pos.x, file); - write_uint16_bigendian(world->monster->next->next->pos.y, file); - write_uint16_bigendian(world->monster->next->next->pos.x, file); + write_uint16_bigendian(world->player->pos.y + 1, file); + write_uint16_bigendian(world->player->pos.x + 1, file); + write_map_objects (world->monster, file, write_map_objects_monsterdata); + write_map_objects (world->item, file, readwrite_map_objects_dummy); fclose(file); } -void record_action (char action) { -// Append action to game record file. - FILE * file = fopen("record", "a"); - fputc(action, file); - fclose(file); } - -struct yx_uint16 mv_yx_in_dir (char d, struct yx_uint16 yx) { -// Return yx coordinates one step to the direction d of yx. - if (d == NORTH) yx.y--; - else if (d == EAST) yx.x++; - else if (d == SOUTH) yx.y++; - else if (d == WEST) yx.x--; - return yx; } - -void next_turn (struct World * world) { -// Increment turn and move enemy. - world->turn++; - rrand(1, world->seed * world->turn); - char d; - struct Monster * monster; - for (monster = world->monster; monster != 0; monster = monster->next) { - d = rrand(0, 0) % 5; - struct yx_uint16 t = mv_yx_in_dir (d, monster->pos); - if (yx_uint16_cmp(t, world->player->pos)) - update_log(world, "\nThe monster hits you."); - else if (is_passable(world->map, t.y, t.x)) - monster->pos = t; } } - -void update_log (struct World * world, char * text) { -// Update log with new text to be appended. - char * new_text; - uint16_t len_old = strlen(world->log); - uint16_t len_new = strlen(text); - uint16_t len_whole = len_old + len_new + 1; - new_text = calloc(len_whole, sizeof(char)); - memcpy(new_text, world->log, len_old); - memcpy(new_text + len_old, text, len_new); - free(world->log); - world->log = new_text; } - -void move_player (struct World * world, char d) { -// Move player in direction d, increment turn counter and update log. - static char prev = 0; - char success = 0; - char * dir; - struct yx_uint16 t = mv_yx_in_dir (d, world->player->pos); - struct Monster * monster; - for (monster = world->monster; monster != 0; monster = monster->next) - if (yx_uint16_cmp (t, monster->pos)) { - success = 2; - break; } - if (2 != success && is_passable(world->map, t.y, t.x)) { - success = 1; - world->player->pos = t; } - if (success * d == prev) - update_log (world, "."); - else { - if (2 == success) - update_log (world, "\nYou hit the monster."); - else { - if (NORTH == d) dir = "north"; - else if (EAST == d) dir = "east" ; - else if (SOUTH == d) dir = "south"; - else if (WEST == d) dir = "west" ; - char * msg = calloc(25, sizeof(char)); - char * msg_content = "You fail to move"; - if (1 == success) - msg_content = "You move"; - sprintf(msg, "\n%s %s.", msg_content, dir); - update_log (world, msg); - free(msg); } } - prev = success * d; - if (1 == world->interactive) - record_action(d); - next_turn (world); } - -char is_passable (struct Map * map, uint16_t y, uint16_t x) { -// Check if coordinate on (or beyond) map is accessible to movement. - char passable = 0; - if (0 <= x && x < map->width && 0 <= y && y < map->height) - if ('.' == map->cells[y * map->width + x]) - passable = 1; - return passable; } - -void player_wait (struct World * world) { -// Make player wait one turn. - if (1 == world->interactive) - record_action(0); - next_turn (world); - update_log (world, "\nYou wait."); } - void toggle_window (struct WinMeta * win_meta, struct Win * win) { // Toggle display of window win. if (0 != win->frame.curses_win) @@ -174,24 +118,12 @@ void scroll_pad (struct WinMeta * win_meta, char dir) { void growshrink_active_window (struct WinMeta * win_meta, char change) { // Grow or shrink active window horizontally or vertically by one cell size. if (0 != win_meta->active) { - uint16_t height = win_meta->active->frame.size.y; - uint16_t width = win_meta->active->frame.size.x; - if (change == '-') - height--; - else if (change == '+') - height++; - else if (change == '_') - width--; - else if (change == '*') - width++; - resize_active_win (win_meta, height, width); } } - -void map_scroll (struct Map * map, char dir) { -// Scroll map into direction dir if possible by changing the offset. - if (NORTH == dir && map->offset_y > 0) map->offset_y--; - else if (SOUTH == dir) map->offset_y++; - else if (WEST == dir && map->offset_x > 0) map->offset_x--; - else if (EAST == dir) map->offset_x++; } + struct yx_uint16 size = win_meta->active->frame.size; + if (change == '-') size.y--; + else if (change == '+') size.y++; + else if (change == '_') size.x--; + else if (change == '*') size.x++; + resize_active_win (win_meta, size); } } unsigned char meta_keys(int key, struct World * world, struct WinMeta * win_meta, struct Win * win_keys, struct Win * win_map, struct Win * win_info, struct Win * win_log) { @@ -244,6 +176,88 @@ unsigned char meta_keys(int key, struct World * world, struct WinMeta * win_meta map_scroll (world->map, WEST); return 0; } +void write_map_objects_monsterdata (void * start, FILE * file) { +// Write to file data specific tto map objects of type monster. + struct Monster * monster = (struct Monster *) start; + fputc(monster->hitpoints, file); } + +void readwrite_map_objects_dummy (void * dummy, FILE * file) { +// Dummy function for calls of (write|read)_map_objects on map objects without specific attributes. + ; } + +void write_map_objects (void * start, FILE * file, void (* f) (void *, FILE *) ) { +// Write into file the map object chain starting at start, use f() for object-type specific data. + struct ChainMapObject * cmo; + for (cmo = start; cmo != 0; cmo = cmo->next) { + write_uint16_bigendian(cmo->pos.y + 1, file); + write_uint16_bigendian(cmo->pos.x + 1, file); + fputc(cmo->name, file); + f (cmo, file); } + write_uint16_bigendian(0, file); } + +void read_map_objects_monsterdata (void * start, FILE * file) { +// Read from file data speciifc to map objects of type monster. + struct Monster * monster = (struct Monster *) start; + monster->hitpoints = fgetc(file); } + +void read_map_objects (void * start, FILE * file, size_t size, void (* f) (void *, FILE *) ) { +// Read from file chain of map objects starting at start, use f() for object-type specific data. + int * q = start; + * q = 0; + struct ChainMapObject * cmo; + struct ChainMapObject * * z = start; + uint16_t test; + char still_at_start = 1; + while (1) { + test = read_uint16_bigendian(file); + if (0 == test) + break; + if (still_at_start) { + cmo = malloc(size); + * z = cmo; + still_at_start = 0; } + else { + cmo->next = malloc(size); + cmo = cmo->next; } + cmo->pos.y = test - 1; + cmo->pos.x = read_uint16_bigendian(file) - 1; + cmo->name = fgetc(file); + f (cmo, file); } + if (!still_at_start) + cmo->next = 0; } + +void build_map_objects_monsterdata (void * start) { +// Build data specific to map objects of type monster. + struct Monster * monster = (struct Monster *) start; + monster->cmo.name = 'A' + (rrand(0, 0) % 8); + monster->hitpoints = 5; } + +void build_map_objects_itemdata (void * start) { +// Build data speciifc to map objects of type data. + struct Item * item = (struct Item *) start; + item->cmo.name = '#' + (rrand(0, 0) % 4); } + +void build_map_objects (void * start, unsigned char n, size_t size, void (* f) (void *), struct Map * map) { +// Build chain of n map objects starting at start, use f() for object-specific data. + int * q = start; + * q = 0; + unsigned char i; + struct ChainMapObject * cmo; + struct ChainMapObject * * z = start; + char still_at_start = 1; + for (i = 0; i < n; i++) { + if (still_at_start) { + cmo = malloc(size); + * z = cmo; + still_at_start = 0; } + else { + cmo->next = malloc(size); + cmo = cmo->next; } + cmo->pos = find_passable_pos(map); + f(cmo); } + if (!still_at_start) + cmo->next = 0; } + int main (int argc, char *argv[]) { struct World world; @@ -262,21 +276,11 @@ int main (int argc, char *argv[]) { default: exit(EXIT_FAILURE); } } - // Initialize log, player and monsters. + // Initialize log, player, monsters and items. world.log = calloc(1, sizeof(char)); update_log (&world, " "); struct Player player; world.player = &player; - struct Monster monster1; - struct Monster monster2; - struct Monster monster3; - world.monster = &monster1; - monster1.next = &monster2; - monster2.next = &monster3; - monster3.next = 0; - monster1.name = 'A'; - monster2.name = 'B'; - monster3.name = 'C'; // For interactive mode, try to load world state from savefile. FILE * file; @@ -284,17 +288,13 @@ int main (int argc, char *argv[]) { file = fopen("savefile", "r"); world.seed = read_uint32_bigendian(file); world.turn = read_uint32_bigendian(file); - player.pos.y = read_uint16_bigendian(file); - player.pos.x = read_uint16_bigendian(file); - monster1.pos.y = read_uint16_bigendian(file); - monster1.pos.x = read_uint16_bigendian(file); - monster2.pos.y = read_uint16_bigendian(file); - monster2.pos.x = read_uint16_bigendian(file); - monster3.pos.y = read_uint16_bigendian(file); - monster3.pos.x = read_uint16_bigendian(file); + player.pos.y = read_uint16_bigendian(file) - 1; + player.pos.x = read_uint16_bigendian(file) - 1; + read_map_objects (&world.monster, file, sizeof(struct Monster), read_map_objects_monsterdata); + read_map_objects (&world.item, file, sizeof(struct Item), readwrite_map_objects_dummy); fclose(file); } - // For non-interactive mode, try to load world state from frecord file. + // For non-interactive mode, try to load world state from record file. else { world.turn = 1; if (0 == world.interactive) { @@ -313,14 +313,11 @@ int main (int argc, char *argv[]) { struct Map map = init_map(); world.map = ↦ if (1 == world.turn) { - for (player.pos.y = player.pos.x = 0; 0 == is_passable(&map, player.pos.y, player.pos.x);) { - player.pos.y = rrand(0, 0) % map.height; - player.pos.x = rrand(0, 0) % map.width; } - struct Monster * monster; - for (monster = world.monster; monster != 0; monster = monster->next) - for (monster->pos.y = monster->pos.x = 0; 0 == is_passable(&map, monster->pos.y, monster->pos.x);) { - monster->pos.y = rrand(0, 0) % map.height; - monster->pos.x = rrand(0, 0) % map.width; } } + player.pos = find_passable_pos(&map); + unsigned char n_monsters = rrand(0, 0) % 16; + unsigned char n_items = rrand(0, 0) % 48; + build_map_objects (&world.monster, n_monsters, sizeof(struct Monster), build_map_objects_monsterdata, &map); + build_map_objects (&world.item, n_items, sizeof(struct Item), build_map_objects_itemdata, &map); } // Initialize window system and windows. WINDOW * screen = initscr();