Added diagonal movement, with a 1.4 penalty.

[plomrogue] / src / server / run.c

diff --git a/src/server/run.c b/src/server/run.c
index 540f025cc7c1eb7792be1c35c3bd0bffe8189f67..83bb724cb67cabbabdb1dfbff2615fc592a22dae 100644 (file)
--- a/src/server/run.c
+++ b/src/server/run.c
@@ -12,7 +12,7 @@
                                   * textfile_sizes(), try_fputc()
                                   */
 #include "../common/rexit.h" /* exit_trouble() */
-#include "ai.h" /* pretty_dumb_ai() */
+#include "ai.h" /* ai() */
 #include "init.h" /* remake_world() */
 #include "io.h" /* io_round() */
 #include "map_object_actions.h" /* get_moa_id_by_name() */
@@ -26,6 +26,17 @@
  */
 static void turn_over();
 
+/* Helper to turn_over() to determine whether a map object's action effort has
+ * reached its end. The simplicity of just comparing map_object->progress to
+ * moa->effort is suspended for actor movement, for in this case the effort
+ * depends on the diagonal movement penalty expressed in the ratio of
+ * world.map.dist_diagonal / world.map.dist_orthogonal. (Movement being diagonal
+ * or orthogonal is determined by the ->arg char encoding an even or un-even
+ * number digit).
+ */
+static uint8_t is_effort_finished(struct MapObjAct * moa,
+                                  struct MapObj * map_object);
+
 /* If "msg"'s first part matches "command_name", set player's MapObj's .command
  * to the command's id and its .arg to a numerical value following in the latter
  * part of "msg" (if no digits are found, use 0); then finish player's turn and
@@ -40,7 +51,6 @@ static void turn_over()
     struct MapObj * player = get_player();
     struct MapObj * map_object = player;
     uint16_t start_turn = world.turn;
-    uint8_t first_round = 1;
     while (    0 < player->lifepoints
            || (0 == player->lifepoints && start_turn == world.turn))
     {
@@ -51,24 +61,24 @@ static void turn_over()
         }
         if (0 < map_object->lifepoints)
         {
-            if (0 == first_round && 0 == map_object->progress)
+            if (0 == map_object->command)
             {
                 if (map_object == player)
                 {
                     break;
                 }
-                pretty_dumb_ai(map_object);
+                ai(map_object);
             }
-            first_round = 0;
             map_object->progress++;
             struct MapObjAct * moa = world.map_obj_acts;
             while (moa->id != map_object->command)
             {
                 moa = moa->next;
             }
-            if (map_object->progress == moa->effort)
+            if (is_effort_finished(moa, map_object))
             {
                 moa->func(map_object);
+                map_object->command = 0;
                 map_object->progress = 0;
             }
         }
@@ -78,6 +88,37 @@ static void turn_over()
 
 
 
+static uint8_t is_effort_finished(struct MapObjAct * moa,
+                                  struct MapObj * map_object)
+{
+    if (moa->func != actor_move)
+    {
+        if (map_object->progress == moa->effort)
+        {
+            return 1;
+        }
+    }
+    else if (strchr("8624", map_object->arg))
+    {
+        if (map_object->progress == moa->effort)
+        {
+            return 1;
+        }
+    }
+    else if (strchr("1379", map_object->arg))
+    {
+        uint16_t diagonal_effort =   (moa->effort * world.map.dist_diagonal)
+                                   / world.map.dist_orthogonal;
+        if (map_object->progress == diagonal_effort)
+        {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+
+
 static uint8_t apply_player_command(char * msg, char * command_name)
 {
     if (!strncmp(msg, command_name, strlen(command_name)))