/* src/client/io.c */
+#define _POSIX_C_SOURCE 1 /* PIPE_BUF */
#include "io.h"
#include <limits.h> /* PIPE_BUF */
#include <ncurses.h> /* halfdelay(), getch() */
*/
#include "control.h" /* try_key() */
#include "map.h" /* map_center() */
-#include "misc.h" /* reset_windows() */
#include "windows.h" /* reset_windows_on_winch(), draw_all_wins() */
#include "world.h" /* world global */
*/
static void read_inventory(char * read_buf, uint32_t linemax, FILE * file);
-/* Read the next characters in "file" into world.map.cells. In detail: Read
- * world.map.size.y times world.map.size.x characters, followed by one ignored
+/* Read the next characters in "file" into "map". In detail: Read
+ * world.map.length times world.map.length characters, followed by one ignored
* character (that we assume is a newline).
*/
-static void read_map_cells(FILE * file);
+static void read_map_cells(FILE * file, char ** map);
/* Repeatedly use try_fgets() with given arguments to read the remaining lines
* of "file" into the world.log string.
* out file wasn't read for supposedly not having changed since a last
* read_world() call.
*
- * map_center() is triggered by the first successful read_world() or on turn 1,
- * so the client focuses the map window on the player on client and world start.
+ * map_center() is triggered by either, the first successful read_world() (thus
+ * on client start), or on turn 1 (thus on world start).
*/
static uint8_t read_world();
static void read_inventory(char * read_buf, uint32_t linemax, FILE * file)
{
- char * f_name = "read_inventory()";
char * delimiter = "%\n";
free(world.player_inventory);
world.player_inventory = NULL; /* Avoids illegal strlen() below. */
while (1)
{
- try_fgets(read_buf, linemax + 1, file, f_name);
+ try_fgets(read_buf, linemax + 1, file, __func__);
if (!(strcmp(read_buf, delimiter)))
{
break;
old_size = strlen(world.player_inventory);
}
int new_size = strlen(read_buf);
- char * new_inventory = try_malloc(old_size + new_size + 1, f_name);
+ char * new_inventory = try_malloc(old_size + new_size + 1, __func__);
memcpy(new_inventory, world.player_inventory, old_size);
- sprintf(new_inventory + old_size, "%s", read_buf);
+ int test = sprintf(new_inventory + old_size, "%s", read_buf);
+ exit_trouble(test < 0, __func__, "sprintf");
free(world.player_inventory);
world.player_inventory = new_inventory;
}
-static void read_map_cells(FILE * file)
+static void read_map_cells(FILE * file, char ** map)
{
- char * f_name = "read_map_cells()";
- free(world.map.cells);
- world.map.cells = try_malloc(world.map.size.y * world.map.size.x, f_name);
+ if (*map)
+ {
+ free(*map);
+ *map = NULL;
+ }
+ *map = try_malloc(world.map.length * world.map.length, __func__);
+ char * map_cells = *map;
uint16_t y, x;
- for (y = 0; y < world.map.size.y; y++)
+ for (y = 0; y < world.map.length; y++)
{
- for (x = 0; x < world.map.size.x; x++)
+ for (x = 0; x < world.map.length; x++)
{
- char c = try_fgetc(file, f_name);
- world.map.cells[(y * world.map.size.x) + x] = c;
+ char c = try_fgetc(file, __func__);
+ map_cells[y * world.map.length + x] = c;
}
- try_fgetc(file, f_name);
+ try_fgetc(file, __func__);
}
}
static void read_log(char * read_buf, uint32_t linemax, FILE * file)
{
- char * f_name = "read_log()";
free(world.log);
world.log = NULL;
- while (try_fgets(read_buf, linemax + 1, file, f_name))
+ while (try_fgets(read_buf, linemax + 1, file, __func__))
{
int old_size = 0;
if (NULL != world.log)
old_size = strlen(world.log);
}
int new_size = strlen(read_buf);
- char * new_log = try_malloc(old_size + new_size + 1, f_name);
+ char * new_log = try_malloc(old_size + new_size + 1, __func__);
memcpy(new_log, world.log, old_size);
- sprintf(new_log + old_size, "%s", read_buf);
+ int test = sprintf(new_log + old_size, "%s", read_buf);
+ exit_trouble(test < 0, __func__, "sprintf");
free(world.log);
world.log = new_log;
}
static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
FILE * file)
{
- char * f_name = "read_value_from_line()";
- try_fgets(read_buf, linemax + 1, file, f_name);
+ try_fgets(read_buf, linemax + 1, file, __func__);
return atoi(read_buf);
}
static FILE * changed_worldstate_file(char * path)
{
- char * f_name = "changed_worldstate_file()";
struct stat stat_buf;
- exit_trouble(stat(path, &stat_buf), f_name, "stat()");
+ exit_trouble(stat(path, &stat_buf), __func__, "stat");
if (stat_buf.st_mtime != world.last_update)
{
world.last_update = stat_buf.st_mtime;
- return try_fopen(path, "r", f_name);
+ return try_fopen(path, "r", __func__);
}
- FILE * file = try_fopen(path, "r", f_name);
+ FILE * file = try_fopen(path, "r", __func__);
char turn_string[6];
- try_fgets(turn_string, 6, file, f_name);
+ try_fgets(turn_string, 6, file, __func__);
if (world.turn == atoi(turn_string))
{
- try_fclose(file, f_name);
+ try_fclose(file, __func__);
return NULL;
}
- exit_trouble(fseek(file, 0, SEEK_SET), f_name, "fseek()");
+ exit_trouble(fseek(file, 0, SEEK_SET), __func__, "fseek");
return file;
}
static uint8_t read_world()
{
- char * f_name = "read_world()";
char * path = "server/worldstate";
char * quit_msg = "No worldstate file found to read. Server may be down.";
static uint8_t first_read = 1;
return 0;
}
uint32_t linemax = textfile_width(file);
- char * read_buf = try_malloc(linemax + 1, f_name);
+ char * read_buf = try_malloc(linemax + 1, __func__);
world.turn = read_value_from_line(read_buf, linemax, file);
world.player_lifepoints = read_value_from_line(read_buf, linemax, file);
read_inventory(read_buf, linemax, file);
map_center();
first_read = 0;
}
- world.map.size.y = read_value_from_line(read_buf, linemax, file);
- world.map.size.x = read_value_from_line(read_buf, linemax, file);
- read_map_cells(file);
+ world.map.length = read_value_from_line(read_buf, linemax, file);
+ read_map_cells(file, &world.map.cells);
+ read_map_cells(file, &world.mem_map);
read_log(read_buf, linemax, file);
free(read_buf);
- try_fclose(file, f_name);
+ try_fclose(file, __func__);
return 1;
}
static void test_server_activity(time_t * last_server_answer_time)
{
- char * f_name = "test_server_activity()";
- int test = try_fgetc(world.file_server_out, f_name);
+ int test = try_fgetc(world.file_server_out, __func__);
if (EOF == test)
{
return;
{
;
}
- while (EOF != (test = try_fgetc(world.file_server_out, f_name)));
+ while (EOF != (test = try_fgetc(world.file_server_out, __func__)));
* last_server_answer_time = time(0);
}
extern void send(char * msg)
{
- char * f_name = "send()";
uint32_t msg_size = strlen(msg) + 1;
char * err = "send() tries to send message larger than PIPE_BUF bytes.";
exit_err(msg_size > PIPE_BUF, err);
- try_fwrite(msg, strlen(msg), 1, world.file_server_in, f_name);
- try_fputc('\n', world.file_server_in, f_name);
+ try_fwrite(msg, strlen(msg), 1, world.file_server_in, __func__);
+ try_fputc('\n', world.file_server_in, __func__);
fflush(world.file_server_in);
}
world.halfdelay = 1; /* Ensures read_world() is only called 10 */
halfdelay(world.halfdelay); /* times a second during user inactivity. */
uint8_t change_in_client = 0;
+ uint16_t last_focused_turn = world.turn;
time_t last_server_answer_time = time(0);
while (1)
{
world.winch = 0;
change_in_client++;
}
- if (read_world() || change_in_client)
+ if (change_in_client || read_world())
{
+ if (world.turn != last_focused_turn && world.focus_each_turn)
+ {
+ last_focused_turn = world.turn;
+ map_center();
+ }
draw_all_wins();
}
change_in_client = 0;
projects / plomrogue / blobdiff