plomlompom.com Git - plomrogue/blob - src/misc.c

   1 /* misc.c */
   2
   3 #include "misc.h"
   4 #include <errno.h> /* for errno */
   5 #include <unistd.h> /* for unlink(), acess() */
   6 #include <stdlib.h> /* for size_t, calloc(), free() */
   7 #include <string.h> /* for strlen(), strcmp(), memcpy() */
   8 #include <stdint.h> /* for uint8_t, uint16_t */
   9 #include "readwrite.h" /* for [read/write]_uint[8/16/32][_bigendian](),
  10                         * try_fopen(), try_fclose()
  11                         */
  12 #include "map_objects.h" /* for struct Monster, write_map_objects(), */
  13 #include "map_object_actions.h" /* for is_passable(), move_monster() */
  14 #include "map.h" /* for Map struct */
  15 #include "main.h" /* for World struct */
  16 #include "yx_uint16.h" /* for yx_uint16 struct */
  17 #include "rrand.h" /* for rrand(), rrand_seed() */
  18 #include "rexit.h" /* for exit_err() */
  19
  20
  21
  22 extern char * trouble_msg(struct World * w, char * parent, char * child)
  23 {
  24     char * p1 = "Trouble in ";
  25     char * p2 = " with ";
  26     char * p3 = ".";
  27     uint16_t size = strlen(p1) + strlen(parent) + strlen(p2) + strlen(child)
  28                     + strlen(p3) + 1;
  29     char * msg = malloc(size);
  30     exit_err(NULL == msg, w, "malloc() in trouble_msg() failed.");
  31     sprintf(msg, "%s%s%s%s%s", p1, parent, p2, child, p3);
  32     return msg;
  33 }
  34
  35
  36
  37 extern void * try_malloc(size_t size, struct World * w, char * f)
  38 {
  39     char * msg = trouble_msg(w, f, "malloc()");
  40     void * p = malloc(size);
  41     exit_err(NULL == p, w, msg);
  42     free(msg);
  43     return p;
  44 }
  45
  46
  47
  48 extern void * try_calloc(size_t size1, size_t size2, struct World * w, char * f)
  49 {
  50     char * msg = trouble_msg(w, f, "calloc()");
  51     void * p = calloc(size1, size2);
  52     exit_err(NULL == p, w, msg);
  53     free(msg);
  54     return p;
  55 }
  56
  57
  58
  59 extern void check_files_xor(char * p1, char * p2, struct World * w)
  60 {
  61     char * msg1 = "A file '";
  62     char * msg2 = "' exists, but no file '";
  63     char * msg3 = "'. If everything was in order, both or noe would exist. "
  64                   "The game won't start until this is corrected.";
  65     uint16_t size = strlen(msg1) + strlen(p1) + strlen(msg2) + strlen(p2)
  66                     + strlen(msg3);
  67     char msg[size];
  68     if      (!access(p1, F_OK) && access(p2, F_OK))
  69     {
  70         sprintf(msg, "%s%s%s%s%s", msg1, p1, msg2, p2, msg3);
  71         errno = 0;
  72         exit_err(1, w, msg);
  73     }
  74     else if (access(p1, F_OK) && !access(p2, F_OK))
  75     {
  76         sprintf(msg, "%s%s%s%s%s", msg1, p2, msg2, p1, msg3);
  77         errno = 0;
  78         exit_err(1, w, msg);
  79     }
  80 }
  81
  82
  83
  84 extern void check_tempfile(char * path, struct World * w)
  85 {
  86     char * msg1 = "A file '";
  87     char * msg2 = "' exists, probably from a corrupted previous file saving "
  88                 "process. To avoid corruption of game files, the game won't  "
  89                 "start until it is removed or renamed.";
  90     uint16_t size = strlen(msg1) + strlen(path) + strlen(msg2);
  91     char msg[size];
  92     sprintf(msg, "%s%s%s", msg1, path, msg2);
  93     exit_err(!access(path, F_OK), w, msg);
  94 }
  95
  96
  97
  98 extern void update_log(struct World * world, char * text)
  99 {
 100     char * f_name = "update_log()";
 101     static char * last_msg;                 /* TODO: valgrind is dissatisfied */
 102     if (0 == last_msg)                      /* with this calloc'd pointer not */
 103     {                                       /* being freed. Rectify this?     */
 104         last_msg = try_calloc(1, sizeof(char), world, f_name);
 105     }
 106     char * new_text;
 107     uint16_t len_old = strlen(world->log);
 108     if (0 == strcmp(last_msg, text))
 109     {
 110         uint16_t len_whole = len_old + 1;
 111         new_text = try_calloc(len_whole + 1, sizeof(char), world, f_name);
 112         memcpy(new_text, world->log, len_old);
 113         memcpy(new_text + len_old, ".", 1);
 114     }
 115     else
 116     {
 117         uint16_t len_new = strlen(text);
 118         uint16_t len_whole = len_old + len_new + 1;
 119         new_text = try_calloc(len_whole, sizeof(char), world, f_name);
 120         memcpy(new_text, world->log, len_old);
 121         memcpy(new_text + len_old, text, len_new);
 122         last_msg = try_calloc(len_new + 1, sizeof(char), world, f_name);
 123         memcpy(last_msg, text, len_new);
 124     }
 125     free(world->log);
 126     world->log = new_text;
 127 }
 128
 129
 130
 131 extern uint16_t center_offset(uint16_t pos, uint16_t mapsize,
 132                               uint16_t framesize)
 133 {
 134     uint16_t offset = 0;
 135     if (mapsize > framesize)
 136     {
 137         if (pos > framesize / 2)
 138         {
 139             if (pos < mapsize - (framesize / 2))
 140             {
 141                 offset = pos - (framesize / 2);
 142             }
 143             else
 144             {
 145                 offset = mapsize - framesize;
 146             }
 147         }
 148     }
 149     return offset;
 150 }
 151
 152
 153
 154 extern void turn_over(struct World * world, char action)
 155 {
 156     char * f_name = "turn_over()";
 157     char * err_write = "Trouble in turn_over() with write_uint8() "
 158                        "writing to opened file 'record_tmp'.";
 159
 160     char * recordfile_tmp = "record_tmp";
 161     char * recordfile     = "record";
 162     if (1 == world->interactive)
 163     {
 164         FILE * file_old = try_fopen(recordfile,     "r", world, f_name);
 165         FILE * file_new = try_fopen(recordfile_tmp, "w", world, f_name);
 166         char c = fgetc(file_old);
 167         while (EOF != c)
 168         {
 169             exit_err(write_uint8(c, file_new), world, err_write);
 170             c = fgetc(file_old);
 171         }
 172         try_fclose(file_old, world, f_name);
 173         exit_err(write_uint8(action, file_new), world, err_write);
 174         try_fclose_unlink_rename(file_new, recordfile_tmp, recordfile,
 175                                  world, f_name);
 176     }
 177     world->turn++;
 178     rrand_seed(world->seed * world->turn);
 179     struct Monster * monster;
 180     for (monster = world->monster;
 181          monster != 0;
 182          monster = monster->map_obj.next)
 183     {
 184         move_monster(world, monster);
 185     }
 186 }
 187
 188
 189
 190 extern void save_game(struct World * world)
 191 {
 192     char * f_name = "save_game()";
 193     char * err_write = "Trouble in save_game() "
 194                        "writing to opened file 'savefile_tmp'.";
 195
 196     char * savefile_tmp = "savefile_tmp";
 197     char * savefile     = "savefile";
 198     FILE * file = try_fopen(savefile_tmp, "w", world, f_name);
 199     if (   write_uint32_bigendian(world->seed, file)
 200         || write_uint32_bigendian(world->turn, file)
 201         || write_uint16_bigendian(world->score, file)
 202         || write_uint16_bigendian(world->player->pos.y + 1, file)
 203         || write_uint16_bigendian(world->player->pos.x + 1, file)
 204         || write_uint8(world->player->hitpoints, file)
 205         || write_map_objects(world, world->monster, file)
 206         || write_map_objects(world, world->item, file))
 207     {
 208         exit_err(1, world, err_write);
 209     }
 210     try_fclose_unlink_rename(file, savefile_tmp, savefile, world, f_name);
 211 }
 212
 213
 214
 215 extern struct yx_uint16 find_passable_pos(struct Map * map)
 216 {
 217     struct yx_uint16 pos;
 218     for (pos.y = pos.x = 0; 0 == is_passable(map, pos);)
 219     {
 220         pos.y = rrand() % map->size.y;
 221         pos.x = rrand() % map->size.x;
 222     }
 223     return pos;
 224 }