plomlompom.com Git - plomrogue/blob - 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 }