4 #include <limits.h> /* PIPE_BUF */
5 #include <ncurses.h> /* halfdelay(), getch() */
6 #include <stddef.h> /* NULL */
7 #include <stdint.h> /* uint8_t, uint16_t, uint32_t */
8 #include <stdio.h> /* FILE, sprintf(), fseek(), fflush() */
9 #include <string.h> /* strcmp(), strlen(), memcpy() */
10 #include <stdlib.h> /* free(), atoi() */
11 #include <sys/stat.h> /* stat() */
12 #include <sys/types.h> /* time_t */
13 #include <time.h> /* time() */
14 #include <unistd.h> /* access() */
15 #include "../common/try_malloc.h" /* try_malloc() */
16 #include "../common/rexit.h" /* exit_trouble(), exit_err() */
17 #include "../common/readwrite.h" /* try_fopen(), try_fclose(), try_fgets(),
18 * try_fgetc(), textfile_width(), try_fputc()
20 #include "control.h" /* try_key() */
21 #include "map.h" /* map_center() */
22 #include "windows.h" /* reset_windows_on_winch(), draw_all_wins() */
23 #include "world.h" /* world global */
27 /* Read next lines of "file" up to (and excluding) a line "%\n" into the
28 * world.player_inventory string.
30 static void read_inventory(char * read_buf, uint32_t linemax, FILE * file);
32 /* Read the next characters in "file" into world.map.cells. In detail: Read
33 * world.map.size.y times world.map.size.x characters, followed by one ignored
34 * character (that we assume is a newline).
36 static void read_map_cells(FILE * file);
38 /* Repeatedly use try_fgets() with given arguments to read the remaining lines
39 * of "file" into the world.log string.
41 static void read_log(char * read_buf, uint32_t linemax, FILE * file);
43 /* Return value seen by atoi() in next line of "file" when passed to try_fgets()
44 * with the given arguments.
46 static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
49 /* If the server's worldstate file has changed since the last read_world(),
50 * return a pointer to its file descriptor; else, return NULL.
52 * Two tests are performed to check for a file change. The file's last data
53 * modification time in seconds via stat() is compared against world.last_update
54 * (and if it is changed, world.last_update is re-set to it). If this does not
55 * verify a change, the first bytes of the file are read to compare the game
56 * turn number described therein to the last read turn number in world.turn.
58 * The stat() check is mostly useless, for it only detects file updates once a
59 * second. But the turn check fails if a new world is generated from turn 1 on:
60 * the new world also starts in turn 1, not signifying any world change to the
61 * turn check. The stat() check detects this change with at most 1 second delay.
63 static FILE * changed_worldstate_file(char * path);
65 /* Attempt to read the server's worldstate file as representation of the game
66 * world in a hard-coded serialization format. Returns 1 on success and 0 if the
67 * out file wasn't read for supposedly not having changed since a last
70 * map_center() is triggered by the first successful read_world() or on turn 1,
71 * so the client focuses the map window on the player on client and world start.
73 static uint8_t read_world();
75 /* If "last_server_answer_time" is too old, send a PING to the server; or, if a
76 * previous PING has not sparked any answer after a while, abort the client.
78 static void test_ping_pong(time_t last_server_answer_time);
80 /* Update "last_server_answer_time" if new stuff has been written to the
83 static void test_server_activity(time_t * last_server_answer_time);
87 static void read_inventory(char * read_buf, uint32_t linemax, FILE * file)
89 char * f_name = "read_inventory()";
90 char * delimiter = "%\n";
91 free(world.player_inventory);
92 world.player_inventory = NULL; /* Avoids illegal strlen() below. */
95 try_fgets(read_buf, linemax + 1, file, f_name);
96 if (!(strcmp(read_buf, delimiter)))
101 if (NULL != world.player_inventory)
103 old_size = strlen(world.player_inventory);
105 int new_size = strlen(read_buf);
106 char * new_inventory = try_malloc(old_size + new_size + 1, f_name);
107 memcpy(new_inventory, world.player_inventory, old_size);
108 sprintf(new_inventory + old_size, "%s", read_buf);
109 free(world.player_inventory);
110 world.player_inventory = new_inventory;
112 world.player_inventory[strlen(world.player_inventory) - 1] = '\0';
113 world.player_inventory_select = 0;
118 static void read_map_cells(FILE * file)
120 char * f_name = "read_map_cells()";
121 free(world.map.cells);
122 world.map.cells = try_malloc(world.map.size.y * world.map.size.x, f_name);
124 for (y = 0; y < world.map.size.y; y++)
126 for (x = 0; x < world.map.size.x; x++)
128 char c = try_fgetc(file, f_name);
129 world.map.cells[(y * world.map.size.x) + x] = c;
131 try_fgetc(file, f_name);
137 static void read_log(char * read_buf, uint32_t linemax, FILE * file)
139 char * f_name = "read_log()";
142 while (try_fgets(read_buf, linemax + 1, file, f_name))
145 if (NULL != world.log)
147 old_size = strlen(world.log);
149 int new_size = strlen(read_buf);
150 char * new_log = try_malloc(old_size + new_size + 1, f_name);
151 memcpy(new_log, world.log, old_size);
152 sprintf(new_log + old_size, "%s", read_buf);
160 static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
163 char * f_name = "read_value_from_line()";
164 try_fgets(read_buf, linemax + 1, file, f_name);
165 return atoi(read_buf);
170 static FILE * changed_worldstate_file(char * path)
172 char * f_name = "changed_worldstate_file()";
173 struct stat stat_buf;
174 exit_trouble(stat(path, &stat_buf), f_name, "stat()");
175 if (stat_buf.st_mtime != world.last_update)
177 world.last_update = stat_buf.st_mtime;
178 return try_fopen(path, "r", f_name);
180 FILE * file = try_fopen(path, "r", f_name);
182 try_fgets(turn_string, 6, file, f_name);
183 if (world.turn == atoi(turn_string))
185 try_fclose(file, f_name);
188 exit_trouble(fseek(file, 0, SEEK_SET), f_name, "fseek()");
194 static uint8_t read_world()
196 char * f_name = "read_world()";
197 char * path = "server/worldstate";
198 char * quit_msg = "No worldstate file found to read. Server may be down.";
199 static uint8_t first_read = 1;
200 exit_err(access(path, F_OK), quit_msg);
201 FILE * file = changed_worldstate_file(path);
206 uint32_t linemax = textfile_width(file);
207 char * read_buf = try_malloc(linemax + 1, f_name);
208 world.turn = read_value_from_line(read_buf, linemax, file);
209 world.player_lifepoints = read_value_from_line(read_buf, linemax, file);
210 read_inventory(read_buf, linemax, file);
211 world.player_pos.y = read_value_from_line(read_buf, linemax, file);
212 world.player_pos.x = read_value_from_line(read_buf, linemax, file);
213 if (1 == world.turn || first_read)
218 world.map.size.y = read_value_from_line(read_buf, linemax, file);
219 world.map.size.x = read_value_from_line(read_buf, linemax, file);
220 read_map_cells(file);
221 read_log(read_buf, linemax, file);
223 try_fclose(file, f_name);
229 static void test_ping_pong(time_t last_server_answer_time)
231 static uint8_t ping_sent = 0;
232 time_t now = time(0);
233 if (ping_sent && last_server_answer_time > now - 3)
237 if (!ping_sent && last_server_answer_time < now - 3)
243 exit_err(last_server_answer_time < now - 6, "Server not answering.");
248 static void test_server_activity(time_t * last_server_answer_time)
250 char * f_name = "test_server_activity()";
251 int test = try_fgetc(world.file_server_out, f_name);
260 while (EOF != (test = try_fgetc(world.file_server_out, f_name)));
261 * last_server_answer_time = time(0);
266 extern void send(char * msg)
268 char * f_name = "send()";
269 uint32_t msg_size = strlen(msg) + 1;
270 char * err = "send() tries to send message larger than PIPE_BUF bytes.";
271 exit_err(msg_size > PIPE_BUF, err);
272 try_fwrite(msg, strlen(msg), 1, world.file_server_in, f_name);
273 try_fputc('\n', world.file_server_in, f_name);
274 fflush(world.file_server_in);
279 extern char * io_loop()
281 world.halfdelay = 1; /* Ensures read_world() is only called 10 */
282 halfdelay(world.halfdelay); /* times a second during user inactivity. */
283 uint8_t change_in_client = 0;
284 time_t last_server_answer_time = time(0);
287 test_server_activity(&last_server_answer_time);
288 test_ping_pong(last_server_answer_time);
291 reset_windows_on_winch();
295 if (read_world() || change_in_client)
299 change_in_client = 0;
303 change_in_client = try_key((uint16_t) key);
304 if (2 == change_in_client)
311 return "Sent QUIT to server.";