home · contact · privacy
Re-wrote large parts of the server client architecture. No more fifo.
[plomrogue] / src / server / run.c
1 /* src/server/run.c */
2
3 #include "run.h"
4 #include <stddef.h> /* NULL */
5 #include <stdint.h> /* uint8_t, uint16_t, uint32_t */
6 #include <stdio.h> /* FILE, sprintf(), fflush() */
7 #include <stdlib.h> /* free() */
8 #include <string.h> /* strlen(), strcmp() strncmp(), atoi() */
9 #include <unistd.h> /* access() */
10 #include "../common/readwrite.h" /* try_fopen(), try_fcose(), try_fwrite(),
11                                   * try_fgets(), try_fclose_unlink_rename(),
12                                   * textfile_width(), try_fputc()
13                                   */
14 #include "../common/rexit.h" /* exit_trouble(), exit_err() */
15 #include "ai.h" /* ai() */
16 #include "cleanup.h" /* unset_cleanup_flag() */
17 #include "init.h" /* remake_world() */
18 #include "io.h" /* io_round() */
19 #include "map_object_actions.h" /* get_moa_id_by_name() */
20 #include "map_objects.h" /* struct MapObj, get_player() */
21 #include "world.h" /* global world */
22
23
24
25 /* Run the game world and its inhabitants (and their actions) until the player
26  * avatar is free to receive new commands (or is dead).
27  */
28 static void turn_over();
29
30 /* Helper to turn_over() to determine whether a map object's action effort has
31  * reached its end. The simplicity of just comparing map_object->progress to
32  * moa->effort is suspended for actor movement, for in this case the effort
33  * depends on the diagonal movement penalty expressed in the ratio of
34  * world.map.dist_diagonal / world.map.dist_orthogonal. (Movement being diagonal
35  * or orthogonal is determined by the ->arg char encoding an even or un-even
36  * number digit).
37  */
38 static uint8_t is_effort_finished(struct MapObjAct * moa,
39                                   struct MapObj * map_object);
40
41 /* If "msg"'s first part matches "command_name", set player's MapObj's .command
42  * to the command's id and its .arg to a numerical value following in the latter
43  * part of "msg" (if no digits are found, use 0); then finish player's turn and
44  * turn game over to the NPCs via turn_over(); then return 1. Else, return 0.
45  */
46 static uint8_t apply_player_command(char * msg, char * command_name);
47
48 /* Compares first line of file at world.path_out to world.server_test, aborts if
49  * they don't match, but not before unsetting the flags deleting files in the
50  * server directory, for in that case those must be assumed to belong to another
51  * server process.
52  */
53 static void server_test();
54
55
56
57 static void turn_over()
58 {
59     struct MapObj * player = get_player();
60     struct MapObj * map_object = player;
61     uint16_t start_turn = world.turn;
62     while (    0 < player->lifepoints
63            || (0 == player->lifepoints && start_turn == world.turn))
64     {
65         if (NULL == map_object)
66         {
67             world.turn++;
68             map_object = world.map_objs;
69         }
70         if (0 < map_object->lifepoints)
71         {
72             if (0 == map_object->command)
73             {
74                 if (map_object == player)
75                 {
76                     break;
77                 }
78                 ai(map_object);
79             }
80             map_object->progress++;
81             struct MapObjAct * moa = world.map_obj_acts;
82             while (moa->id != map_object->command)
83             {
84                 moa = moa->next;
85             }
86             if (is_effort_finished(moa, map_object))
87             {
88                 moa->func(map_object);
89                 map_object->command = 0;
90                 map_object->progress = 0;
91             }
92         }
93         map_object = map_object->next;
94     }
95 }
96
97
98
99 static uint8_t is_effort_finished(struct MapObjAct * moa,
100                                   struct MapObj * map_object)
101 {
102     if (moa->func != actor_move)
103     {
104         if (map_object->progress == moa->effort)
105         {
106             return 1;
107         }
108     }
109     else if (strchr("8624", map_object->arg))
110     {
111         if (map_object->progress == moa->effort)
112         {
113             return 1;
114         }
115     }
116     else if (strchr("1379", map_object->arg))
117     {
118         uint16_t diagonal_effort =   (moa->effort * world.map.dist_diagonal)
119                                    / world.map.dist_orthogonal;
120         if (map_object->progress == diagonal_effort)
121         {
122             return 1;
123         }
124     }
125     return 0;
126 }
127
128
129
130 static uint8_t apply_player_command(char * msg, char * command_name)
131 {
132     if (!strncmp(msg, command_name, strlen(command_name)))
133     {
134         struct MapObj * player = get_player();
135         player->arg = atoi(&(msg[strlen(command_name)]));
136         player->command = get_moa_id_by_name(command_name);
137         turn_over();
138         return 1;
139     }
140     return 0;
141 }
142
143
144
145 static void server_test()
146 {
147     char * f_name = "server_test()";
148     char test[10 + 1 + 10 + 1 + 1];
149     FILE * file = try_fopen(world.path_out, "r", f_name);
150     try_fgets(test, 10 + 10 + 1 + 1, file, f_name);
151     try_fclose(file, f_name);
152     if (strcmp(test, world.server_test))
153     {
154         unset_cleanup_flag(CLEANUP_WORLDSTATE);
155         unset_cleanup_flag(CLEANUP_OUT);
156         unset_cleanup_flag(CLEANUP_IN);
157         char * msg = "Server test string in server output file does not match. "
158                      "This indicates that the current server process has been "
159                      "superseded by another one.";
160         exit_err(1, msg);
161     }
162 }
163
164
165
166 extern void obey_msg(char * msg, uint8_t do_record)
167 {
168     char * f_name = "obey_msg()";
169     if (   apply_player_command(msg, "wait")   /* TODO: Check for non-error   */
170         || apply_player_command(msg, "move")   /* return value of a modified  */
171         || apply_player_command(msg, "pick_up")/* get_moa_id_by_name(); if id */
172         || apply_player_command(msg, "drop")   /* found, execute on it what's */
173         || apply_player_command(msg, "use"));  /* in apply_player_command().  */
174     else
175     {
176         char * seed_command = "seed";
177         if (!strncmp(msg, seed_command, strlen(seed_command)))
178         {
179             remake_world(atoi(&(msg[strlen(seed_command)])));
180         }
181     }
182     if (do_record)
183     {
184         char path_tmp[strlen(world.path_record) + strlen(world.tmp_suffix) + 1];
185         sprintf(path_tmp, "%s%s", world.path_record, world.tmp_suffix);
186         FILE * file_tmp  = try_fopen(path_tmp, "w", f_name);
187         if (!access(world.path_record, F_OK))
188         {
189             FILE * file_read = try_fopen(world.path_record, "r", f_name);
190             uint32_t linemax = textfile_width(file_read);
191             char line[linemax + 1];
192             while (try_fgets(line, linemax + 1, file_read, f_name))
193             {
194                 try_fwrite(line, strlen(line), 1, file_tmp, f_name);
195             }
196             try_fclose(file_read, f_name);
197         }
198         try_fwrite(msg, strlen(msg), 1, file_tmp, f_name);
199         try_fputc('\n', file_tmp, f_name);
200         try_fclose_unlink_rename(file_tmp, path_tmp, world.path_record, f_name);
201     }
202 }
203
204
205
206 extern uint8_t io_loop()
207 {
208     char * f_name = "io_loop()";
209     while (1)
210     {
211         server_test();
212         char * msg = io_round();
213         if (NULL == msg)
214         {
215             continue;
216         }
217         if (world.is_verbose)
218         {
219             exit_trouble(-1 == printf("Input: %s\n", msg), f_name, "printf()");
220         }
221         if (!strcmp("QUIT", msg))
222         {
223             free(msg);
224             return 1;
225         }
226         if (!strcmp("PING", msg))
227         {
228             free(msg);
229             char * pong = "PONG\n";
230             try_fwrite(pong, strlen(pong), 1, world.file_out, f_name);
231             fflush(world.file_out);
232             continue;
233         }
234         if (world.replay)
235         {
236             free(msg);
237             return 0;
238         }
239         obey_msg(msg, 1);
240         free(msg);
241     }
242 }