From 7417749aa85958f1ca0370c46f84a904b3ea2089 Mon Sep 17 00:00:00 2001
From: kittel <tkpub_ahnfyc@doki.dk>
Date: Sun, 9 Oct 2011 15:34:56 +0200
Subject: [PATCH] running follows corridors

---
 crawl-ref/source/delay.cc  |    2 +
 crawl-ref/source/externs.h |   11 ++-
 crawl-ref/source/travel.cc |  181 ++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 176 insertions(+), 18 deletions(-)

diff --git a/crawl-ref/source/delay.cc b/crawl-ref/source/delay.cc
index ac7233d..ec02b36 100644
--- a/crawl-ref/source/delay.cc
+++ b/crawl-ref/source/delay.cc
@@ -1352,6 +1352,8 @@ static void _armour_wear_effects(const int item_slot)
 
 static command_type _get_running_command()
 {
+    you.running.possibly_update_direction();
+
     if (Options.travel_key_stop && kbhit()
         || !in_bounds(you.pos() + you.running.pos))
     {
diff --git a/crawl-ref/source/externs.h b/crawl-ref/source/externs.h
index 3edc05e..fad3af7 100644
--- a/crawl-ref/source/externs.h
+++ b/crawl-ref/source/externs.h
@@ -639,9 +639,16 @@ public:
     // Returns true if you were running and are now no longer running.
     bool check_stop_running();
 
+    //Call to give the runrest object a chance to change its direction, so we
+    //can follow corridors around corners when shift-running:
+    void possibly_update_direction();
+
 private:
-    void set_run_check(int index, int compass_dir);
-    bool run_should_stop() const;
+    void _set_run_check(int index, int compass_dir);
+
+    //Returns 0 if should not stop, 2 if stopped by feature change and 1
+    //if stopped for another reason:
+    int _run_should_stop() const;
 };
 
 typedef std::vector<delay_queue_item> delay_queue_type;
diff --git a/crawl-ref/source/travel.cc b/crawl-ref/source/travel.cc
index 24b953f..8929193 100644
--- a/crawl-ref/source/travel.cc
+++ b/crawl-ref/source/travel.cc
@@ -3972,13 +3972,13 @@ void runrest::initialise(int dir, int mode)
         runmode = mode;
 
         // Get the compass point to the left/right of intended travel:
-        const int left  = (dir - 1 < 0) ? 7 : (dir - 1);
-        const int right = (dir + 1 > 7) ? 0 : (dir + 1);
+        const int left  = (dir + 7) % 8;
+        const int right = (dir + 1) % 8;
 
         // Record the direction and starting tile type for later reference:
-        set_run_check(0, left);
-        set_run_check(1, dir);
-        set_run_check(2, right);
+        _set_run_check(0, left);
+        _set_run_check(1, dir);
+        _set_run_check(2, right);
     }
 
     if (runmode == RMODE_REST_DURATION)
@@ -3998,6 +3998,8 @@ const runrest &runrest::operator = (int newrunmode)
     return (*this);
 }
 
+// This function creates "equivalence classes" so that changes
+// in wall and floor type aren't running stopping points.
 static dungeon_feature_type _base_feat_type(dungeon_feature_type grid)
 {
     if (grid >= DNGN_FLOOR_MIN && grid <= DNGN_FLOOR_MAX)
@@ -4010,7 +4012,7 @@ static dungeon_feature_type _base_feat_type(dungeon_feature_type grid)
     return (grid);
 }
 
-void runrest::set_run_check(int index, int dir)
+void runrest::_set_run_check(int index, int dir)
 {
     run_check[index].delta = Compass[dir];
 
@@ -4020,7 +4022,7 @@ void runrest::set_run_check(int index, int dir)
 
 bool runrest::check_stop_running()
 {
-    if (runmode > 0 && runmode != RMODE_START && run_should_stop())
+    if (runmode > 0 && runmode != RMODE_START && _run_should_stop())
     {
         stop();
         return (true);
@@ -4028,15 +4030,162 @@ bool runrest::check_stop_running()
     return (false);
 }
 
-// This function creates "equivalence classes" so that changes
-// in wall and floor type aren't running stopping points.
-bool runrest::run_should_stop() const
+static int _delta_to_direction(const coord_def& delta)
+{
+    for (unsigned i = 0; i < 8; ++i)
+    {
+        if (Compass[i] == delta)
+            return i;
+    }
+    return -1;
+}
+
+static dungeon_feature_type _delta_to_feat(const coord_def& delta)
+{
+    return _base_feat_type(env.map_knowledge(you.pos()+delta).feat());
+}
+
+void runrest::possibly_update_direction()
+{
+    if (runmode != RMODE_CONTINUE || _run_should_stop() != 2)
+        return;
+
+    //The following are Situations in which we should adjust the course by a
+    //clock-wise turn (the player is moving north in the pictures below, and
+    //mirror-images are of course valid):
+    //
+    //  ###       ###
+    //  #..  ##.  #@.
+    //  #@#  #@#  #.#
+    //
+    //  (A)  (B)  (C)
+    //
+    //Unlike B+C, A is only applicable for non-diagonal moves (dir1%2==0). C
+    //needs a 90 degree turn, A+B needs a 45 degree turn. C of course only
+    //happens when the player just initiated the shift-run one step ago (when
+    //standing one square south of the "@")
+    //
+    // And finally a diagonal-only case. In this orientation the player is going
+    // south-west and we should change it to north-west:
+    //
+    // #.#
+    // #.@
+    // ###
+    //
+    // (D)
+    //
+    //Note that just covering scenarios ABCD represents a slightly conservative
+    //approach, and one might argue to include more cases such as running past a
+    //1-square crevice. However it is probably better to not be overly aggresive
+    //since for instance a player might want to search said crevice for a secret
+    //door. Too aggresive and people might shy away from shift-running {kittel}
+
+    int dir0 = _delta_to_direction(run_check[0].delta);
+    int dir1 = _delta_to_direction(run_check[1].delta);
+    int dir2 = _delta_to_direction(run_check[2].delta);
+
+    if (dir0 < 0 || dir1 < 0 || dir2 < 0
+        || (8 + dir1 - dir0) % 8 != 1
+        || (8 + dir2 - dir1) % 8 != 1 )
+    {
+        //Better to have a few sanity checks than obscure bugs later...
+        mpr("Running direction change aborted due to mysterious deltas.");
+        return;
+    }
+
+    int dir_left  = (dir0 + 7) % 8;
+    int dir_right = (dir2 + 1) % 8;
+    bool diagonal = dir1 % 2 != 0;
+
+    //Wall feature (we could consider a bit of logic here to allow auto-turning
+    //when surrounded by something else than walls, like lava and deep
+    //water. This would for instance allow shift-running to follow a turning
+    //bridge, but I am not 100% sure this is both a desired feature and worth
+    //the extra complication):
+    dungeon_feature_type wall = DNGN_ROCK_WALL;
+
+    //Finally, extract and examine features and start a new run if applicable.
+    dungeon_feature_type feat_left  = _delta_to_feat(Compass[dir_left]);
+    dungeon_feature_type feat_right = _delta_to_feat(Compass[dir_right]);
+    dungeon_feature_type feat0      = _delta_to_feat(Compass[dir0]);
+    dungeon_feature_type feat1      = _delta_to_feat(Compass[dir1]);
+    dungeon_feature_type feat2      = _delta_to_feat(Compass[dir2]);
+
+    int new_dir = -1;
+
+    if ( feat_left == wall && feat_right == wall )
+    {
+        if (feat1 == wall)
+        {
+            if (feat0 == wall && feat2 == DNGN_FLOOR)
+                new_dir = dir2;//(B) with right turn
+            else  if (feat0 == DNGN_FLOOR && feat2 == wall)
+                new_dir = dir0;//(B) with left turn
+        }
+        else if (!diagonal && feat1 == DNGN_FLOOR)
+        {
+            if (_delta_to_feat(Compass[dir1] + Compass[dir0]) == wall
+                && _delta_to_feat(Compass[dir1] + Compass[dir1]) == wall
+                && _delta_to_feat(Compass[dir1] + Compass[dir2]) == wall)
+            {
+                if (feat0 == wall && feat2 == DNGN_FLOOR)
+                    new_dir = dir2;//(A) with right turn
+                else if (feat0 == DNGN_FLOOR && feat2 == wall)
+                    new_dir = dir0;//(A) with left turn
+            }
+        }
+    }
+
+    if ( new_dir == -1 && feat0 == wall && feat1 == wall && feat2 == wall )
+    {
+        if (_delta_to_feat(Compass[(dir_right + 1) % 8]) == wall
+            && _delta_to_feat(Compass[(dir_right + 2) % 8]) == DNGN_FLOOR
+            && _delta_to_feat(Compass[(dir_right + 3) % 8]) == wall)
+        {
+            if (feat_left == wall && feat_right == DNGN_FLOOR)
+                new_dir = dir_right;//(C) with right turn
+            else if (feat_left == DNGN_FLOOR && feat_right == wall)
+                new_dir = dir_left;//(C) with left turn
+        }
+    }
+
+    if ( new_dir == -1 && diagonal && feat1 == wall )
+    {
+        if (feat0 == wall && feat2 == DNGN_FLOOR)
+        {
+            if (feat_right == DNGN_FLOOR
+                && _delta_to_feat(Compass[(dir_right + 1) % 8]) == wall
+                && _delta_to_feat(Compass[dir2] + Compass[dir1]) == wall
+                && _delta_to_feat(Compass[dir2] * 2) == wall
+                && _delta_to_feat(Compass[dir2] + Compass[dir_right]) == wall)
+            {
+                new_dir = dir_right;//(D) with right turn
+            }
+        }
+        else if (feat0 == DNGN_FLOOR && feat2 == wall)
+        {
+            if (feat_left == DNGN_FLOOR
+                && _delta_to_feat(Compass[(dir_left + 7) % 8]) == wall
+                && _delta_to_feat(Compass[dir0] + Compass[dir1]) == wall
+                && _delta_to_feat(Compass[dir0] * 2) == wall
+                && _delta_to_feat(Compass[dir0] + Compass[dir_left]) == wall)
+            {
+                new_dir = dir_left;//(D) with left turn
+            }
+        }
+    }
+
+    if (new_dir != -1)
+        initialise(new_dir, runmode);
+}
+
+int runrest::_run_should_stop() const
 {
     const coord_def targ = you.pos() + pos;
     const map_cell& tcell = env.map_knowledge(targ);
 
     if (tcell.cloud() != CLOUD_NONE)
-        return (true);
+        return 1;
 
     if (is_excluded(targ))
     {
@@ -4044,16 +4193,16 @@ bool runrest::run_should_stop() const
         // XXX: Remove this once exclusions are visible.
         mprf(MSGCH_WARN, "Stopped running for exclusion.");
 #endif
-        return (true);
+        return 1;
     }
 
     const monster_info* mon = tcell.monsterinfo();
     if (mon && !fedhas_passthrough(tcell.monsterinfo()))
-        return (true);
+        return 1;
 
     for (adjacent_iterator ai(targ); ai; ++ai)
         if (env.grid(*ai) == DNGN_SLIMY_WALL)
-            return (true);
+            return 1;
 
     for (int i = 0; i < 3; i++)
     {
@@ -4062,10 +4211,10 @@ bool runrest::run_should_stop() const
             _base_feat_type(env.map_knowledge(p).feat());
 
         if (run_check[i].grid != feat)
-            return (true);
+            return 2;
     }
 
-    return (false);
+    return 0;
 }
 
 void runrest::stop()
-- 
1.7.6.1