Merge lp:~armagetronad-dev/armagetronad/trunk-armagetronad-fortress_ai into lp:~armagetronad-dev/armagetronad/trunk-armagetronad-work

[Yann Kaiser]

[Manuel Moos (z-man)]

This definitely needs more work, non-fortress games are totally broken :)

review: Needs Fixing

[lp:~armagetronad-dev/armagetronad/trunk-armagetronad-fortress_ai]

936. By Manuel Moos on 2010-02-06

Taught the AI to aim for the enemy cycle, not the gap, and to avoid going in narrow tunnels.

937. By Manuel Moos on 2010-02-07

Better insertions. Still crappy followup.

938. By Manuel Moos on 2010-02-07

Merging from mainline.

939. By Manuel Moos on 2010-02-07

Merging memory leak fix.

940. By Manuel Moos on 2010-02-07

Merged another memory leak.

941. By Manuel Moos on 2010-02-07

Merging from trunk again.

942. By Manuel Moos on 2010-08-07

Merging from mainline.

943. By Manuel Moos on 2010-08-08

merging from mainline.

944. By Manuel Moos on 2011-09-26

Merging from mainline.

945. By Manuel Moos on 2011-11-04

Merging from 0.4.

Unmerged revisions

945. By Manuel Moos on 2011-11-04

Merging from 0.4.

944. By Manuel Moos on 2011-09-26

Merging from mainline.

943. By Manuel Moos on 2010-08-08

merging from mainline.

942. By Manuel Moos on 2010-08-07

Merging from mainline.

941. By Manuel Moos on 2010-02-07

Merging from trunk again.

940. By Manuel Moos on 2010-02-07

Merged another memory leak.

939. By Manuel Moos on 2010-02-07

Merging memory leak fix.

938. By Manuel Moos on 2010-02-07

Merging from mainline.

937. By Manuel Moos on 2010-02-07

Better insertions. Still crappy followup.

936. By Manuel Moos on 2010-02-06

Taught the AI to aim for the enemy cycle, not the gap, and to avoid going in narrow tunnels.

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2015-01-02 07:18:54 +0000
+++ src/Makefile.am	2019-01-04 23:26:28 +0000
@@ -149,7 +149,10 @@
 	render/rTextureRenderTarget.cpp render/rTextureRenderTarget.h render/rGLuintObject.cpp render/rGLuintObject.h
 
 
-libtron_a_SOURCES=tron/gAIBase.cpp tron/gAIBase.h tron/gAICharacter.cpp tron/gAICharacter.h tron/gArena.cpp tron/gArena.h\
+libtron_a_SOURCES=tron/gAIBase.cpp tron/gAIBase.h \
+    tron/gAICharacter.cpp tron/gAICharacter.h \
+    tron/gAINavigator.cpp tron/gAINavigator.h \
+    tron/gArena.cpp tron/gArena.h\
 	tron/gArmagetron.cpp tron/gCamera.cpp tron/gCamera.h tron/gCycle.cpp tron/gCycle.h tron/gCycleMovement.cpp\
 	tron/gJoystick.h tron/gJoystick.cpp\
 	tron/gCycleMovement.h tron/gExplosion.cpp tron/gExplosion.h tron/gGame.cpp tron/gGame.h\
@@ -177,6 +180,7 @@
 if BUILDZONESV2
 libtron_a_SOURCES +=\
 	tron/zone/zZone.cpp        tron/zone/zZone.h\
+	tron/zone/zAI.cpp          tron/zone/zAI.h\
 	tron/zone/zTimedZone.cpp   tron/zone/zTimedZone.h\
 	tron/zone/zShape.cpp       tron/zone/zShape.h\
 	tron/zone/zMonitor.h       tron/zone/zMonitor.cpp\

=== modified file 'src/engine/eCamera.cpp'
--- src/engine/eCamera.cpp	2013-10-28 22:02:36 +0000
+++ src/engine/eCamera.cpp	2019-01-04 23:26:28 +0000
@@ -543,6 +543,11 @@
 
     centerPos=eCoord(100,100);
     centerSpeedSmooth=0;
+    if( !Center() )
+    {
+        SwitchCenter(1);
+    }
+
     if ( Center() )
     {
         centerPos = Center()->PredictPosition();

=== modified file 'src/engine/eGameObject.cpp'
--- src/engine/eGameObject.cpp	2013-10-28 22:02:36 +0000
+++ src/engine/eGameObject.cpp	2019-01-04 23:26:28 +0000
@@ -144,6 +144,13 @@
     tCHECK_DEST;
 }
 
+eCoord eGameObject::Position()const{return pos;}
+eCoord eGameObject::Direction()const{return dir;}
+eCoord eGameObject::LastDirection()const{return dir;}
+REAL eGameObject::DeathTime()const{return deathTime;}
+REAL  eGameObject::Speed()const{return 0;}
+
+
 // returns the type of this object (important for interaction of
 // two gameObjects)
 //gameobject_type gameobject::type(){return ArmageTron_GENERIC;}

=== modified file 'src/engine/eGameObject.h'
--- src/engine/eGameObject.h	2011-08-22 19:38:52 +0000
+++ src/engine/eGameObject.h	2019-01-04 23:26:28 +0000
@@ -134,11 +134,11 @@
     eGameObject(eGrid *grid, const eCoord &p,const eCoord &d, eFace *currentface, bool autodelete=1);
     virtual ~eGameObject();
 
-    virtual eCoord Position()const{return pos;}
-    virtual eCoord Direction()const{return dir;}
-    virtual eCoord LastDirection()const{return dir;}
-    virtual REAL DeathTime()const{return deathTime;}
-    virtual REAL  Speed()const{return 20;}
+    virtual eCoord Position()const;
+    virtual eCoord Direction()const;
+    virtual eCoord LastDirection()const;
+    virtual REAL DeathTime()const;
+    virtual REAL  Speed()const;
 
     //! returns a guess about which other object killed this
     virtual eGameObject const * Killer() const { return NULL; }

=== modified file 'src/engine/eSensor.cpp'
--- src/engine/eSensor.cpp	2008-12-29 17:15:32 +0000
+++ src/engine/eSensor.cpp	2019-01-04 23:26:28 +0000
@@ -34,7 +34,7 @@
 //#define DEBUGLINE
 #endif
 
-eSensor::eSensor(eGameObject *o,const eCoord &start,const eCoord &d)
+eSensor::eSensor(eGameObject const * o,const eCoord &start,const eCoord &d)
         :eStackGameObject(o->grid, start,d,o->currentFace)
         ,hit(1000),ehit(NULL),lr(0), owned(o) , inverseSpeed_(0)
 {

=== modified file 'src/engine/eSensor.h'
--- src/engine/eSensor.h	2010-08-08 13:55:24 +0000
+++ src/engine/eSensor.h	2019-01-04 23:26:28 +0000
@@ -43,7 +43,7 @@
     int             lr;         // and direction it goes to (left/right)
     eCoord           before_hit; // a point shortly before that eWall
 
-    eSensor(eGameObject *o,const eCoord &start,const eCoord &d);
+    eSensor(eGameObject const * o,const eCoord &start,const eCoord &d);
 
     virtual void PassEdge(const eWall *w,REAL time,REAL,int =1);
     //  virtual void PassEdge(eEdge *e,REAL time,REAL a,int recursion=1);
@@ -56,7 +56,7 @@
     inline eSensor const & GetInverseSpeed( REAL & inverseSpeed ) const;	//!< Gets the inverse speed of the sensor
     eGameObject const * GetOwner() const { return owned; } //!< Returns the gameobject owning this sensor
 protected:
-    tCHECKED_PTR(eGameObject) owned;
+    tCHECKED_PTR( eGameObject const ) owned;
 private:
     REAL inverseSpeed_; //! the inverse speed of the sensor; walls far away will be checked for opacity a bit in the future if this is set.
 };

=== modified file 'src/tools/tError.cpp'
--- src/tools/tError.cpp	2011-08-24 21:08:38 +0000
+++ src/tools/tError.cpp	2019-01-04 23:26:28 +0000
@@ -51,6 +51,12 @@
 #endif
 }
 
+void st_NotImplemented( char const * function )
+{
+    std::cerr << "Missing implementation of " << function << ".\n";
+    st_Breakpoint();
+}
+
 #ifndef WIN32
 
 void st_PresentError( const char* caption, const char *message )

=== modified file 'src/tools/tError.h'
--- src/tools/tError.h	2010-10-21 20:07:14 +0000
+++ src/tools/tError.h	2019-01-04 23:26:28 +0000
@@ -52,6 +52,9 @@
 
 int st_debugValid(tLevel l,tChannel c);
 
+// marks that something is left to be done here
+void st_NotImplemented( char const * function );
+#define tTODO() st_NotImplemented( __FUNCTION__ )
 
 #define tERR_DUMP(level,stream,stuff) if(st_debugValid(level,stream))  std::cout <<  setw(28) << __FUNCTION__  << " : " << stuff << '\n'
 
@@ -66,6 +69,7 @@
 #define tASSERT_EVAL( x ) { if ( !( x ) ){ char const * mess = "Assertion " #x " failed";  tERR_ERROR_INT( mess ); } }
 
 #else  /* DEBUG */
+#define tTODO()
 #define tERR_DUMP(level,stream,stuff) 
 #define tERR_FLOW()
 #define tERR_FLOW_HIGH()

=== modified file 'src/tools/tMath.h'
--- src/tools/tMath.h	2013-11-23 20:50:07 +0000
+++ src/tools/tMath.h	2019-01-04 23:26:28 +0000
@@ -44,11 +44,13 @@
 #include <ieeefp.h>
 #endif
 
+//! returns wiether a float value is good and finite
 inline bool good( REAL f )
 {
     return isfinite( f );
 }
 
+//! clamps a value between two others
 static inline bool clamp(REAL &c, REAL min, REAL max){
     tASSERT(min <= max);
 
@@ -73,4 +75,16 @@
     return false;
 }
 
+//! returns the minumum of two values
+static inline REAL tMin(REAL a, REAL b)
+{
+    return a > b ? b : a;
+}
+
+//! returns the maximum of two values
+static inline REAL tMax(REAL a, REAL b)
+{
+    return a > b ? a : b;
+}
+
 #endif

=== modified file 'src/tron/gAIBase.cpp'
--- src/tron/gAIBase.cpp	2011-11-20 22:01:15 +0000
+++ src/tron/gAIBase.cpp	2019-01-04 23:26:28 +0000
@@ -39,13 +39,19 @@
 #include "eFloor.h"
 #include "eDebugLine.h"
 #include "gAICharacter.h"
+#include "gAINavigator.h"
 #include "tReferenceHolder.h"
 #include "tRandom.h"
 #include "tRecorder.h"
+#include "zone/zZone.h"
 #include <stdlib.h>
 #include <cstdlib>
 #include <memory>
 
+#ifdef DEBUG
+#include "tCommandLine.h"
+#endif
+
 #include "nProtoBuf.h"
 #include "gAIBase.pb.h"
 
@@ -65,12 +71,6 @@
 
 static tReferenceHolder< gAIPlayer > sg_AIReferences;
 
-#ifdef DEBUG
-//#define TESTSTATE AI_PATH
-//#define TESTSTATE AI_TRACE
-#endif
-//#define DEBUGLINE
-
 static tCONTROLLED_PTR(gAITeam) sg_AITeam = NULL;
 
 gSimpleAIFactory *gSimpleAIFactory::factory_ = NULL;
@@ -173,7 +173,10 @@
     return delay;
 }
 
+<<<<<<< TREE
 
+=======
+>>>>>>> MERGE-SOURCE
 static gAICharacter* BestIQ( int iq )
 {
     int i;
@@ -314,8 +317,8 @@
 
                 if ( best )
                 {
-                    gAIPlayer *ai 	= tNEW( gAIPlayer ) ();
-                    ai->character	= best;
+                    gAIPlayer *ai  = tNEW( gAIPlayer ) ();
+                    ai->character_ = best;
                     ai->SetName( best->name );
                     ai->SetTeam( t );
                     ai->UpdateTeam();
@@ -589,7 +592,14 @@
     return false;
 }
 
-
+// see if the given Cycle is trapped currently
+bool IsTrapped(const eGameObject *trapped, const gCycle *other)
+{
+    gCycle const * cycle = dynamic_cast< gCycle const * >( trapped );
+    if( cycle )
+        return IsTrapped( cycle, other );
+    return false;
+}
 
 
 // data about a loop
@@ -603,6 +613,8 @@
     void AddCycle(const gCycle* c){closedIn[closedIn.Len()] = c;}
 };
 
+#ifdef OBSOLETES
+
 // hit data
 class gHitData{
 public:
@@ -892,7 +904,7 @@
 
 };
 
-
+#endif // OBSOLETES
 
 
 
@@ -986,8 +998,160 @@
     }
 }
 
-
-
+// *******************
+// * Tracing state   *
+// *******************
+
+class gStateTrace: public gAIPlayer::State
+{
+public:
+    gStateTrace( gAIPlayer & ai, int dir ): gAIPlayer::State( ai ), dir_( dir ){}
+
+    // evaluator for tracing
+    class Evaluator: public gAINavigator::PathEvaluator
+    {
+    public:
+        Evaluator( gCycle & cycle, int dir ): cycle_( cycle ), dir_( dir ){}
+
+        virtual void Evaluate( gAINavigator::Path const & path, gAINavigator::PathEvaluation & evaluation ) const
+        {
+            gAINavigator::WallHug const * hug = 0, * noHug = 0;
+            if( dir_ > 0 )
+            {
+                hug   = &path.left;
+                noHug = &path.right;
+            }
+            else
+            {
+                hug   = &path.right;
+                noHug = &path.left;
+            }
+
+            bool good = hug->owner && hug->owner->Team() != cycle_.Team();
+            if( good )
+            {
+                if( hug->owner != noHug->owner )
+                {
+                    evaluation.score = 50;
+                }
+                else if( ( path.shortTermDirection - path.longTermDirection ).NormSquared() < .01 )
+                {
+                    evaluation.score = 50 + .5*Adjust( path.immediateDistance/(cycle_.Speed()*cycle_.GetTurnDelay() ) );
+                }
+            }
+        }
+    private:
+        gCycle & cycle_;
+        int dir_;
+    };
+    
+    virtual REAL Think( REAL maxStep )
+    { 
+        Navigator().UpdatePaths();
+        gAINavigator::EvaluationManager manager( Navigator().GetPaths() );
+        manager.Evaluate( gAINavigator::SuicideEvaluator( *Parent().Object() ), 1 );
+        manager.Reset();
+        manager.Evaluate( Evaluator( *Parent().Object(), dir_ ), 1 );
+        manager.Evaluate( gAINavigator::SpaceEvaluator( *Parent().Object() ), .5 );
+        manager.Evaluate( gAINavigator::PlanEvaluator(), .1 );
+
+        gAINavigator::CycleControllerBasic controller;
+        return manager.Finish( controller, *Parent().Object(), maxStep );
+    }
+private:
+    int dir_;
+};
+
+// ********************
+// * tailchase helper *
+// ********************
+   
+// likes to chase its own tail
+class gTailChaseEvaluator: public gAINavigator::PathEvaluator
+{
+public:
+    gTailChaseEvaluator( gCycle const & cycle ): cycle_( cycle )
+    {
+    }
+
+    void Evaluate( gAINavigator::Path const & path, gAINavigator::PathEvaluation & evaluation ) const
+    {
+        evaluation.score = 0;
+        
+        // don't do anything if we're tunneling. Danger affot.
+        // if( path.left.owner == path.right.owner )
+        // {
+        // return;
+        // }
+
+        // total wall length
+        REAL len  = cycle_.ThisWallsLength();
+        if( len < 0 )
+        {
+            return;
+        }
+
+        if( path.left.owner == &cycle_ ) // && path.left.lr == 1 )
+        {
+            evaluation.score += 200 * path.left.hitDistance/len - 100;
+        }
+        if( path.right.owner == &cycle_ ) // && path.right.lr == -1 )
+        {
+            evaluation.score +=  200 * path.right.hitDistance/len - 100;
+        }
+        if ( evaluation.score < 0 )
+        {
+            evaluation.score = 0;
+        }
+    }
+private:
+    gCycle const & cycle_; //!< the owning cycle
+};
+
+
+// *******************
+// * Survival state  *
+// *******************
+
+class gStateSurvive: public gAIPlayer::State
+{
+public:
+    gStateSurvive( gAIPlayer & ai ): gAIPlayer::State( ai ){}
+
+    virtual REAL Think( REAL maxStep )
+    { 
+        gCycle & cycle = *Parent().Object();
+        Navigator().UpdatePaths();
+        gAINavigator::EvaluationManager manager( Navigator().GetPaths() );
+        manager.Evaluate( gAINavigator::SuicideEvaluator( cycle ), 1 );
+        manager.Evaluate( gAINavigator::SuicideEvaluator( cycle, maxStep ), 1 );
+        manager.Evaluate( gAINavigator::TrapEvaluator( cycle ), 1 );
+        manager.Reset();
+        manager.Evaluate( gAINavigator::CowardEvaluator( cycle ), 5 );
+        manager.Evaluate( gAINavigator::SpaceEvaluator( cycle ), 1 );
+        manager.Evaluate( gAINavigator::RandomEvaluator(), .01 );
+        manager.Evaluate( gAINavigator::PlanEvaluator(), .1 );
+
+        gAINavigator::CycleControllerBasic controller;
+        return manager.Finish( controller, *Parent().Object(), maxStep );
+    }
+};
+
+void gAIPlayer::SwitchToSurvival()
+{
+    SwitchToState( tNEW( gStateSurvive )( *this ) );
+}
+
+void gAIPlayer::SetTarget( eNetGameObject * target )
+{
+    this->target_ = target;
+
+    // let's see how well this works:
+    // state = AI_CLOSECOMBAT;
+
+    // start with it right now
+    nextTime_ = -1;
+}
 
 // called whenever cylce a drives close to the wall of cylce b.
 // directions: aDir tells whether the wall is to the left (-1) or right(1)
@@ -998,6 +1162,8 @@
                                int aDir, int bDir, REAL bDist, int winding)
 {
 
+    return;
+
 
     tASSERT(aa && bb);
     gCycle * a = dynamic_cast< gCycle * >( const_cast< gCycleMovement * > ( aa ) );
@@ -1020,35 +1186,42 @@
     if (a->Team() != b->Team())
     {
         gAIPlayer* ai = dynamic_cast<gAIPlayer*>(b->Player());
-        if (ai && ai->Character() && ai->Character()->properties[AI_DETECTTRACE] > 5)
-            if(aDir != bDir && ai->nextStateChange < se_GameTime() + 5 &&
-                    ai->lastChangeAttempt < se_GameTime() - 5 )
+        if( ai && dynamic_cast< zZone const * >( ai->GetTarget() ) )
+        {
+            // ai is attacking or defending a zone, don't disturb it
+            return;
+        }
+
+        if (ai && ai->Character() && ai->Character()->properties[AI_DETECTTRACE] > 5 )
+            if(aDir != bDir )
             {
                 REAL behind = b->GetDistance() - bDist;
                 if (a->Speed() > b->Speed() * 1.2f && behind < (a->Speed() - b->Speed()) * 10)
                 { // a is faster. Try to escape.
-                    ai->SetTraceSide(aDir > 0 ? 1 : -1);
-                    ai->SwitchToState(AI_TRACE, 10);
-                    ai->target = const_cast< gCycle * >( a );
+                    ai->SwitchToState( tNEW(gStateTrace)( *ai, aDir > 0 ? 1 : -1 ) );
+                    ai->target_ = const_cast< gCycle * >( a );
                 }
                 else// if (a->Speed() < b->Speed() * 1.1f)
                 { // b is faster. Attack.
-                    ai->SetTraceSide(aDir > 0 ? -1 : 1);
-                    ai->SwitchToState(AI_TRACE, 10 + behind / ( a->Speed() + b->Speed() ) );
-                    ai->target = const_cast< gCycle * >( a );
+                    ai->SwitchToState( tNEW(gStateTrace)( *ai, aDir > 0 ? -1 : 1 ) );
+                    ai->target_ = const_cast< gCycle * >( a );
                 }
             }
 
         // what to do if the AI player traces his opponent by accident? Trace On!
         ai = dynamic_cast<gAIPlayer*>(a->Player());
+
+        if( ai && dynamic_cast< zZone const * >( ai->GetTarget() ) )
+        {
+            // ai is attacking or defending a zone, don't disturb it
+            return;
+        }
+
         if (ai && ai->Character() && ai->Character()->properties[AI_DETECTTRACE] > 0)
-            if(aDir != bDir && ai->nextStateChange < se_GameTime() + 5 &&
-                    ai->lastChangeAttempt < se_GameTime() - 5 )
+            if(aDir != bDir )
             {
-                REAL behind = b->GetDistance() - bDist;
-                ai->SetTraceSide(aDir > 0 ? 1 : -1);
-                ai->SwitchToState(AI_TRACE, 10 + 4 * behind / a->Speed());
-                ai->target = const_cast< gCycle * >( b );
+                ai->SwitchToState( tNEW(gStateTrace)( *ai, aDir > 0 ? 1 : -1 ) );
+                ai->target_ = const_cast< gCycle * >( b );
             }
     }
 }
@@ -1102,35 +1275,25 @@
 //! creates a netobject form sync data
 gAIPlayer::gAIPlayer( Game::AIPlayerSync const & sync, nSenderInfo const & sender ):
         ePlayerNetID(sync.base(), sender ),
-        character(NULL),
-        //	target(NULL),
-        lastPath(se_GameTime()-100),
-        lastTime(se_GameTime()),
-        nextTime(0),
-        concentration(1),
-        log(NULL)
+        character_(NULL),
+        lastTime_(se_GameTime()),
+        nextTime_(0),
+        concentration_(1)
 {
 }
 
 
 gAIPlayer::gAIPlayer():
         simpleAI_(NULL),
-        character(NULL),
+        character_(NULL),
         //	target(NULL),
-        lastPath(se_GameTime()-100),
-        lastTime(se_GameTime()),
-        nextTime(0),
-        concentration(1),
-        log(NULL)
+        lastTime_(se_GameTime()),
+        nextTime_(0),
+        concentration_(1)
 {
-    character = NULL;
     ClearTarget();
-    traceSide = 1;
-    freeSide  = 0;
-    log       = NULL;
 
     // find a good color
-
     current_ai=(current_ai+1) % MAXAI_COLOR;
     int take_ai=current_ai;
     int try_ai=current_ai;
@@ -1260,7 +1423,7 @@
                 //				int index = ((int)ai->character - (int)&gAICharacter::s_Characters(0))/sizeof(gAICharacter);
                 //				inGame(index) = true;
 
-                if (!worstIQ || !worstIQ->character || fabs(worstIQ->character->iq - iq) < fabs(ai->character->iq - iq) )
+                if (!worstIQ || !worstIQ->character_ || fabs(worstIQ->character_->iq - iq) < fabs(ai->character_->iq - iq) )
                     worstIQ = ai;
 
                 count++;
@@ -1286,8 +1449,8 @@
             count = pcount;
 
         iqperfect = true;
-        if (bestIQ && worstIQ && worstIQ->character )
-            iqperfect = (fabs(bestIQ->iq - iq) > fabs(worstIQ->character->iq - iq) * .9f);
+        if (bestIQ && worstIQ && worstIQ->character_ )
+            iqperfect = (fabs(bestIQ->iq - iq) > fabs(worstIQ->character_->iq - iq) * .9f);
 
 
         // count complete. Do something!
@@ -1318,7 +1481,7 @@
             // too litte AIs. Create one.
             gAIPlayer *ai = tNEW(gAIPlayer)();
             ai->SetName( bestIQ->name );
-            ai->character = bestIQ;
+            ai->character_ = bestIQ;
 
             sg_AIReferences.Add( ai );
 
@@ -1348,8 +1511,6 @@
 
 }
 
-
-
 // Possible state changes:
 // Every state -> Survive for 20 seconds if the victim is dead or can be assumed dead soon, or if the situation gets too dangerous
 
@@ -1364,6 +1525,7 @@
 // CloseCombat -> Path if the vicim gets out of view
 
 
+#ifdef OLD_AI_OUTDATED
 void gAIPlayer::SetTraceSide(int side)
 {
     REAL time = se_GameTime();
@@ -1387,8 +1549,15 @@
 // flag set if pathfinding is enabled. It's an expensive opeeration, so we just turn it
 // off if the PC can't handle it. Doesn't doo much good, anyway.
 static bool sg_pathEnabled = true;
+#endif // OLD_AI
 
 // state change:
+void gAIPlayer::SwitchToState( State * state )
+{
+    state_           = state;
+}
+
+#ifdef OLD_AI_OUTDATED
 void gAIPlayer::SwitchToState(gAI_STATE nextState, REAL minTime)
 {
     int thisAbility = 10 - character->properties[AI_STATE_TRACE];
@@ -1883,7 +2052,6 @@
         data.thinkAgain *= .7;
 }
 
-
 void gAIPlayer::ThinkCloseCombat( ThinkData & data )
 {
     int lr=0;
@@ -1899,7 +2067,8 @@
     //  REAL ls=left.hit;
     //  REAL rs=right.hit;
 
-    if ( bool( target ) && !IsTrapped(target, Object()) && nextStateChange < se_GameTime() )
+    zZone const * zoneTarget = dynamic_cast< zZone const * >( GetTarget() );
+    if ( bool( target ) && !zoneTarget && !IsTrapped(target, Object()) && nextStateChange < se_GameTime() )
     {
         gSensor p(Object(),Object()->Position(),target->Position() - Object()->Position());
         p.detect(REAL(1));
@@ -1907,6 +2076,7 @@
         {
             SwitchToState(sg_pathEnabled ? AI_PATH : AI_SURVIVE, 5);
             EmergencySurvive( data );
+
             return;
         }
     }
@@ -1931,7 +2101,7 @@
         REAL enemyspeed=target->Speed();
 
         ed=REAL(fabs(enemypos.x)+fabs(enemypos.y));
-        ed/=enemyspeed;
+        ed/=(enemyspeed+Object()->Speed());
 
         // transform coordinates relative to us:
         enemypos=enemypos.Turn(dir.Conj()).Turn(0,1);
@@ -1953,6 +2123,32 @@
         }
         // now we can even assume the enemy is on our right side.
 
+        if ( zoneTarget && idler.get() )
+        {
+            if ( enemypos.y < 0 || ( data.front.front.wallType != gSENSOR_SELF && data.front.front.distance < Object()->Speed() * Object()->GetTurnDelay() ) )
+            {
+                gAINavigator::Wish wish( *idler );
+                wish.turn = -side;
+
+                // extra strong turn wish if wall is not mine
+                if( sides[1]->front.wallType != gSENSOR_SELF &&  sides[0]->front.wallType != gSENSOR_SELF )
+                {
+                    wish.turn *= 2;
+                }
+
+                if ( enemypos.x > -enemypos.y * 2 )
+                {
+                    wish.minDistance = Object()->ThisWallsLength()/2;
+                }
+                data.thinkAgain = idler->Activate( Object()->LastTime(), 0, 0, &wish );
+            }
+            else
+            {
+                data.thinkAgain = idler->Activate( Object()->LastTime(), 0, 0 );
+            }
+            return;
+        }
+
         // consider his ping and our reaction time
 #define REACTION .2
 
@@ -1971,6 +2167,7 @@
 
         REAL ourdist=REACTION*ourspeed;;
 
+        
 
         // now we consider the worst case: we drive straight on,
         enemypos.y-=ourdist;
@@ -2015,17 +2212,6 @@
             }
         }
         else if (enemypos.y*ourspeed<-enemypos.x*enemyspeed){
-            /*
-              // good attack position
-              if (enemypos.x<rs && rs < range*.99){
-              #ifdef DEBUG
-              con << "BOX!\n";
-              #endif
-              turn+=10;
-              lr-=side;
-              }
-
-            */
 
             REAL canCutIfDriveOn = enemypos.x*ourspeed - fs * (enemyspeed - ourspeed);
             canCutIfDriveOn -= enemypos.y*enemyspeed;
@@ -2067,6 +2253,7 @@
     if (!EmergencySurvive(data, 1, -lr))
         nextThought = 0;
 
+<<<<<<< TREE
     data.thinkAgain = ed/2 + nextThought;
 }
 
@@ -2710,25 +2897,188 @@
 
 
 
+=======
+    data.thinkAgain = ed + nextThought;
+}
+#endif // OLD_AI
+
+// **********
+// * States *
+// **********
+
+//!@param player   the AI player the state belongs to
+gAIPlayer::State::State( gAIPlayer & player )
+: parent_( player )
+{
+}
+
+gAIPlayer::State::~State()
+{
+}
+
+//!@return time in seconds until a new thought is needed
+REAL gAIPlayer::State::Think( REAL maxStep )
+{
+    tASSERT(0);
+    return 0;
+}
+
+//!@return the navigator to use
+gAINavigator & gAIPlayer::State::Navigator()
+{
+    tASSERT( Parent().navigator_.get() );
+    return *(Parent().navigator_.get());
+}
+
+//!@return the navigator to use
+gAINavigator const & gAIPlayer::State::Navigator() const
+{
+    tASSERT( Parent().navigator_.get() );
+    return *( Parent().navigator_.get() );
+}
+
+//!@return the character
+gAICharacter const & gAIPlayer::State::Character() const
+{
+    tASSERT( Parent().character_ );
+    return *Parent().character_;
+}
+
+gAIPlayer::StateGrind::StateGrind( gAIPlayer & player )
+: State( player )
+{
+}
+
+gAIPlayer::StateGrind::~StateGrind(){}
+
+REAL gAIPlayer::StateGrind::Think( REAL maxStep )
+{
+    Parent().SwitchToSurvival();
+    /*
+
+    REAL range = Delay() * Object()->Speed() * .5;
+
+    if( data.front.front.wallType == gSENSOR_TEAMMATE )
+    {
+        if ( substate == AI_GRIND_GRIND )
+        {
+            if ( data.front.front.distance > range * .1 )
+            {
+                data.thinkAgain = data.front.front.distance/Object()->Speed();
+                return;
+            }
+            else
+            {
+                data.turn = data.front.front.lr;
+                data.thinkAgain = Object()->GetTurnDelay();
+                return;
+            }
+        }
+        else
+        {
+            data.turn = data.front.front.lr;
+            data.thinkAgain = Object()->GetTurnDelay();
+            state = AI_SURVIVE;
+            return;
+        }
+    }
+
+    if( data.left.front.wallType == gSENSOR_TEAMMATE )
+    {
+        if ( data.left.front.distance > range )
+        {
+            substate = AI_GRIND_GRIND;
+            data.turn = -1;
+            data.thinkAgain = data.left.front.distance/Object()->Speed();
+            return;
+        }
+        else if ( state == AI_GRIND )
+        {
+            substate = AI_GRIND_SPLIT_RIGHT;
+            return;
+        }
+    }
+
+    if( data.right.front.wallType == gSENSOR_TEAMMATE )
+    {
+        if ( data.right.front.distance > range )
+        {
+            substate = AI_GRIND_GRIND;
+            data.turn = 1;
+            data.thinkAgain = data.right.front.distance/Object()->Speed();
+            return;
+        }
+        else if ( state == AI_GRIND )
+        {
+            substate = AI_GRIND_SPLIT_LEFT;
+            return;
+        }
+    }
+
+    // SPLIT!
+    if( substate == AI_GRIND_SPLIT_LEFT )
+    { 
+        if ( data.right.front.wallType != gSENSOR_TEAMMATE )
+        {
+            data.thinkAgain = data.left.front.distance/Object()->Speed();
+            data.turn = -1;
+        }
+        else
+        {
+            data.thinkAgain = Delay() * 2;
+            return;
+        }
+    }
+
+    if( substate == AI_GRIND_SPLIT_RIGHT )
+    {
+        if( data.left.front.wallType != gSENSOR_TEAMMATE )
+        {
+            data.thinkAgain = data.right.front.distance/Object()->Speed();
+            data.turn = 1;
+        }
+        else
+        {
+            data.thinkAgain = Delay() * 2;
+            return;
+        }
+    }
+
+    SwitchToState( AI_SURVIVE );
+    data.thinkAgain = .5;
+
+    */
+
+    return 0;
+}
+>>>>>>> MERGE-SOURCE
 
 void gAIPlayer::RightBeforeDeath(int triesLeft) // is called right before the vehicle gets destroyed.
 {
+    // sadly, we have no energy for this
+    if( triesLeft > concentration_ )
+    {
+        return;
+    }
+
     if ( nCLIENT == sn_GetNetState() )
         return;
 
     if ( simpleAI_ )
         return;
 
-    if (!character)
+    if ( !character_ )
     {
         st_Breakpoint();
         return;
     }
 
+    CreateNavigator();
+
     gRandomController random( randomizer_ );
 
     // think again immediately after this
-    nextTime = lastTime;
+    nextTime_ = lastTime_;
 
 #ifdef DEBUG_X
     if (log && !Object()->Alive())
@@ -2740,9 +3090,10 @@
     }
 #endif
 
-    if (!Object()->Alive() || ( character && Random() * 10 > character->properties[AI_EMERGENCY] ) )
+    if (!Object()->Alive() || ( character_ && Random() * 10 > character_->properties[AI_EMERGENCY] ) )
         return;
 
+<<<<<<< TREE
 
     // get the delay between two turns
     REAL delay = Delay();
@@ -2799,38 +3150,66 @@
         gAISensor right(Object(),Object()->Position(),dir.Turn(eCoord(0,-1)), side, range, range*.3, 1);
     }
 #endif
+=======
+    if( triesLeft <= 0 )
+    {
+        gAINavigator::SuicideEvaluator::SetEmergency( true );
+    }
+
+    Think( 0 );
+
+    gAINavigator::SuicideEvaluator::SetEmergency( false );
+>>>>>>> MERGE-SOURCE
 }
 
 gAIPlayer * sg_watchAI = 0;
 
 void gAIPlayer::NewObject()         // called when we control a new object
 {
+<<<<<<< TREE
     lastTime = se_GameTime();
     lastPath = 0;
     lastChangeAttempt = 0;
     lazySideChange = 0;
     path.Clear();
+=======
+    lastTime_ = 0;
+    
+    navigator_.reset();
+>>>>>>> MERGE-SOURCE
 
-    if (character)
+    if ( character_ )
     {
+<<<<<<< TREE
         nextTime        = lastTime + character->properties[AI_STARTSTRAIGHT] * gArena::SizeMultiplier()/gCycleMovement::SpeedMultiplier();
         nextStateChange = lastTime + character->properties[AI_STATECHANGE];
         state           = (gAI_STATE)character->properties[AI_STARTSTATE];
+=======
+        nextTime_       = character_->properties[AI_STARTSTRAIGHT] * gArena::SizeMultiplier()/gCycleMovement::SpeedMultiplier();
+        switch ( character_->properties[AI_STARTSTATE] )
+        {
+        default:
+            state_          = tNEW(gStateSurvive)(*this);
+            break;
+        }
+>>>>>>> MERGE-SOURCE
     }
     else
     {
-        nextTime        = 10;
-        nextStateChange = 30;
-        state           = AI_TRACE;
+        nextTime_        = 10;
+        state_          = tNEW(gStateSurvive)(*this);
     }
 
-    if (log)
-        delete log;
-    log = NULL;
+    if( TeamListID() > 0 )
+    {
+        state_ = tNEW(StateGrind)(*this);
+        nextTime_ = Delay() * 2 + .1;
+    }
 
     ClearTarget();
 }
 
+/*
 static gAISensor * sg_GetSensor( int currentDirectionNumber, gCycle const & object, int turn, REAL side, REAL range, REAL corridor, REAL & mindist )
 {
     // determine the current direction
@@ -2875,8 +3254,44 @@
 
     return ret;
 }
-
-REAL gAIPlayer::Think(){
+*/
+
+void gAIPlayer::CreateNavigator()
+{
+    gCycle * cycle = Object();
+    if( cycle && !navigator_.get() )
+    {
+        navigator_ = std::auto_ptr< gAINavigator >( tNEW( gAINavigator( cycle ) ) );
+    }
+}
+
+#ifdef DEBUG
+static int sg_breakOnThought = 0;
+class tCommandLineBreakOnThought: public tCommandLineAnalyzer
+{
+    virtual bool DoAnalyze( tCommandLineParser & parser )    //! Analyzes the command line option
+    {
+        tString value;
+        if( parser.GetOption( value, "--breakonthought" ) ) 
+        {
+            sg_breakOnThought = value.ToInt();
+
+            return true;
+        }
+        return false;
+    }
+
+    virtual void DoHelp( std::ostream & s )                  //! Prints option help
+    {
+        s << "--breakonthought <thought>   : sets a breakpoint on the given thought of the AI (the static variable 'count' in gAIBase::Think())\n\n";
+    }
+};
+static tCommandLineBreakOnThought sg_breakOnThoughtCommandLine;
+#endif
+
+REAL gAIPlayer::Think( REAL maxStep ){
+    concentration_ -= 1;
+
     if ( !simpleAI_ )
     {
         gSimpleAIFactory * factory = gSimpleAIFactory::Get();
@@ -2886,27 +3301,23 @@
         }
     }
 
+    CreateNavigator();
+
     if ( simpleAI_ )
     {
-        return simpleAI_->Think();
+        return simpleAI_->Think( maxStep );
     }
 
-    // get the delay between two turns
-    REAL delay = Delay();
-
-#ifdef DEBUG_X  
-    if (log && !Object()->Alive())
+    if( GetTarget() && ( !GetTarget()->Alive() || IsTrapped( GetTarget(), Object() ) ) )
     {
-        log->Print();
-        st_Breakpoint();
-        delete log;
-        log = NULL;
+        // no longer makes sense to chase
+        ClearTarget();
     }
-#endif
 
     if (!Object()->Alive())
         return 100;
 
+<<<<<<< TREE
     emergency = false;
     //  return 1;
 
@@ -2960,23 +3371,22 @@
         SwitchToState(AI_SURVIVE, 1);
 #endif
 
+=======
+#ifdef DEBUG
+>>>>>>> MERGE-SOURCE
     {
         eDebugLine::SetTimeout(.5);
         eDebugLine::SetColor  (0, 1, 0);
         eCoord p = Object()->Position();
         eDebugLine::Draw(p, .5, p, 5.5);
         eDebugLine::SetTimeout(0);
-    }
-
-    triesLeft = 10;
-
-    REAL ret = 1;
-
-    //not the best solution, but still better than segfault...
-    if(left.get() != 0 && right.get() != 0) {
-        ThinkData data( front, *left, *right);
-        switch (state)
+
+        // to debug specific situations on playback
+        static int count = 0;
+        count++;
+        if( count == sg_breakOnThought )
         {
+<<<<<<< TREE
         case AI_SURVIVE:
             ThinkSurvive(data);
             break;
@@ -2993,19 +3403,14 @@
         case AI_CLOSECOMBAT:
             ThinkCloseCombat(data);
             break;
+=======
+            st_Breakpoint();
+>>>>>>> MERGE-SOURCE
         }
-        ActOnData( data );
-        ret = data.thinkAgain;
-    }
-
-#ifdef DEBUG_X
-    {
-        gAISensor front(Object(),Object()->Position(),dir, side, range, range*.3, 0);
-        gAISensor left(Object(),Object()->Position(),dir.Turn(eCoord(0,1)), side, range, range*.3, -1);
-        gAISensor right(Object(),Object()->Position(),dir.Turn(eCoord(0,-1)), side, range, range*.3, 1);
     }
 #endif
 
+<<<<<<< TREE
     REAL mindist = front.distance * front.distance * 8;
 
     const tList<eGameObject>& gameObjects = Object()->Grid()->GameObjects();
@@ -3108,41 +3513,57 @@
 }
 
 const REAL relax=25;
+=======
+    if( state_ )
+    {
+        tJUST_CONTROLLED_PTR< State > keepalive( state_ );
+        return state_->Think( maxStep );
+    }
+
+    return 10;
+}
+>>>>>>> MERGE-SOURCE
 
 void gAIPlayer::Timestep(REAL time){
-    if (!character)
+    if (!character_)
     {
         st_Breakpoint();
         return;
     }
 
+    const REAL relax=3;
+
     // don't think if the object is not up to date
     if ( Object() && Object()->LastTime() < time - EPS )
         return;
 
-    REAL ts=time-lastTime;
-    lastTime=time;
-
-    if (concentration < 0)
-        concentration = 0;
-
-    concentration += 4*(character->properties[AI_REACTION]+1) * ts/relax;
-    concentration=concentration/(1+ts/relax);
-
-    if (bool(Object()) && Object()->Alive() && nextTime<time){
+    REAL ts=time-lastTime_;
+    lastTime_=time;
+
+    concentration_ += (character_->properties[AI_REACTION]+1) * ts;
+    concentration_ = concentration_/(1+ts/relax);
+    if( concentration_ < 0 )
+    {
+        nextTime_ = time - concentration_ + .01;
+        return;
+    }
+
+    if (bool(Object()) && Object()->Alive() && nextTime_<time){
         gRandomController random( randomizer_ );
 
-        REAL nextthought=Think();
+        REAL target = (character_->properties[AI_REACTION]+1);
+        REAL safethought = 4 / (target + 3 * concentration_ );
+
+        REAL nextthought=Think( safethought );
         //    if (nextthought>.9) nextthought=REAL(.9);
 
-        if (nextthought<REAL(.6-concentration)) nextthought=REAL(.6-concentration);
-
-        nextTime=nextTime+nextthought;
-
-        //con << concentration << "\t" << nextthought << '\t' << ts << '\n';
-
-        if(.1+4*nextthought<1)
-            concentration*=REAL(.1+4*nextthought);
+        if( nextthought < -concentration_ )
+        {
+            nextthought = -concentration_;
+        }
+        nextTime_=nextTime_+nextthought;
+
+        //con << concentration_ << "\t" << nextthought << '\t' << ts << '\n';
     }
 }
 
@@ -3154,12 +3575,9 @@
 
 gAIPlayer::~gAIPlayer()
 {
-    target=NULL;
+    target_=NULL;
     ClearObject();
     tCHECK_DEST;
-
-    delete log;
-    log = NULL;
 }
 
 void gAIPlayer::ClearAll()

=== modified file 'src/tron/gAIBase.h'
--- src/tron/gAIBase.h	2011-11-23 15:32:48 +0000
+++ src/tron/gAIBase.h	2019-01-04 23:26:28 +0000
@@ -18,7 +18,7 @@
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
+5along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   
 ***************************************************************************
@@ -46,6 +46,7 @@
 
 namespace Game{ class AIPlayerSync; class AITeamSync; }
 
+<<<<<<< TREE
 typedef enum
 { AI_SURVIVE = 0,   // just try to stay alive
   AI_TRACE,         // trace a wall
@@ -56,6 +57,8 @@
 }
 gAI_STATE;
 
+=======
+>>>>>>> MERGE-SOURCE
 class gSimpleAI
 {
 public:
@@ -64,9 +67,9 @@
     }
 
     // do the thinking
-    inline REAL Think()
+    inline REAL Think( REAL maxStep )
     {
-        return DoThink();
+        return DoThink( maxStep );
     }
 
     virtual ~gSimpleAI();
@@ -74,7 +77,7 @@
     gCycle * Object(){ return object_; }
     void SetObject( gCycle * cycle ){ object_ = cycle; }
 protected:
-    virtual REAL DoThink() = 0;
+    virtual REAL DoThink( REAL maxStep ) = 0;
 private:
     tJUST_CONTROLLED_PTR< gCycle > object_;
 };
@@ -93,6 +96,7 @@
 
 class gAIPlayer: public ePlayerNetID{
     friend class gAITeam;
+<<<<<<< TREE
 
     tReproducibleRandomizer randomizer_;
 protected:
@@ -182,6 +186,18 @@
     virtual void ActOnData( ThinkDataBase & data );
 public:
     gAICharacter* Character() const {return character;}
+=======
+public:
+    //! set sight on target (side effects: switch state accordingly)
+    void SetTarget( eNetGameObject * target );
+
+    eNetGameObject const * GetTarget() const
+    {
+        return target_;
+    }
+
+    gAICharacter* Character() const {return character_;}
+>>>>>>> MERGE-SOURCE
 
     //	virtual void AddRef();
     //	virtual void Release();
@@ -212,13 +228,13 @@
 
     static void SetNumberOfAIs(int num, int minPlayers, int iq, int tries=3); // make sure this many AI players are in the game (with approximately the given IQ)
 
-    void ClearTarget(){target=NULL;}
+    void ClearTarget(){target_=NULL;}
 
     virtual void ControlObject(eNetGameObject *c){ ePlayerNetID::ControlObject( c ); simpleAI_ = NULL; }
     virtual void ClearObject(){ ePlayerNetID::ClearObject(); simpleAI_ = NULL; }
 
     // do some thinking. Return value: time to think again
-    virtual REAL Think();
+    virtual REAL Think( REAL maxStep );
 
     bool Alive(){
         return bool(Object()) && Object()->Alive();
@@ -255,6 +271,76 @@
     // void WriteSync( Game::AIPlayerSync & sync, bool init );
     //! returns the descriptor responsible for this class
     virtual nNetObjectDescriptorBase const & DoGetDescriptor() const;
+
+    // an AI state
+    class State: public tReferencable< State >
+    {
+    public:
+        State( gAIPlayer & player );
+        virtual ~State();
+
+        //! executes the state's work
+        virtual REAL Think( REAL maxStep ) = 0;
+    protected:
+        gAIPlayer & Parent(){ return parent_; }
+        gAIPlayer const & Parent() const { return parent_; }
+
+        gAINavigator & Navigator();
+        gAINavigator const & Navigator() const;
+
+        gAICharacter const & Character() const;
+    private:
+        gAIPlayer & parent_;
+    };
+
+    friend class State;
+
+    // state management
+    void SwitchToState( State * newState );
+    State * GetState() const{ return state_; }
+
+    // switch to survival state
+    void SwitchToSurvival();
+
+    // state for grinding at start
+    class StateGrind: public State
+    {
+    public:
+        enum Substate
+        {
+             AI_NONE = 0,
+             AI_GRIND_GRIND, // currently getting closer to teammate's wall
+             AI_GRIND_SPLIT_LEFT, AI_GRIND_SPLIT_RIGHT,  // split as soon as you overtake your teammate
+             AI_SUBSTATE_COUNT
+        };
+
+        StateGrind( gAIPlayer & player );
+        virtual ~StateGrind();
+
+        //! executes the state's work
+        virtual REAL Think( REAL maxStep );
+    };
+private:
+    tReproducibleRandomizer randomizer_;
+
+    gSimpleAI    * simpleAI_;
+    gAICharacter * character_; // our specification of abilities
+
+    // for all offensive modes:
+    nObserverPtr< eNetGameObject >  target_;  // the current victim
+
+    // basic thinking resource management
+    REAL lastTime_;
+    REAL nextTime_;
+    REAL concentration_;
+
+    //! navigator
+    std::auto_ptr< gAINavigator > navigator_;
+
+    //! state
+    tJUST_CONTROLLED_PTR< State > state_;
+
+    void CreateNavigator();
 };
 
 // the AI team
@@ -279,5 +365,4 @@
     virtual bool IsHuman() const { return false; } // does this team consist of humans?
 };
 
-
 #endif

=== added file 'src/tron/gAINavigator.cpp'
--- src/tron/gAINavigator.cpp	1970-01-01 00:00:00 +0000
+++ src/tron/gAINavigator.cpp	2019-01-04 23:26:28 +0000
@@ -0,0 +1,1803 @@
+/*
+
+*************************************************************************
+
+ArmageTron -- Just another Tron Lightcycle Game in 3D.
+Copyright (C) 2005  by 
+and the AA DevTeam (see the file AUTHORS(.txt) in the main source directory)
+
+**************************************************************************
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+  
+***************************************************************************
+
+*/
+
+#include "gAINavigator.h"
+
+#include "tRandom.h"
+#include "tSysTime.h"
+#include "tMath.h"
+
+#include "eGrid.h"
+
+#include "gCycle.h"
+#include "gWall.h"
+
+#ifndef HUGE
+#define HUGE 1e+38
+#endif
+
+gAINavigator::Settings::Settings()
+: newWallBlindness(-.1)
+, range( 1 )
+{}
+
+gAINavigator::Wish::Wish( gAINavigator const & idler )
+: turn(0)
+, maxDisadvantage( HUGE )
+{
+    gCycle & owner = *idler.Owner();
+    minDistance = owner.GetTurnDelay() * owner.Speed();
+}
+
+// *************************
+// * Sensors               *
+// *************************
+
+gAINavigator::Sensor::Sensor(gAINavigator & ai,const eCoord &start,const eCoord &d)
+: gSensor(ai.Owner(),start,d)
+, ai_( ai )
+, hitOwner_( 0 )
+, hitTime_ ( 0 )
+, hitDistance_( ai.Owner()->MaxWallsLength() )
+, lrSuggestion_( 0 )
+, windingNumber_( 0 )
+{
+    if ( hitDistance_ <= 0 )
+        hitDistance_ = ai.Owner()->GetDistance();
+}
+
+/*
+// do detection and additional stuff
+void detect( REAL range )
+{
+gSensor::detect( range );
+}
+*/
+
+void gAINavigator::Sensor::PassEdge(const eWall *ww,REAL time,REAL a,int r)
+{
+    try{
+        gSensor::PassEdge(ww,time,a,r);
+    }
+    catch( eSensorFinished & e )
+    {
+        if ( DoExtraDetectionStuff() )
+            throw;
+    }
+}
+
+extern REAL sg_cycleRubberWallShrink;
+
+bool gAINavigator::Sensor::DoExtraDetectionStuff()
+{
+    // move towards the beginning of a wall
+    lrSuggestion_ = -lr;
+
+    switch ( type )
+    {
+    case gSENSOR_NONE:
+    case gSENSOR_RIM:
+        lrSuggestion_ = 0;
+        return true;
+    default:
+        // unless it is an enemy, follow his wall instead (uncomment for a nasty cowardy campbot)
+        // lrSuggestion *= -1;
+    case gSENSOR_SELF:
+    {
+        // determine whether we're hitting the front or back half of his wall
+        if ( !ehit )
+            return true;
+        eWall * wall = ehit->GetWall();
+        if ( !wall )
+            return true;
+        gPlayerWall * playerWall = dynamic_cast< gPlayerWall * >( wall );
+        if ( !playerWall )
+            return true;
+        hitOwner_ = playerWall->Cycle();
+        if ( !hitOwner_ )
+            return true;
+
+        // gAINavigator & enemyChatBot = Get( hitOwner_ );
+
+        REAL wallAlpha = playerWall->Edge()->Ratio( before_hit );
+        // that's an unreliable source
+        if ( wallAlpha < 0 )
+            wallAlpha = 0;
+        if ( wallAlpha > 1 )
+            wallAlpha = 1;
+        hitDistance_   = hitOwner_->GetDistance() - playerWall->Pos( wallAlpha );
+        hitTime_       = playerWall->Time( wallAlpha );
+        windingNumber_ = playerWall->WindingNumber();
+
+        // don't see new walls
+        if ( hitTime_ > hitOwner_->LastTime() - ai_.settings_.newWallBlindness && hitOwner_ != owned )
+        {
+            ehit = NULL;
+            hit = 1.01;
+            return false;
+        }
+
+        // don't see vanishing walls
+        {
+            // TODO: this is a bit wrong in the face of diagonals and quantizized driving directions.
+            REAL distanceToHit = dir.Norm() * hit;
+            REAL rubberDistance = 0;
+            
+            // assume we can waste half our rubber waiting for the wall to get lost
+            {
+                REAL rubberGranted, rubberEffectiveness;
+                sg_RubberValues( ai_.owner_->Player(), ai_.owner_->Speed(), rubberGranted, rubberEffectiveness );
+                rubberDistance = ( rubberGranted - ai_.owner_->GetRubber() ) * .5;
+            }
+            if( type == gSENSOR_SELF )
+            {
+                rubberDistance *= sg_cycleRubberWallShrink;
+            }
+
+            REAL timeToHit = distanceToHit/ai_.owner_->Speed();
+            if( !playerWall->IsDangerous( wallAlpha, ai_.owner_->LastTime() + timeToHit ) )
+            {
+                // wall will be gone until we get there. ignore.
+                ehit = false;
+                hit = 1.01;
+                return false;
+            }
+        }
+
+        // REAL cycleDistance = hitOwner_->GetDistance();
+
+        // REAL wallStart = 0;
+
+        /*
+          if ( gCycle::WallsLength() > 0 )
+          {
+          wallStart = cyclePos - playerWall->Cycle()->ThisWallsLength();
+          if ( wallStart < 0 )
+          wallStart = 0;
+          }
+        */
+    }
+    }
+
+    return true;
+}
+
+// check how far the hit wall extends straight into the given direction
+REAL gAINavigator::Sensor::HitWallExtends( eCoord const & dir, eCoord const & origin )
+{
+    if ( !ehit || !ehit->Other() )
+    {
+        return 0;
+    }
+
+    REAL ret = -HUGE;
+    eCoord ends[2] = { *ehit->Point(), *ehit->Other()->Point() };
+    for ( int i = 1; i>=0; --i )
+    {
+        REAL newRet = eCoord::F( dir, ends[i]-origin );
+        if ( newRet > ret )
+            ret = newRet;
+    }
+
+    return ret;
+}
+
+// *************************
+// * Controllers           *
+// *************************
+
+//!@param cycle  the cycle to execute the action
+//!@param dir    direction to turn into
+void gAINavigator::CycleController::Turn( gCycle & cycle , int dir    )
+{
+}
+
+//!@param cycle  the cycle to execute the action
+//!@param brake  whether to brake or not
+void gAINavigator::CycleController::Brake( gCycle & cycle, bool brake )
+{
+}
+
+gAINavigator::CycleController::~CycleController(){}
+
+void gAINavigator::CycleControllerBasic::Turn( gCycle & cycle , int dir    )
+{
+    cycle.Turn( dir );
+}
+
+void gAINavigator::CycleControllerBasic::Brake( gCycle & cycle, bool brake )
+{
+    cycle.Act( &gCycle::s_brake, brake ? 1 : -1 );
+}
+
+gAINavigator::CycleControllerBasic::~CycleControllerBasic(){}
+
+void gAINavigator::CycleControllerAction::Turn( gCycle & cycle , int dir    )
+{
+    cycle.Act( dir > 0 ? &gCycle::se_turnRight : &gCycle::se_turnLeft, 1 );
+}
+
+void gAINavigator::CycleControllerAction::Brake( gCycle & cycle, bool brake )
+{
+    cycle.Act( &gCycle::s_brake, brake ? 1 : -1 );
+}
+
+gAINavigator::CycleControllerAction::~CycleControllerAction(){}
+
+// *************************
+// * Path                  *
+// *************************
+
+void gAINavigator::Path::Fill( gAINavigator const & navigator, Sensor const & left, Sensor const & right, eCoord const & shortDir, eCoord const & longDir, int turn )
+{
+    // check orientation
+    tASSERT( left.Direction() * right.Direction() >= 0 );
+
+    this->distance = navigator.Distance( left, right );
+    this->shortTermDirection = shortDir;
+    this->longTermDirection = longDir;
+
+    this->left.FillFrom( left );
+    this->right.FillFrom( right );
+
+    // get width by checking the edges (there's a better way for sure, but for now, this suffices)
+    eHalfEdge const * leftEdge = left.ehit;
+    eHalfEdge const * rightEdge = right.ehit;
+    width = HUGE;
+    if( leftEdge && rightEdge )
+    {
+        // get distance of the endpoints of the edges to the extended
+        // line of the other edge
+        eCoord const & leftBeg = *leftEdge->Point();
+        eCoord leftDir = leftEdge->Vec();
+        eCoord const & rightBeg = *rightEdge->Point();
+        eCoord rightDir = rightEdge->Vec();
+        eCoord offset = leftBeg - rightBeg;
+
+        REAL widthLeftBeg = offset * rightDir;
+        REAL widthLeftEnd = widthLeftBeg + leftDir * rightDir;
+        REAL widthRightBeg = -(offset * leftDir);
+        REAL widthRightEnd = widthRightBeg + rightDir * leftDir;
+
+        // take the minimum of those distances without sign change
+        width = this->left.distance + this->right.distance;
+        if ( widthLeftBeg * widthLeftEnd >= 0 )
+        {
+            width = tMin( width, tMin( fabs(widthLeftBeg), fabs(widthLeftEnd) )/rightDir.Norm() );
+        }
+        if ( widthRightBeg * widthRightEnd >= 0 )
+        {
+            width = tMin( width, tMin( fabs(widthRightBeg), fabs(widthRightEnd) )/leftDir.Norm() );
+        }
+    }
+
+    this->turn = turn;
+    this->driveOn = 0;
+}
+
+//!@param controller the controller to use for the execution
+//!@param cycle      the cycle to execute the action
+//!@param maxStep    maximal timestep the caller suggests
+REAL gAINavigator::Path::Take( CycleController & controller, gCycle & cycle, REAL maxStep )
+{
+    if( driveOn > 0 )
+    {
+        REAL driveOnTime = driveOn/cycle.Speed();
+        if( maxStep > driveOnTime )
+        {
+            maxStep = driveOnTime;
+        }
+        // driveOn = 0;
+        return maxStep;
+    }
+
+    if( turn != 0 )
+    {
+        if( !cycle.CanMakeTurn( turn ) )
+        {
+            return driveOn = cycle.GetNextTurn( turn ) - cycle.LastTime();
+        }
+
+        controller.Turn( cycle, turn );
+    }
+    
+    return maxStep;
+}
+
+gAINavigator::Path::~Path()
+{
+}
+
+gAINavigator::Path::Path()
+: distance(HUGE)
+, immediateDistance(HUGE)
+, width(HUGE)
+, shortTermDirection(0,0)
+, longTermDirection(0,0)
+, followedSince(0)
+, turn(0)
+, driveOn(0)
+{
+}
+
+// *************************
+// * PathGroup             *
+// *************************
+
+
+//!@return the number of paths accessible via GetPath
+int gAINavigator::PathGroup::GetPathCount() const
+{
+    return PATH_COUNT;
+}
+
+//!@param id  the ID of the path, between 0 and GetPathCount()-1
+//!@return    the path of given ID
+gAINavigator::Path const & gAINavigator::PathGroup::GetPath( int id ) const
+{
+    tASSERT( id >= 0 && id < PATH_COUNT );
+    return paths[ id ];
+}
+
+//!@param controller the controller to use for the execution
+//!@param cycle      the cycle to execute the action
+//!@param id         the ID of the path, between 0 and GetPathCount()-1
+//!@param maxStep    maximal timestep the caller suggests
+REAL gAINavigator::PathGroup::TakePath( CycleController & controller, gCycle & cycle, int id, REAL maxStep )
+{
+    // save plan
+    last = GetPath( id );
+
+    // execute plan
+    REAL ret = last.Take( controller, cycle, maxStep );
+
+    // clear all paths
+    for( int i = GetPathCount()-1; i >= 0; --i )
+    {
+        Path & path = AccessPath( i );
+        path.left = path.right = WallHug();
+        path.distance = path.immediateDistance = HUGE;
+        path.followedSince = 0;
+        path.driveOn = 0;
+    }
+
+    last.followedSince++;
+
+    // check whether execution was successful
+    if( last.driveOn > 0 )
+    {
+        // turn was not executed. memorize that it was a good choilce
+        paths[ id ].followedSince = last.followedSince;
+        return ret;
+    }
+
+    // transfer last use stats
+    switch( id )
+    {
+    case PATH_UTURN_LEFT:
+        paths[ PATH_UTURN_LEFT ].followedSince = last.followedSince;
+        paths[ PATH_TURN_LEFT  ].followedSince = last.followedSince;
+        break;
+    case PATH_UTURN_RIGHT:
+        paths[ PATH_UTURN_RIGHT ].followedSince = last.followedSince;
+        paths[ PATH_TURN_RIGHT  ].followedSince = last.followedSince;
+        break;
+    case PATH_ZIGZAG_LEFT:
+        if ( last.driveOn )
+        {
+            paths[ PATH_TURN_LEFT  ].followedSince = last.followedSince;
+            paths[ PATH_ZIGZAG_LEFT].followedSince = last.followedSince;
+        }
+        else
+        {
+            paths[ PATH_STRAIGHT   ].followedSince = last.followedSince;
+            paths[ PATH_TURN_RIGHT ].followedSince = last.followedSince;
+        }
+        break;
+    case PATH_ZIGZAG_RIGHT:
+        if ( last.driveOn )
+        {
+            paths[ PATH_TURN_RIGHT  ].followedSince = last.followedSince;
+            paths[ PATH_ZIGZAG_RIGHT].followedSince = last.followedSince;
+        }
+        else
+        {
+            paths[ PATH_STRAIGHT  ].followedSince = last.followedSince;
+            paths[ PATH_TURN_LEFT ].followedSince = last.followedSince;
+        }
+        break;
+    case PATH_TURN_LEFT:
+    case PATH_STRAIGHT:
+    case PATH_TURN_RIGHT:
+        paths[ PATH_STRAIGHT ].followedSince = last.followedSince;
+        break;
+    }
+
+    return ret;
+}
+
+//!@return    the path taken last time
+gAINavigator::Path const & gAINavigator::PathGroup::GetLastPath() const
+{
+    return last;
+}
+
+gAINavigator::PathGroup::PathGroup()
+{
+    // pretend we went straight
+    paths[ PATH_STRAIGHT ].followedSince = 100;
+}
+gAINavigator::PathGroup::~PathGroup(){}
+
+//!@param id  the ID of the path, between 0 and GetPathCount()-1
+//!@return    the path of given ID
+gAINavigator::Path & gAINavigator::PathGroup::AccessPath( int id )
+{
+    tASSERT( id >= 0 && id < PATH_COUNT );
+    return paths[ id ];
+}
+
+// *************************
+// * Evaluation            *
+// *************************
+
+gAINavigator::PathEvaluation::PathEvaluation() : veto( false ), score( 0 ), nextThought( HUGE ){}
+
+//!@param path        the path to evaluate
+//!@param evaluation  place to store the result
+void gAINavigator::PathEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const{}
+gAINavigator::PathEvaluator::~PathEvaluator(){}
+
+//!@param path        the path to evaluate
+//!@param evaluation  place to store the result
+void gAINavigator::SuicideEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    REAL speed = cycle_.Speed();
+    REAL referenceDistance = speed*timeFrame_;
+    REAL distance = path.distance;
+    if( path.immediateDistance < distance )
+    {
+        distance = path.immediateDistance;
+    }
+
+    // check if this is the forward path
+    if( !emergency_ &&
+        eCoord::F( path.shortTermDirection, cycle_.Direction() ) > .99 )
+    {
+        distance += cycle_.GetTurnDelay()*speed;
+    }
+
+    REAL timeToLive = distance/referenceDistance;
+    evaluation.score = Adjust(timeToLive/100);
+    if( timeToLive < 1 )
+    {
+        evaluation.veto = true;
+    }
+}
+
+bool gAINavigator::SuicideEvaluator::emergency_ = false;
+
+void gAINavigator::SuicideEvaluator::SetEmergency( bool emergency )
+{
+    emergency_ = emergency;
+}
+
+gAINavigator::SuicideEvaluator::SuicideEvaluator( gCycle const & cycle ): cycle_( cycle ), timeFrame_( cycle.GetTurnDelay() ){}
+gAINavigator::SuicideEvaluator::SuicideEvaluator( gCycle const & cycle, REAL timeFrame ): cycle_( cycle ), timeFrame_( timeFrame ){}
+gAINavigator::SuicideEvaluator::~SuicideEvaluator(){}
+
+//!@param path        the path to evaluate
+//!@param evaluation  place to store the result
+void gAINavigator::TrapEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    if( space_ <= 0 )
+    {
+        return;
+    }
+    evaluation.score = Adjust( path.distance/space_ );
+    REAL trapLength = cycle_.GetTurnDelay() * cycle_.Speed();
+    if( path.distance < space_ && path.left.owner == path.right.owner && path.left.owner && 
+        ( path.immediateDistance < trapLength || ( path.left.distance < trapLength && path.right.distance < trapLength ) || path.left.owner == &cycle_ ) )
+    {
+        evaluation.veto = true;
+    }
+}
+
+gAINavigator::TrapEvaluator::TrapEvaluator( gCycle const & cycle )
+: cycle_( cycle )
+{
+    space_ = .25 * cycle.ThisWallsLength();
+}
+
+gAINavigator::TrapEvaluator::TrapEvaluator( gCycle const & cycle, REAL space )
+: cycle_( cycle )
+, space_( space ){}
+gAINavigator::TrapEvaluator::~TrapEvaluator(){}
+
+void gAINavigator::RandomEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    static tReproducibleRandomizer randomizer;
+    evaluation.score = randomizer.Get() * 100;
+}
+
+gAINavigator::RandomEvaluator::RandomEvaluator(){}
+gAINavigator::RandomEvaluator::~RandomEvaluator(){}
+
+gAINavigator::CowardEvaluator::CowardEvaluator( gCycle const & cycle ): cycle_( cycle ){}
+gAINavigator::CowardEvaluator::~CowardEvaluator(){}
+
+void gAINavigator::CowardEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    evaluation.score = 100;
+    if( path.left.owner || path.right.owner )
+    {
+        REAL turnDelay = cycle_.GetTurnDelay() * cycle_.Speed();
+        if( path.width < turnDelay * 2 )
+        {
+            evaluation.score = tMax(0,(path.width/turnDelay)-1);
+        }
+        {
+            if(  path.left.owner && path.left.owner->Alive() && path.left.owner->Team() != cycle_.Team() && path.left.lr == 1 )
+            {
+                evaluation.score = 0;
+            }
+            if( path.right.owner && path.right.owner->Alive() && path.right.owner->Team() != cycle_.Team() && path.right.lr == -1 )
+            {
+                evaluation.score = 0;
+            }
+        }
+    }
+}
+
+gAINavigator::TunnelEvaluator::TunnelEvaluator( gCycle const & cycle ): cycle_( cycle ){}
+gAINavigator::TunnelEvaluator::~TunnelEvaluator(){}
+
+void gAINavigator::TunnelEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    evaluation.score = 100;
+
+    // check for tunnel situation
+    if( path.left.owner && path.right.owner && path.left.owner != path.right.owner )
+    {
+        // the narrower, the worse the score gets
+        REAL referenceWidth = cycle_.GetTurnDelay() * cycle_.Speed() * 2;
+        if( path.width < referenceWidth )
+        {
+            REAL w = (path.width/referenceWidth - .25)/.75;
+            w = tMin(0,w);
+            evaluation.score = 100*w*w;
+        }
+    }
+}
+
+gAINavigator::SpaceEvaluator::SpaceEvaluator( gCycle const & cycle )
+: referenceDistance_( cycle.MaxWallsLength() )
+{
+    if( referenceDistance_ <= 0 )
+    {
+        referenceDistance_ = cycle.GetDistance() + cycle.Speed() * 5;
+    }
+}
+
+gAINavigator::SpaceEvaluator::SpaceEvaluator( REAL referenceDistance )
+: referenceDistance_( referenceDistance )
+{}
+
+void gAINavigator::SpaceEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    evaluation.score = Adjust(path.distance/referenceDistance_);
+}
+
+gAINavigator::SpaceEvaluator::~SpaceEvaluator(){}
+
+//!@param path        the path to evaluate
+//!@param evaluation  place to store the result
+void gAINavigator::PlanEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    evaluation.score = Adjust( path.followedSince/3.0 );
+}
+
+gAINavigator::PlanEvaluator::~PlanEvaluator(){}
+
+//!@param paths the path group to evaluate
+gAINavigator::EvaluationManager::EvaluationManager( PathGroup & paths )
+: paths_( paths )
+, bestPath_( -1 )
+{
+    // evaluations_.reserve( paths.GetPathCount() );
+    for( int i = 0; i < paths.GetPathCount(); ++i )
+    {
+        //evaluations_.push_back( PathEvaluation() );
+
+        // store preliminary 'best' path
+        // if( paths.GetPath( i ).followedSince )
+        // {
+        // bestPath_ = i;
+        // }
+    }
+}
+        
+//! evaluate a path.
+void gAINavigator::RubberEvaluator::Evaluate( Path const & path, PathEvaluation & evaluation ) const
+{
+    // rubber that is about to get burned
+    REAL burn = rubberLeft_ - path.immediateDistance;
+    if( burn < 0 )
+    {
+        burn = 0;
+    }
+    if( burn > maxRubber_ )
+    {
+        burn = maxRubber_;
+    }
+    evaluation.score = ( 1 - burn/maxRubber_ ) * 100;
+}
+
+gAINavigator::RubberEvaluator::RubberEvaluator( gCycle const & cycle )
+{
+    Init( cycle, cycle.GetTurnDelay() );
+}
+
+gAINavigator::RubberEvaluator::RubberEvaluator( gCycle const & cycle, REAL maxTime )
+{
+    Init( cycle, maxTime );
+}
+
+gAINavigator::RubberEvaluator::~RubberEvaluator()
+{
+}
+
+void gAINavigator::RubberEvaluator::Init( gCycle const & cycle, REAL maxTime )
+{
+    // compensate for the addition of rubber in the stored sensor distances
+    REAL rubberGranted, rubberEffectiveness;
+    REAL speed = cycle.Speed();
+    sg_RubberValues( cycle.Player(), speed, rubberGranted, rubberEffectiveness );
+    REAL rubberLeft = ( rubberGranted - cycle.GetRubber() )*rubberEffectiveness;
+    maxRubber_  = maxTime * speed;
+
+    // account for inevitable loss
+    rubberLeft_ = rubberLeft + maxRubber_;
+
+    if( maxRubber_ > rubberLeft )
+    {
+        maxRubber_ = rubberLeft;
+    }
+
+    if( maxRubber_ < EPS )
+    {
+        maxRubber_ = EPS;
+    }
+}
+
+// *************************
+// * FollowEvaluator      *
+// *************************
+
+gAINavigator::FollowEvaluator::FollowEvaluator( gCycle const & cycle ): cycle_( cycle ), blocker_( 0 ), blockedBySelf_( false )
+{
+}
+
+gAINavigator::FollowEvaluator::~FollowEvaluator()
+{
+}
+
+//!@ param direction            direction to turn in
+//!@ param targetVelocity       velocity of the target
+//!@ param targetPosition       current position of the target relative to cycle
+//!@ param data                 solution filled in
+void gAINavigator::FollowEvaluator::SolveTurn( int direction, eCoord const & targetVelocity, eCoord const & targetPosition, SolveTurnData & data )
+{
+    eCoord velocityDifference = cycle_.Speed() * cycle_.Direction() - targetVelocity;
+
+    // get the velocity after the turn
+    int winding = cycle_.WindingNumber();
+    cycle_.Grid()->Turn( winding, direction );
+    data.turnDir = cycle_.Grid()->GetDirection( winding );
+    eCoord turnVelocityDifference = data.turnDir * cycle_.Speed() * GetTurnSpeedFactor() - targetVelocity;
+        
+    // some little algebra to solve velocityDifference * turnTime + turnVelocityDifference * Quality == targetPosition
+    REAL determinant = turnVelocityDifference * velocityDifference;
+    if( fabs( determinant ) < EPS )
+    {
+        // division by zero error, problem is not well defined. approximate.
+        data.turnTime = 0;
+
+        REAL velocityDifferenceLen = velocityDifference.NormSquared();
+        if( velocityDifferenceLen > EPS )
+        {
+            data.turnTime = eCoord::F( velocityDifference, targetPosition )/velocityDifferenceLen;
+        }
+    }
+    else
+    {
+        // the better case
+        data.turnTime = ( turnVelocityDifference * targetPosition )/determinant;
+    }
+
+    // but halt, clamp it, we can't rewind (we've gone too far)
+    if ( data.turnTime < 0 )
+    {
+        data.turnTime = 0;
+    }
+
+    // fetch an alternative turn direction (the same as before with 4 axes)
+    // so that we have a guaranteed nonnegative positive quality outcome among the two
+    winding = cycle_.WindingNumber();
+    cycle_.Grid()->Turn( winding, -direction );
+    eCoord antiTurnDir = -cycle_.Grid()->GetDirection( winding );
+
+    // and handle the rest primitively via dot product
+    data.quality = eCoord::F( antiTurnDir, targetPosition - velocityDifference * data.turnTime );
+    data.quality /= antiTurnDir.Norm();
+}
+
+//! sensor picking up several walls between cycle and target
+class gTargetSensor:public gSensor
+{
+public:
+    int lastOwnLR; //!< the last LR value of a hit with an own wall
+    tCHECKED_PTR_CONST(eHalfEdge) lastOwnEHit; //!< the edge hit there
+    
+    gTargetSensor(eGameObject const * o,const eCoord &start,const eCoord &d)
+    :gSensor(o,start,d), lastOwnLR(0), lastOwnEHit(0) {}
+
+    virtual void PassEdge(const eWall *w,REAL time,REAL a,int i)
+    {
+        try
+        {
+            gSensor::PassEdge( w, time, a, i );
+        }
+        catch( eSensorFinished & e )
+        {
+            if( type == gSENSOR_SELF )
+            {
+                // copy the last own wall we see
+                lastOwnLR = lr;
+                lastOwnEHit = ehit;
+                ehit = 0;
+            }
+            else
+            {
+                throw;
+            }
+        }
+    }
+};
+
+void gAINavigator::FollowEvaluator::SetTarget( eCoord const & target, eCoord const & velocity )
+{
+    // determine direction to center
+    toTarget_ = target - cycle_.Position();
+
+    blocker_ = 0;
+    blockedBySelf_ = false;
+
+    // check whether the path is blocked
+    gTargetSensor sensor( &cycle_, cycle_.Position(), toTarget_ );
+    sensor.detect( .99 );
+
+    if( sensor.type != gSENSOR_NONE )
+    {
+        if( sensor.lastOwnEHit )
+        {
+            gPlayerWall const * ownWall = dynamic_cast< gPlayerWall const * >( sensor.lastOwnEHit->GetWall() );
+            if ( ownWall )
+            {
+                blocker_ = ownWall->Cycle();
+                blockedBySelf_ = true;
+                tASSERT( blocker_ == &cycle_ );
+                if( ownWall->Pos(.5) > blocker_->GetDistance() - blocker_->ThisWallsLength()*.9 )
+                {
+                    int lr = toTarget_ * ownWall->Vec() > 0 ? 1 : -1;
+
+                    // if we block our own recent path, turn around
+                    if( ownWall->Pos(.5) > blocker_->GetDistance() - blocker_->ThisWallsLength()*.75 )
+                    {
+                        lr *= -1;
+                    }
+
+                    int winding = cycle_.WindingNumber();
+                    cycle_.Grid()->Turn( winding, lr );
+                    toTarget_ = cycle_.Grid()->GetDirection( winding );
+                    return;
+                }
+            }
+        }
+        else if ( sensor.ehit )
+        {
+            gPlayerWall const * w = dynamic_cast< gPlayerWall const * >( sensor.ehit->GetWall() );
+            if ( w )
+            {
+                blocker_ = w->Cycle();
+
+                // just follow enemy wall in the inverse direction, but keep an eye on the target
+                toTarget_.Normalize();
+                eCoord follow = - w->Vec();
+                follow.Normalize();
+
+                // hah, but if we're faster than the other guy, try to overtake him.
+                if( blocker_->Speed() < cycle_.Speed() )
+                {
+                    follow *= -1;
+                }
+
+                toTarget_ += follow * .9;
+                toTarget_.Normalize();
+                return;
+            }
+        }
+    }
+
+    // determine next possible left or right directions
+    SolveTurnData left, right;
+    SolveTurn( -1, velocity, toTarget_, left );
+    SolveTurn( 1,  velocity, toTarget_, right );
+
+    REAL quality = 0;
+
+    // pick the best one
+    if( left.quality > right.quality )
+    {
+        quality   = left.quality;
+        toTarget_ = left.turnDir;
+        turnTime_ = left.turnTime;
+    }
+    else
+    {
+        quality   = right.quality;
+        toTarget_ = right.turnDir;
+        turnTime_ = right.turnTime;
+    }
+
+    if( turnTime_ < 0 )
+    {
+        turnTime_ = HUGE;
+    }
+    else
+    {
+        // bend direction into current direction
+        toTarget_.Normalize();
+        toTarget_ += cycle_.Direction()*turnTime_*20;
+    }
+
+    toTarget_.Normalize();
+}
+
+void gAINavigator::FollowEvaluator::Evaluate( gAINavigator::Path const & path, gAINavigator::PathEvaluation & evaluation ) const
+{
+    eCoord pathDir = path.shortTermDirection;
+    REAL f = eCoord::F( toTarget_, pathDir );
+    if( f > 0 && f*f > .5 * pathDir.NormSquared() )
+    {
+        evaluation.nextThought = turnTime_;
+    }
+
+    evaluation.score = 50 * f + 50;
+}
+
+//!@param evaluator  evaluator doing the core work
+//!@param scale      weight factor for that work
+void gAINavigator::EvaluationManager::Evaluate( PathEvaluator const & evaluator, BlendMode mode, REAL scale, REAL offset )
+{
+    REAL bestScore = -HUGE;
+    REAL bestDistance = HUGE;
+        
+    for( int i = paths_.GetPathCount()-1; i >= 0 ; --i )
+    {
+        PathEvaluation & store = evaluations_[i];
+        if( store.veto )
+        {
+            continue;
+        }
+
+        PathEvaluation evaluation;
+        Path const & path = paths_.GetPath(i);
+        evaluator.Evaluate( path, evaluation );
+        evaluation.score = evaluation.score * scale + offset;
+
+        // update stored evaluation
+        switch ( mode )
+        {
+        case BLEND_ADD:
+            store.score += evaluation.score;
+            break;
+        case BLEND_MULT:
+            store.score *= evaluation.score;
+            break;
+        case BLEND_MAX:
+            if( evaluation.score > store.score )
+            {
+                store.score = evaluation.score;
+            }
+            break;
+        case BLEND_MIN:
+            if( evaluation.score < store.score )
+            {
+                store.score = evaluation.score;
+            }
+            break;
+        }
+
+        if ( evaluation.nextThought < store.nextThought )
+        {
+            store.nextThought = evaluation.nextThought;
+        }
+
+        if ( evaluation.veto )
+        {
+            store.veto = true;
+        }
+        else if ( bestPath_ < 0 || store.score > bestScore || ( store.score == bestScore && path.distance < bestDistance ) )
+        {
+            bestPath_ = i;
+            bestScore = store.score;
+            bestDistance = path.distance;
+        }
+    }
+
+    if( bestPath_ < 0 )
+    {
+#ifdef DEBUG
+        con << "PANIC!\n";
+#endif
+
+        // PANIC. No path ever was not vetoed. Oh well. Take the best anyway and be done.
+        for( int i = paths_.GetPathCount()-1; i >= 0 ; --i )
+        {
+            PathEvaluation & store = evaluations_[i];
+            Path const & path = paths_.GetPath(i);
+            if ( bestPath_ < 0 || store.score > bestScore || ( store.score == bestScore && path.distance < bestDistance ) )
+            {
+                bestPath_ = i;
+                bestScore = store.score;
+                bestDistance = path.distance;
+            }
+        }
+    }
+}
+
+//! reset scores, but don't forget veto
+void gAINavigator::EvaluationManager::Reset()
+{
+    for( int i = paths_.GetPathCount()-1; i >= 0; --i )
+    {
+        evaluations_[i].score = 0;
+    }
+}
+
+//!@param controller   controller issuing the commands
+//!@param cycle        cycle getting controlled
+//!@param maxStep      suggestion for next timestep
+REAL gAINavigator::EvaluationManager::Finish( CycleController & controller, gCycle & cycle, REAL maxStep ){
+    if( bestPath_ >= 0 )
+    {
+        REAL thisMaxStep = evaluations_[ bestPath_ ].nextThought;
+        if( maxStep > thisMaxStep )
+        {
+            maxStep = thisMaxStep;
+        }
+        return paths_.TakePath( controller, cycle, bestPath_, maxStep );
+    }
+    else
+    {
+        return maxStep;
+    }
+}
+
+gAINavigator::gAINavigator( gCycle * owner )
+: lastTurn_( 0 )
+, nextTurn_ ( 0 )
+, turnedRecently_ ( 0 )
+, owner_ ( owner )
+{
+}
+
+gAINavigator::WallHug::WallHug()
+: owner ( NULL ), lastTimeSeen ( 0 ), distance( HUGE ), lr( 0 )
+{
+}
+
+void gAINavigator::WallHug::FillFrom( Sensor const & sensor )
+{
+    owner = sensor.hitOwner_;
+    lr = sensor.lr;
+    hitDistance = sensor.hitDistance_;
+    distance = sensor.hit * sensor.Direction().Norm();
+    if( owner )
+    {
+        lastTimeSeen = owner->LastTime();
+    }
+}
+
+// determines the distance between two sensors; the size should give the likelyhood
+// to survive if you pass through a gap between the two selected walls
+REAL gAINavigator::Distance( Sensor const & a, Sensor const & b ) const
+{
+    // make sure a is left from b
+    if ( a.Direction() * b.Direction() < 0 )
+        return Distance( b, a );
+
+    bool self = a.type == gSENSOR_SELF || b.type == gSENSOR_SELF;
+    bool rim  = a.type == gSENSOR_RIM || b.type == gSENSOR_RIM;
+
+    // some big distance to return if we don't know anything better
+    REAL bigDistance = owner_->MaxWallsLength();
+    if ( bigDistance <= 0 )
+        bigDistance = owner_->GetDistance();
+
+    REAL totallyFree = bigDistance * 8;
+    REAL halfFree    = bigDistance * 6;
+    REAL rimTunnel   = bigDistance * 4;
+    REAL tunnel      = bigDistance * 2;
+
+    if ( a.type == gSENSOR_NONE || b.type == gSENSOR_NONE )
+    {
+        // empty space! Woo!
+        if ( a.type == gSENSOR_NONE && b.type == gSENSOR_NONE )
+        {
+            // totally empty space! groovy!
+            return totallyFree;
+        }
+        else
+        {
+            return halfFree;
+        }
+    }
+    else if ( a.hitOwner_ != b.hitOwner_ )
+    {
+        // different owners? Great, there has to be a way through!
+        if ( rim )
+        {
+            if ( !self )
+            {
+                // we love going between the rim and enemies
+                return rimTunnel;
+            }
+            else
+            {
+                // we don't love going between own wall and rim
+                return bigDistance * .001 + ( a.before_hit - b.before_hit).Norm();
+            }
+        }
+
+        if ( self )
+        {
+            REAL trapFactor = .5;
+            if ( a.type == gSENSOR_SELF && a.lr == +1 )
+            {
+                // we're trapping another player and us with him. bad idea.
+                return a.hitDistance_ * trapFactor;
+            }
+            if ( b.type == gSENSOR_SELF && b.lr == -1 )
+            {
+                return b.hitDistance_ * trapFactor;
+            }
+        }
+
+        return tunnel;
+    }
+    else if ( rim )
+    {
+        // at least one rim wall? Take the distance between the hit positions.
+        return ( a.before_hit - b.before_hit).Norm();
+    }
+    else if ( a.lr != b.lr )
+    {
+        // well, the longer the wall segment between the two points, the better.
+        return fabsf( a.hitDistance_ - b.hitDistance_ ) * 2;
+    }
+
+    // default: hit distance
+    return ( a.before_hit - b.before_hit).Norm();
+}
+
+bool gAINavigator::CanMakeTurn( uActionPlayer * action )
+{
+    return owner_->CanMakeTurn( ( action == &gCycle::se_turnRight ) ? 1 : -1 );
+}
+
+//!@return group of future paths
+gAINavigator::PathGroup & gAINavigator::GetPaths()
+{
+    return paths_;
+}
+
+// check whether two sensors effecively hit the same wall
+static inline bool sg_SameWall( gAINavigator::Sensor const & a,
+                                gAINavigator::Sensor const & b )
+{
+    if( a.ehit == b.ehit )
+    {
+        return true;
+    }
+    if( a.hitOwner_ != b.hitOwner_ )
+    {
+        return false;
+    }
+    if( b.hit == 0 && a.hit != 0 )
+    {
+        return false;
+    }
+
+    REAL ratio = a.hit/b.hit;
+    if( ratio < .99 || ratio > 1.01 )
+    {
+        return false;
+    }
+
+    return true;
+}
+
+// generates immediate distance data from sensor
+static void sg_AddSensor( gAINavigator::Path & path, gAINavigator::Sensor const & sensor, REAL range, REAL rubber )
+{
+    REAL r = path.distance;
+    if( sensor.type != gSENSOR_NONE )
+    {
+        // check for the direct problem that driving in that direction causes: we're about to hit a wall,
+        // and rubber is going to run out eventually.
+        r  = sensor.hit * range + rubber;
+    }
+
+    if( r < path.immediateDistance )
+    {
+        path.immediateDistance = r;
+    }
+}
+
+// interpolates gaps of sensor data
+static void sg_FillSensorGap( gAINavigator::Sensor const & left, gAINavigator::Sensor const & right, gAINavigator::Sensor & gap )
+{
+    // check orientation
+    tASSERT( left.Direction() * right.Direction() >= 0 );
+
+    if( gap.type == gSENSOR_NONE )
+    {
+        // do left and right sensors fit?
+        if ( left.type != gSENSOR_NONE &&
+             left.type == right.type &&
+             left.lr  == right.lr &&
+             left.hitOwner_ == right.hitOwner_ )
+        {
+            gap.type = left.type;
+            gap.lr = left.lr;
+            gap.hitOwner_ = left.hitOwner_;
+            gap.hitTime_  = ( left.hitTime_ + right.hitTime_ )/2;
+            gap.hitDistance_  = ( left.hitDistance_ + right.hitDistance_ )/2;
+            gap.hit = 1.0;
+
+            return;
+        }
+        
+        // is there an enemy that may block?
+        if( left.type == gSENSOR_ENEMY && left.lr == 1 )
+        {
+            gap.type = left.type;
+            gap.lr = left.lr;
+            gap.hitOwner_ = left.hitOwner_;
+            gap.hitTime_  = left.hitTime_;
+            gap.hitDistance_  = 0;
+            gap.hit = left.hitDistance_/gap.Direction().Norm();
+        }
+
+        // is there an enemy that may block?
+        if( right.type == gSENSOR_ENEMY && right.lr == -1 )
+        {
+            gap.type = right.type;
+            gap.lr = right.lr;
+            gap.hitOwner_ = right.hitOwner_;
+            gap.hitTime_  = right.hitTime_;
+            gap.hitDistance_  = 0;
+            gap.hit = right.hitDistance_/gap.Direction().Norm();
+        }
+    }
+}
+
+
+static inline void sg_NoNeg( REAL & r )
+{
+    if( r < 0 )
+        r = 0;
+}
+
+void gAINavigator::UpdatePaths()
+{
+    REAL lookahead = settings_.range;  // seconds to plan ahead
+
+    // cylce data
+    REAL speed = owner_->Speed();
+    eCoord dir = owner_->Direction();
+    eCoord pos = owner_->Position();
+
+    REAL range = speed * lookahead;
+    eCoord scanDir = dir * range;
+
+    // get extra time we get through rubber usage
+    REAL rubberGranted, rubberEffectiveness;
+    sg_RubberValues( owner_->player, speed, rubberGranted, rubberEffectiveness );
+    REAL rubberLeft = ( rubberGranted - owner_->GetRubber() )*rubberEffectiveness;
+    // REAL rubberTime = rubberLeft/speed;
+    // REAL rubberRatio = owner_->GetRubber()/rubberGranted;
+
+    // this distance needs to be considered close
+    REAL close = rubberLeft + speed * owner_->GetTurnDelay();
+
+    REAL narrowFront = 1;
+
+    // these checks can hit our last wall and fail. Temporarily set it to NULL.
+    tJUST_CONTROLLED_PTR< gNetPlayerWall > lastWall = owner_->lastWall;
+    owner_->lastWall = NULL;
+
+    Sensor forward ( *this, pos, scanDir );
+    forward.detect(1);
+
+    // cast four diagonal rays
+    Sensor forwardLeft ( *this, pos, scanDir.Turn(+1,+1 ) );
+    Sensor left        ( *this, pos, scanDir.Turn( 0,+1 ) );
+    Sensor backwardLeft( *this, pos, scanDir.Turn(-1,+narrowFront) );
+    forwardLeft.detect(1);
+    left.detect(1);
+    backwardLeft.detect(1);
+    Sensor forwardRight ( *this, pos, scanDir.Turn(+1,-1 ) );
+    Sensor right        ( *this, pos, scanDir.Turn( 0,-1 ) );
+    Sensor backwardRight( *this, pos, scanDir.Turn(-1,-narrowFront) );
+    forwardRight.detect(1);
+    right.detect(1);
+    backwardRight.detect(1);
+
+    sg_FillSensorGap( backwardLeft, forwardLeft, left );
+    sg_FillSensorGap( forwardLeft, forwardRight, forward );
+    sg_FillSensorGap( forwardRight, backwardRight, right );
+    
+    // sensor going backwards with fake entries
+    Sensor self( *this, pos, scanDir.Turn(-1, 0) );
+    self.before_hit = pos;
+    self.windingNumber_ = owner_->windingNumber_;
+    self.type = gSENSOR_SELF;
+    self.hit = 0;
+    if ( owner_->CurrentWall() )
+    {
+        self.ehit = owner_->CurrentWall()->Edge();
+    }
+    self.hitDistance_ = 0;
+    self.hitOwner_ = owner_;
+    self.hitTime_ = owner_->LastTime();
+
+    // get directions
+    eCoord forwardDir  = dir;
+    eGrid * grid = owner_->Grid();
+    eCoord backwardDir = - forwardDir;
+    int winding = owner_->WindingNumber();
+    int wl = winding, wr = winding;
+    grid->Turn( wl, -1 );
+    grid->Turn( wr, 1 );
+    eCoord leftDir = grid->GetDirection( wl );
+    eCoord rightDir = grid->GetDirection( wr );
+
+    // fill paths, first the simple cases
+    self.lr = -1;
+    {
+        // U-Turn left
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_UTURN_LEFT  );
+        path.Fill( *this, self, left, leftDir, backwardDir, -1 );
+        sg_AddSensor( path, left, range, rubberLeft );
+
+        // see if there would be more space to the right
+        if( forward.hit > left.hit &&
+            forwardRight.hit > left.hit &&
+            right.hit > left.hit &&
+            left.hit * range < close )
+        {
+            // calculate rubber usage of the two possibilities
+            REAL rubberOffset = owner_->GetTurnDelay() * owner_->Speed()/range;
+            REAL pRubberUsageA = rubberOffset - right.hit;
+            REAL pRubberUsageB = pRubberUsageA - left.hit;
+            REAL pRubberUsageC = rubberOffset - forward.hit;
+            REAL uRubberUsage  = rubberOffset - left.hit;
+            sg_NoNeg( pRubberUsageA );
+            sg_NoNeg( pRubberUsageB );
+            sg_NoNeg( pRubberUsageC );
+            sg_NoNeg( uRubberUsage );
+            if( uRubberUsage > pRubberUsageA + pRubberUsageB + pRubberUsageC )
+            {
+                // transform it into a P-Turn
+                path.turn *= -1;
+                path.immediateDistance = HUGE;
+                sg_AddSensor( path, forward, range, rubberLeft );
+                sg_AddSensor( path, right, range, rubberLeft );
+                sg_AddSensor( path, forwardRight, range, rubberLeft );
+            }
+        }
+    }
+
+    self.lr = 1;
+    // U-Turn right
+    {
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_UTURN_RIGHT );
+        path.Fill( *this, right, self, rightDir, backwardDir, 1 );
+        sg_AddSensor( path, right, range, rubberLeft );
+
+        // see if there would be more space to the left
+        if( forward.hit > right.hit &&
+            forwardLeft.hit > right.hit &&
+            left.hit > right.hit &&
+            right.hit * range < close )
+        {
+            // calculate rubber usage of the two possibilities
+            REAL rubberOffset = owner_->GetTurnDelay() * owner_->Speed()/range;
+            REAL pRubberUsageA = rubberOffset - left.hit;
+            REAL pRubberUsageB = pRubberUsageA - right.hit;
+            REAL pRubberUsageC = rubberOffset - forward.hit;
+            REAL uRubberUsage  = rubberOffset - right.hit;
+            sg_NoNeg( pRubberUsageA );
+            sg_NoNeg( pRubberUsageB );
+            sg_NoNeg( pRubberUsageC );
+            sg_NoNeg( uRubberUsage );
+            if( uRubberUsage > pRubberUsageA + pRubberUsageB + pRubberUsageC )
+            {
+                // transform it into a P-Turn
+                path.turn *= -1;
+                path.immediateDistance = HUGE;
+                sg_AddSensor( path, forward, range, rubberLeft );
+                sg_AddSensor( path, left, range, rubberLeft );
+                sg_AddSensor( path, forwardLeft, range, rubberLeft );
+            }
+        }
+    }
+
+    // straight ahead
+    {
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_STRAIGHT );
+        path.Fill( *this, forwardLeft, forwardRight, forwardDir, forwardDir, 0 );
+        sg_AddSensor( path, forward, range, rubberLeft );
+
+        // slighly favor going straight over anything else
+        path.distance *= 1.0001;
+    }
+
+    // complicated cases
+
+    // immediate turn right
+    {
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_TURN_RIGHT );
+        path.Fill( *this, forwardRight, backwardRight, rightDir, rightDir, 1 );
+
+        REAL smallRightDistance = Distance( right, backwardRight );
+        if( sg_SameWall( backwardRight, right ) || path.distance < smallRightDistance )
+        {
+            // we did not pass a kink, so the smaller distance applies
+            path.distance = smallRightDistance;
+        }
+
+        sg_AddSensor( path, right, range, rubberLeft );
+    }
+
+    // immediate turn left
+    {
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_TURN_LEFT );
+        path.Fill( *this, backwardLeft, forwardLeft, leftDir, leftDir, -1 );
+
+        REAL smallLeftDistance = Distance( backwardLeft, left );
+        if( sg_SameWall( backwardLeft, left ) || path.distance < smallLeftDistance )
+        {
+            path.distance = smallLeftDistance;
+        }
+
+        sg_AddSensor( path, left, range, rubberLeft );
+    }
+
+    // zigzag right
+    {
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_ZIGZAG_RIGHT );
+        path.Fill( *this, forward, right, rightDir, forwardDir, 1 );
+
+        REAL driveOn = right.HitWallExtends( dir, pos );
+        REAL side    = forward.HitWallExtends( rightDir, pos );
+        if( driveOn > 0 && ( driveOn < forward.hit * range * ( 1-EPS ) || forward.type == gSENSOR_NONE || side > right.hit * range * ( 1+EPS ) ) )
+        {
+            // there is a gap waiting for us. Wait and take it.
+            path.driveOn = driveOn;
+            path.shortTermDirection = forwardDir;
+            path.longTermDirection  = rightDir;
+
+            sg_AddSensor( path, forward, range, rubberLeft );
+        }
+        else
+        {
+            sg_AddSensor( path, right, range, rubberLeft );
+        }
+    }
+
+    // zigzag left
+    {
+        Path & path = GetPaths().AccessPath( PathGroup::PATH_ZIGZAG_LEFT );
+        path.Fill( *this, left, forward, leftDir, forwardDir, -1 );
+
+        REAL driveOn = left.HitWallExtends( dir, pos );
+        REAL side    = forward.HitWallExtends( leftDir, pos );
+        if( driveOn > 0 && ( driveOn < forward.hit * range * ( 1-EPS ) || forward.type == gSENSOR_NONE || side > left.hit * range * ( 1+EPS ) ) )
+        {
+            // there is a gap waiting for us. Wait and take it.
+            path.driveOn = driveOn;
+            path.shortTermDirection = forwardDir;
+            path.longTermDirection  = leftDir;
+
+            sg_AddSensor( path, forward, range, rubberLeft );
+        }
+        else
+        {
+            sg_AddSensor( path, left, range, rubberLeft );
+        }
+    }
+}
+
+//! does the main thinking at the current time, knowing the next thought can't be sooner than minstep
+REAL gAINavigator::Activate( REAL currentTime, REAL minstep, REAL penalty, Wish * wish )
+{
+    REAL lookahead = settings_.range;  // seconds to plan ahead
+
+    // cylce data
+    REAL speed = owner_->Speed();
+    eCoord dir = owner_->Direction();
+    eCoord pos = owner_->Position();
+
+    REAL range= speed * lookahead;
+    eCoord scanDir = dir * range;
+
+    REAL frontFactor = .5;
+
+    Sensor front(*this,pos,scanDir);
+    front.detect(frontFactor);
+    owner_->enemyInfluence.AddSensor( front, penalty, owner_ );
+
+    REAL minMoveOn = 0, maxMoveOn = 0, moveOn = 0;
+
+    // get extra time we get through rubber usage
+    REAL rubberGranted, rubberEffectiveness;
+    sg_RubberValues( owner_->player, speed, rubberGranted, rubberEffectiveness );
+    REAL rubberTime = ( rubberGranted - owner_->GetRubber() )*rubberEffectiveness/speed;
+    REAL rubberRatio = owner_->GetRubber()/rubberGranted;
+
+    if ( front.ehit || wish )
+    {
+        turnedRecently_ = false;
+
+        // these checks can hit our last wall and fail. Temporarily set it to NULL.
+        tJUST_CONTROLLED_PTR< gNetPlayerWall > lastWall = owner_->lastWall;
+        owner_->lastWall = NULL;
+
+        REAL narrowFront = 1;
+
+        // cast four diagonal rays
+        Sensor forwardLeft ( *this, pos, scanDir.Turn(+1,+1 ) );
+        Sensor backwardLeft( *this, pos, scanDir.Turn(-1,+narrowFront) );
+        forwardLeft.detect(1);
+        backwardLeft.detect(1);
+        Sensor forwardRight ( *this, pos, scanDir.Turn(+1,-1 ) );
+        Sensor backwardRight( *this, pos, scanDir.Turn(-1,-narrowFront) );
+        forwardRight.detect(1);
+        backwardRight.detect(1);
+
+        // determine survival chances in the four directions
+        REAL frontOpen = Distance ( forwardLeft, forwardRight );
+        REAL leftOpen  = Distance ( forwardLeft, backwardLeft );
+        REAL rightOpen = Distance ( forwardRight, backwardRight );
+        REAL rearOpen = Distance ( backwardLeft, backwardRight );
+
+        Sensor self( *this, pos, scanDir.Turn(-1, 0) );
+        // fake entries
+        self.before_hit = pos;
+        self.windingNumber_ = owner_->windingNumber_;
+        self.type = gSENSOR_SELF;
+        self.hitDistance_ = 0;
+        self.hitOwner_ = owner_;
+        self.hitTime_ = currentTime;
+        self.lr = -1;
+        REAL rearLeftOpen = Distance( backwardLeft, self );
+        self.lr = 1;
+        REAL rearRightOpen = Distance( backwardRight, self );
+
+        // override rim hugging
+        if ( forwardRight.type == gSENSOR_SELF &&
+             forwardLeft.type == gSENSOR_RIM &&
+             backwardRight.type == gSENSOR_SELF &&
+             backwardLeft.type == gSENSOR_RIM &&
+             forwardRight.lr == -1 &&
+             backwardRight.lr == -1 )
+        {
+            turnedRecently_ = true;
+            if ( rightOpen > speed * ( owner_->GetTurnDelay() - rubberTime * .8 ) )
+            {
+                owner_->Act( &gCycle::se_turnRight, 1 );
+                owner_->Act( &gCycle::se_turnRight, 1 );
+            }
+            else
+            {
+                owner_->Act( &gCycle::se_turnLeft, 1 );
+                owner_->Act( &gCycle::se_turnLeft, 1 );
+            }
+        }
+
+        if ( forwardLeft.type == gSENSOR_SELF &&
+             forwardRight.type == gSENSOR_RIM &&
+             backwardLeft.type == gSENSOR_SELF &&
+             backwardRight.type == gSENSOR_RIM &&
+             forwardLeft.lr == 1 &&
+             backwardLeft.lr == 1 )
+        {
+            turnedRecently_ = true;
+            if ( leftOpen > speed * ( owner_->GetTurnDelay() - rubberTime * .8 ) )
+            {
+                owner_->Act( &gCycle::se_turnLeft, 1 );
+                owner_->Act( &gCycle::se_turnLeft, 1 );
+            }
+            else
+            {
+                owner_->Act( &gCycle::se_turnRight, 1 );
+                owner_->Act( &gCycle::se_turnRight, 1 );
+            }
+        }
+
+        // get the best turn direction
+        int             bestDir      = ( leftOpen + rearLeftOpen > rightOpen + rearRightOpen ) ? 1 : -1;
+
+        Sensor direct ( *this, pos, scanDir.Turn( 0, bestDir) );
+        direct.detect( 1 );
+
+        // restore last wall
+        owner_->lastWall = lastWall;
+
+        if( wish && wish->turn )
+        {
+            REAL minDistance = wish->minDistance;
+            if( wish->turn > 0 )
+            {
+                if( wish->maxDisadvantage + leftOpen + rearLeftOpen < frontOpen + rightOpen + rearRightOpen )
+                {
+                    wish = 0;
+                }
+                else if ( leftOpen < wish->minDistance )
+                {
+                    if( leftOpen + rearLeftOpen < wish->minDistance || frontOpen < wish->minDistance || rightOpen < wish->minDistance )
+                    {
+                        wish = 0;
+                    }
+                    else if( wish->turn == -1 )
+                    {
+                        wish = 0;
+                    }
+                    else
+                    {
+                        // double back
+                        owner_->Act( &gCycle::se_turnRight, 1 );
+                        owner_->Act( &gCycle::se_turnRight, 1 );
+                        owner_->Act( &gCycle::se_turnRight, 1 );
+                        return owner_->GetTurnDelay() * 3;
+                    }
+                }
+                else
+                {
+                    bestDir = 1;
+                }
+            }
+            else if( wish->turn < 0 )
+            {
+                if( wish->maxDisadvantage + rightOpen + rearRightOpen < frontOpen + leftOpen + rearLeftOpen )
+                {
+                    wish = 0;
+                }
+                else if ( rightOpen < wish->minDistance )
+                {
+                    if( rightOpen + rearRightOpen < wish->minDistance || frontOpen < wish->minDistance || leftOpen < wish->minDistance )
+                    {
+                        wish = 0;
+                    }
+                    else if( wish->turn == -1 )
+                    {
+                        wish = 0;
+                    }
+                    else
+                    {
+                        // double back
+                        owner_->Act( &gCycle::se_turnLeft, 1 );
+                        owner_->Act( &gCycle::se_turnLeft, 1 );
+                        owner_->Act( &gCycle::se_turnLeft, 1 );
+                        return owner_->GetTurnDelay() * 3;
+                    }
+                }
+                else
+                {
+                    bestDir = -1;
+                }
+            }
+
+            if( !wish && frontOpen > minDistance )
+            {
+                // going straigt is not too bad
+                return Owner()->GetTurnDelay();
+            }
+
+        }
+
+        uActionPlayer * bestAction = ( bestDir > 0 ) ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
+
+        REAL            bestOpen     = ( bestDir > 0 ) ? leftOpen : rightOpen;
+        Sensor &        bestForward  = ( bestDir > 0 ) ? forwardLeft : forwardRight;
+        Sensor &        bestBackward = ( bestDir > 0 ) ? backwardLeft : backwardRight;
+
+        // only turn if the hole has a shape that allows better entry after we do a zig-zag, or if we're past the good turning point
+        // see how the survival chance is distributed between forward and backward half
+        REAL forwardHalf  = Distance ( direct, bestForward );
+        REAL backwardHalf = Distance ( direct, bestBackward );
+
+        REAL forwardOverhang  = bestForward.HitWallExtends( bestForward.Direction(), pos );
+        REAL backwardOverhang  = bestBackward.HitWallExtends( bestForward.Direction(), pos );
+
+        // we have to move forward this much before we can hope to turn
+        minMoveOn = bestBackward.HitWallExtends( dir, pos );
+
+        if( wish )
+        {
+            if( backwardHalf < wish->minDistance )
+            {
+                return (minMoveOn/owner_->Speed())*1.1;
+            }
+
+            if ( !CanMakeTurn( bestAction ) )
+            {
+                return owner_->GetNextTurn( -bestDir ) - owner_->LastTime();
+            }
+            
+            owner_->Act( bestAction, 1 );
+            return Owner()->GetTurnDelay();
+        }
+
+        // maybe the direct to the side sensor is better?
+        REAL minMoveOnOther = direct.HitWallExtends( dir, pos );
+
+        // determine how far we can drive on
+        maxMoveOn      = bestForward.HitWallExtends( dir, pos );
+        REAL maxMoveOnOther = front.HitWallExtends( dir, pos );
+        if ( maxMoveOn > maxMoveOnOther )
+            maxMoveOn = maxMoveOnOther;
+
+        if ( maxMoveOn > minMoveOnOther && forwardHalf > backwardHalf && direct.hitOwner_ == bestBackward.hitOwner_ )
+        {
+            backwardOverhang  = direct.HitWallExtends( bestForward.Direction(), pos );
+            minMoveOn = minMoveOnOther;
+        }
+
+        // best place to turn
+        moveOn = .5 * ( minMoveOn * ( 1 + rubberRatio ) + maxMoveOn * ( 1 - rubberRatio ) );
+
+        // hit the brakes before you hit anything and if it's worth it
+        bool brake = sg_brakeCycle > 0 &&
+        front.hit * lookahead * sg_cycleBrakeDeplete < owner_->GetBrakingReservoir() &&
+        sg_brakeCycle * front.hit * lookahead < 2 * speed * owner_->GetBrakingReservoir() &&
+        ( maxMoveOn - minMoveOn ) > 0 &&
+        owner_->GetBrakingReservoir() * ( maxMoveOn - minMoveOn ) < speed * owner_->GetTurnDelay();
+        if ( frontOpen < bestOpen &&
+             ( forwardOverhang <= backwardOverhang || ( minMoveOn < 0 && moveOn < minstep * speed ) ) )
+        {
+            turnedRecently_ = true;
+
+            minMoveOn = maxMoveOn = moveOn = 0;
+
+            {
+                if ( !CanMakeTurn( bestAction ) )
+                {
+                    return owner_->GetNextTurn( -bestDir ) - owner_->LastTime();
+                }
+
+                owner_->Act( bestAction, 1 );
+            }
+
+            brake = false;
+        }
+        else
+        {
+            // the best
+            REAL bestSoFar = frontOpen > bestOpen ? frontOpen : bestOpen;
+            bestSoFar *= ( 10 * ( 1 - rubberRatio ) + 1 );
+
+            if ( rearOpen > bestSoFar && ( rearLeftOpen > bestSoFar || rearRightOpen > bestSoFar ) )
+            {
+                brake = false;
+                turnedRecently_ = true;
+
+                bool goLeft = rearLeftOpen > rearRightOpen;
+
+                // dead end. reverse into the opposite direction of the front wall
+                uActionPlayer * bestAction = goLeft ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
+                uActionPlayer * otherAction = !goLeft ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
+                Sensor &        bestForward  = goLeft ? forwardLeft : forwardRight;
+                Sensor &        bestBackward  = goLeft ? backwardLeft : backwardRight;
+                Sensor &        otherForward  = !goLeft ? forwardLeft : forwardRight;
+                Sensor &        otherBackward  = !goLeft ? backwardLeft : backwardRight;
+
+                // space in the two directions available for turns
+                REAL bestHit = bestForward.hit > bestBackward.hit ? bestBackward.hit : bestForward.hit;
+                REAL otherHit = otherForward.hit > otherBackward.hit ? otherBackward.hit : otherForward.hit;
+
+                bool wait = false;
+
+                if ( !CanMakeTurn( bestAction ) )
+                {
+                    return owner_->GetNextTurn( -bestDir ) - owner_->LastTime();
+                }
+
+                // well, after a short turn to the right if space is tight
+                if ( bestHit * lookahead < owner_->GetTurnDelay() + rubberTime )
+                {
+                    if ( otherHit < bestForward.hit * 2 && front.hit * lookahead > owner_->GetTurnDelay() * 2 )
+                    {
+                        // wait a bit, perhaps there will be a better spot
+                        wait = true;
+                    }
+                    else
+                    {
+                        if ( !CanMakeTurn( otherAction ) )
+                        {
+                            return owner_->GetNextTurn( bestDir ) - owner_->LastTime();
+                        }
+
+                        owner_->Act( otherAction, 1 );
+
+                        // there needs to be space ahead to finish the maneuver correctly
+                        if ( maxMoveOn < speed * owner_->GetTurnDelay() )
+                        {
+                            // there isn't. oh well, turn into the wrong direction completely, see if I care
+                            owner_->Act( otherAction, 1 );
+                            wait = true;
+                        }
+                    }
+                }
+
+                if ( !wait )
+                {
+                    owner_->Act( bestAction, 1 );
+                    owner_->Act( bestAction, 1 );
+                }
+
+                minMoveOn = maxMoveOn = moveOn = 0;
+            }
+        }
+
+        // execute brake command
+        owner_->Act( &gCycle::s_brake, brake ? 1 : -1 );
+    }
+
+    REAL space = moveOn;
+    REAL minTime = space/speed;
+
+    if ( turnedRecently_ )
+        minTime = owner_->GetTurnDelay();
+
+    return minTime;
+}

=== added file 'src/tron/gAINavigator.h'
--- src/tron/gAINavigator.h	1970-01-01 00:00:00 +0000
+++ src/tron/gAINavigator.h	2019-01-04 23:26:28 +0000
@@ -0,0 +1,423 @@
+/*
+
+*************************************************************************
+
+ArmageTron -- Just another Tron Lightcycle Game in 3D.
+Copyright (C) 2005  by 
+and the AA DevTeam (see the file AUTHORS(.txt) in the main source directory)
+
+**************************************************************************
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+  
+***************************************************************************
+
+*/
+
+#ifndef ArmageTron_AI_NAVIGATOR_H
+#define ArmageTron_AI_NAVIGATOR_H
+
+#include "gSensor.h"
+#include "eCoord.h"
+
+class gCycle;
+
+//! AI helper class that knows the basics of staying alive.
+class gAINavigator
+{
+    gAINavigator();
+public:
+    //! settings used by the idler bot
+    struct Settings
+    {
+        REAL newWallBlindness; //!< number of seconds new walls are invisible to the idler
+        REAL range; //!< seconds to plan ahead
+        
+        Settings();
+    };
+
+    Settings settings_; // settings to use
+
+    //! turn wish passed from outside
+    struct Wish
+    {
+        int turn;             //!< direction to turn into (values >1 turn multiple times)
+
+        REAL maxDisadvantage; //!< maximal disadvantage of the wish direction over others to have it still accepted
+        REAL minDistance;     //!< minimal 'distance' value of the wish direction to have it accepted
+
+        Wish( gAINavigator const & idler );
+    private:
+        Wish();
+    };
+
+    // sensor with additional data
+    class Sensor: public gSensor
+    {
+    public:
+        Sensor(gAINavigator & ai,const eCoord &start,const eCoord &d);
+
+        virtual void PassEdge(const eWall *ww,REAL time,REAL a,int r);
+
+        // check how far the hit wall extends straight into the given direction
+        REAL HitWallExtends( eCoord const & dir, eCoord const & origin );
+
+        gAINavigator & ai_;          // AI using this sensor
+        gCycle * hitOwner_;     // the owner of the hit wall
+        REAL     hitTime_;      // the time the hit wall was built at
+        REAL     hitDistance_;  // the distance of the wall to the cycle that built it
+        short    lrSuggestion_; // sensor's oppinon on whether moving to the left or right of the hit wall is recommended (-1 for left, +1 for right)
+        int      windingNumber_; // the number of turns (with sign) the cycle has taken
+
+    private:
+        bool DoExtraDetectionStuff();
+    };
+
+    //! ways to relay controls to a cycle
+    class CycleController
+    {
+    public:
+        virtual void Turn( gCycle & cycle , int dir    ) = 0; //!< turns a cycle. dir < 0 turns left.
+        virtual void Brake( gCycle & cycle, bool brake ) = 0; //!< brakes a cycle
+        virtual ~CycleController();
+    };
+
+    //! use direct control
+    class CycleControllerBasic: public CycleController
+    {
+    public:
+        virtual void Turn( gCycle & cycle , int dir    ); //!< turns a cycle.
+        virtual void Brake( gCycle & cycle, bool brake ); //!< brakes a cycle
+        virtual ~CycleControllerBasic();
+    };
+
+    //! use actions
+    class CycleControllerAction: public CycleController
+    {
+    public:
+        virtual void Turn( gCycle & cycle , int dir    ); //!< turns a cycle.
+        virtual void Brake( gCycle & cycle, bool brake ); //!< brakes a cycle
+        virtual ~CycleControllerAction();
+    };
+
+    //! describes walls
+    struct WallHug
+    {
+        gCycle const * owner;  //! the cycle the walls we like belong to
+        REAL lastTimeSeen;     //! the last time we saw such a wall
+        REAL hitDistance;      //! driving distance of the wall that was hit
+        REAL distance;         //! distance to the hit wall
+        int  lr;               //! direction the wall is running to as seen from us
+
+        WallHug();
+
+        // fill data from sensor
+        void FillFrom( Sensor const & sensor );
+    };
+
+    class PathGroup;
+
+    //! a possible path that can be taken
+    class Path
+    {
+        friend class gAINavigator;
+        friend class PathGroup;
+    public:
+        REAL   distance;           //!< expected distance possible to travel this path without getting killed
+        REAL   immediateDistance;  //!< distance to next problem
+        REAL   width;              //!< width of the narrowest bit of the path
+        eCoord shortTermDirection; //!< direction to travel in in the short run
+        eCoord longTermDirection;  //!< direction to travel in in the long run
+        int    followedSince;      //!< number of turns this path is already being followed
+
+        WallHug left, right;       //!< walls to the left and right of the path
+    private:
+        // fill in relevant data from sensors
+        void Fill( gAINavigator const & navigator, Sensor const & left, Sensor const & right, eCoord const & shortDir, eCoord const & longDir, int turn );
+        REAL Take( CycleController & controller, gCycle & cycle, REAL maxStep ); //!< take that path. Return value: time to next check
+        ~Path();
+        Path();
+
+        int  turn;    //!< direction to turn to next
+        REAL driveOn; //!< how long to drive straight before doing something (in distance)
+    };
+
+    class PathGroup
+    {
+        friend class gAINavigator;
+    public:
+        //! types of paths
+        enum PathID
+        {
+            PATH_UTURN_LEFT = 0,   //!< turn around completely
+            PATH_TURN_LEFT,        //!< turn left
+            PATH_ZIGZAG_LEFT,      //!< turn left, then right, or wait, then turn left, looking for a hole
+            PATH_STRAIGHT,         //!< go straight
+            PATH_ZIGZAG_RIGHT,
+            PATH_TURN_RIGHT,
+            PATH_UTURN_RIGHT,
+            PATH_COUNT
+        };
+
+        int GetPathCount() const;                   //!< returns the current number of paths
+        Path const & GetPath( int id ) const;       //!< returns a path
+        REAL TakePath( CycleController & controller, gCycle & cycle, int id, REAL maxStep = 1E+30 );    //!< takes a path
+        Path const & GetLastPath() const;           //!< the last path taken, with old info
+
+        PathGroup();
+        ~PathGroup();
+    private:
+        Path & AccessPath( int id );          //!< returns a path
+
+        Path last;                        //!< last path
+        Path paths[ PATH_COUNT ];         //!< fixed path list. Maybe add dynamic paths later.
+    };
+
+    //! evaluation of a path
+    struct PathEvaluation
+    {
+        bool veto;  //!< was this path vetoed?
+        REAL score; //!< score of the path. 0: pointless suicide, 100: pretty good.
+        REAL nextThought; //!< seconds to next thought
+
+        PathEvaluation();
+    };
+
+    //! class evaluating pathes
+    class PathEvaluator
+    {
+    public:
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const = 0;
+        virtual ~PathEvaluator();
+
+        //! turns a value between 0 and infinity, where 1 would be an expected value, into a value
+        //! between 0 and 100
+        static REAL Adjust( REAL input )
+        {
+            return 100*(1-1/(1+input));
+        }
+    };
+
+    //! simple evaluator: vetoes certain death moves, picks best space move
+    class SuicideEvaluator: public PathEvaluator
+    {
+    public:
+        SuicideEvaluator( gCycle const & cycle, REAL timeFrame );
+        explicit SuicideEvaluator( gCycle const & cycle );
+
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+        ~SuicideEvaluator();
+        
+        static void SetEmergency( bool emergency );
+    private:
+        gCycle const & cycle_;
+        REAL   timeFrame_;
+        static bool emergency_;
+    };
+
+    //! simple evaluator: vetoes moves that trap self
+    class TrapEvaluator: public PathEvaluator
+    {
+    public:
+        TrapEvaluator( gCycle const & cycle, REAL space );
+        explicit TrapEvaluator( gCycle const & cycle );
+
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+        ~TrapEvaluator();
+        
+        static void SetEmergency( bool emergency );
+    private:
+        gCycle const & cycle_;
+        REAL   space_;
+    };
+
+    //! simple evaluator: random noise
+    class RandomEvaluator: public PathEvaluator
+    {
+    public:
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+        RandomEvaluator();
+        ~RandomEvaluator();
+    };
+
+    //! cowardly evaluator: try to move backwards on enemy walls
+    class CowardEvaluator: public PathEvaluator
+    {
+    public:
+        explicit CowardEvaluator( gCycle const & cycle );
+        ~CowardEvaluator();
+
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+    private:
+        gCycle const & cycle_;
+    };
+
+    //! tunnel evaluator: avoids tunneling between walls of different cycles
+    class TunnelEvaluator: public PathEvaluator
+    {
+    public:
+        explicit TunnelEvaluator( gCycle const & cycle );
+        ~TunnelEvaluator();
+
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+    private:
+        gCycle const & cycle_;
+    };
+
+    //! simple evaluator: measures available space compared to a passed-in value
+    class SpaceEvaluator: public PathEvaluator
+    {
+    public:
+        explicit SpaceEvaluator( gCycle const & cycle );
+        explicit SpaceEvaluator( REAL referenceDistance );
+
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+        ~SpaceEvaluator();
+    private:
+        REAL referenceDistance_;
+    };
+
+    //! simple evaluator: likes to follow through with the plan
+    class PlanEvaluator: public PathEvaluator
+    {
+    public:
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+        ~PlanEvaluator();
+    };
+
+    //! simple evaluator: does not like it if rubber gets burned
+    class RubberEvaluator: public PathEvaluator
+    {
+    public:
+        //! evaluate a path.
+        virtual void Evaluate( Path const & path, PathEvaluation & evaluation ) const;
+        explicit RubberEvaluator( gCycle const & cylce );
+        RubberEvaluator( gCycle const & cycle, REAL maxTime );
+        ~RubberEvaluator();
+    private:
+        void Init( gCycle const & cycle, REAL maxTime );
+        REAL rubberLeft_; //!< amount of rubber left to burn with inevitable loss due to turn delay factored in
+        REAL maxRubber_;  //!< maximal rubber possible to burn
+    };
+
+    //! evaluator for following a moving target
+    class FollowEvaluator: public PathEvaluator
+    {
+    public:
+        FollowEvaluator( gCycle const & cycle );
+        ~FollowEvaluator();
+        
+        //! return data of SolveTurn
+        struct SolveTurnData
+        {
+            REAL turnTime;  //!< seconds to wait before we turn
+            REAL quality;   //!< quality of the turn
+            eCoord turnDir; //!< direction to drive in
+            
+            SolveTurnData(): turnTime(0), quality(0){}
+        };
+        
+        //! determine when we need to turn in order to catch the target.
+        void SolveTurn( int direction, eCoord const & targetVelocity, eCoord const & targetPosition, SolveTurnData & data );
+        
+        //! set the target to follow
+        void SetTarget( eCoord const & target, eCoord const & velocity );
+
+        virtual void Evaluate( gAINavigator::Path const & path, gAINavigator::PathEvaluation & evaluation ) const;
+
+        gCycle * GetBlocker() const { return blocker_; }
+    protected:
+        gCycle const & cycle_; //!< the owning cycle
+        gCycle * blocker_;     //!< other cycle blocking the path to the target
+        bool   blockedBySelf_; //!< flag indicating the path is blocked by the cycle itself
+        eCoord toTarget_;      //!< direction to target, roughly normalized
+        REAL   turnTime_;      //!< time to make the next turn
+    };
+
+
+    class EvaluationManager
+    {
+    public:
+        EvaluationManager( PathGroup & paths );
+        
+        //! ways to combine new evaluation with previous results
+        enum BlendMode
+        {
+            BLEND_ADD,
+            BLEND_MULT,
+            BLEND_MAX,
+            BLEND_MIN
+        };
+        
+        //! evaluate all paths using the evaluator
+        void Evaluate( PathEvaluator const & evaluator, BlendMode mode = BLEND_ADD, REAL scale = 1.0, REAL offset = 0.0 );
+
+        //! evaluate all paths using the evaluator, adding results
+        void Evaluate( PathEvaluator const & evaluator, REAL scale )
+        {
+            Evaluate( evaluator, BLEND_ADD, scale );
+        }
+
+        //! reset scores, but don't forget veto
+        void Reset();
+
+        //! execute
+        REAL Finish( CycleController & controller, gCycle & cycle, REAL maxStep = 1E+30 );
+    private:
+        PathGroup & paths_; //!< the path group
+
+        int  bestPath_;  //!< best path
+
+        //! list of evaluations fitting to those in the 
+        PathEvaluation evaluations_[ PathGroup::PATH_COUNT ];
+    };
+
+    PathGroup & GetPaths(); //!< returns the paths the navigator knows about
+    void UpdatePaths();     //!< updates the paths to the new cycle position
+
+    gAINavigator( gCycle * owner );
+
+    // returns the controlled cycle
+    gCycle * Owner() const
+    {
+        return owner_;
+    }
+
+    // determines the distance between two sensors; the size should give the likelyhood
+    // to survive if you pass through a gap between the two selected walls
+    REAL Distance( Sensor const & a, Sensor const & b ) const;
+
+    bool CanMakeTurn( uActionPlayer * action );
+
+    //! does the main thinking at the current time, knowing the next thought can't be sooner than minstep
+    REAL Activate( REAL currentTime, REAL minstep, REAL penalty = 0, Wish * wish = 0 );
+
+private:
+    short lastTurn_;         //!< the last turn the chat AI made
+    REAL nextTurn_;          //!< the next turn if one is planned
+    bool turnedRecently_;    //!< whether the cycle was turned or almost turned recently
+    gCycle * owner_;         //!< owner of chatbot
+    PathGroup paths_;        //!< possible future paths
+};
+
+#endif

=== modified file 'src/tron/gCycle.cpp'
--- src/tron/gCycle.cpp	2013-10-28 22:02:36 +0000
+++ src/tron/gCycle.cpp	2019-01-04 23:26:28 +0000
@@ -57,8 +57,12 @@
 #include "gStatistics.h"
 
 #include "cCockpit.h"
+<<<<<<< TREE
 #include "eWarmup.h"
 #include "eLadderLog.h"
+=======
+#include "gAINavigator.h"
+>>>>>>> MERGE-SOURCE
 
 #include "tMath.h"
 #include <stdlib.h>
@@ -116,8 +120,6 @@
 static float sg_cycleSyncSmoothThreshold = .2f;
 static tSettingItem<float> conf_smoothThreshold ("CYCLE_SMOOTH_THRESHOLD", sg_cycleSyncSmoothThreshold);
 
-static REAL sg_enemyChatbotTimePenalty = 30.0f;   //!< penalty for victim in chatbot mode
-static tSettingItem<REAL> sg_enemyChatbotTimePenaltyConf( "ENEMY_CHATBOT_PENALTY", sg_enemyChatbotTimePenalty );
 extern REAL sg_suicideTimeout;
 
 REAL		gCycle::wallsStayUpDelay=8.0f;	// the time the cycle walls stay up ( negative values: they stay up forever )
@@ -288,11 +290,6 @@
 #endif
 }
 
-// from gCycleMovement.cpp
-extern void sg_RubberValues( ePlayerNetID const * player, REAL speed, REAL & max, REAL & effectiveness );
-extern REAL sg_brakeCycle;
-extern REAL sg_cycleBrakeDeplete;
-
 // in release mode, default values should always be used. in debug mode, we want to experiment :)
 #ifdef DEBUG
 #ifndef DEDICATED
@@ -331,284 +328,20 @@
 static gChatBotSetting sg_chatBotDecayConf( "CHATBOT_DECAY",
         sg_chatBotDecay );
 
-class gCycleChatBot
+class gCycleChatBot: public gAINavigator
 {
-    gCycleChatBot();
+    friend class gCycle;
+
+    REAL nextChatAI_;        //!< the next time the chat AI can be active
+    REAL timeOnChatAI_;      //!< the total time the player was on chat AI this round
 public:
-class Sensor: public gSensor
-    {
-    public:
-        Sensor(gCycle *o,const eCoord &start,const eCoord &d)
-                : gSensor(o,start,d)
-                , hitOwner_( 0 )
-                , hitTime_ ( 0 )
-                , hitDistance_( o->MaxWallsLength() )
-                , lrSuggestion_( 0 )
-                , windingNumber_( 0 )
-        {
-            if ( hitDistance_ <= 0 )
-                hitDistance_ = o->GetDistance();
-        }
-
-        /*
-        // do detection and additional stuff
-        void detect( REAL range )
-        {
-            gSensor::detect( range );
-        }
-        */
-
-        virtual void PassEdge(const eWall *ww,REAL time,REAL a,int r)
-        {
-            try{
-                gSensor::PassEdge(ww,time,a,r);
-            }
-            catch( eSensorFinished & e )
-            {
-                if ( DoExtraDetectionStuff() )
-                    throw;
-            }
-        }
-
-        bool DoExtraDetectionStuff()
-        {
-            // move towards the beginning of a wall
-            lrSuggestion_ = -lr;
-
-            switch ( type )
-            {
-            case gSENSOR_NONE:
-            case gSENSOR_RIM:
-                lrSuggestion_ = 0;
-                return true;
-            default:
-                // unless it is an enemy, follow his wall instead (uncomment for a nasty cowardy campbot)
-                // lrSuggestion *= -1;
-            case gSENSOR_SELF:
-                {
-                    // determine whether we're hitting the front or back half of his wall
-                    if ( !ehit )
-                        return true;
-                    eWall * wall = ehit->GetWall();
-                    if ( !wall )
-                        return true;
-                    gPlayerWall * playerWall = dynamic_cast< gPlayerWall * >( wall );
-                    if ( !playerWall )
-                        return true;
-                    hitOwner_ = playerWall->Cycle();
-                    if ( !hitOwner_ )
-                        return true;
-
-                    // gCycleChatBot & enemyChatBot = Get( hitOwner_ );
-
-                    REAL wallAlpha = playerWall->Edge()->Ratio( before_hit );
-                    // that's an unreliable source
-                    if ( wallAlpha < 0 )
-                        wallAlpha = 0;
-                    if ( wallAlpha > 1 )
-                        wallAlpha = 1;
-                    hitDistance_   = hitOwner_->GetDistance() - playerWall->Pos( wallAlpha );
-                    hitTime_       = playerWall->Time( wallAlpha );
-                    windingNumber_ = playerWall->WindingNumber();
-
-                    // don't see new walls
-                    if ( hitTime_ > hitOwner_->LastTime() - sg_chatBotNewWallBlindness && hitOwner_ != owned )
-                    {
-                        ehit = NULL;
-                        hit = 1E+40;
-                        return false;
-                    }
-
-                    // REAL cycleDistance = hitOwner_->GetDistance();
-
-                    // REAL wallStart = 0;
-
-                    /*
-                    if ( gCycle::WallsLength() > 0 )
-                    {
-                        wallStart = cyclePos - playerWall->Cycle()->ThisWallsLength();
-                        if ( wallStart < 0 )
-                            wallStart = 0;
-                    }
-                    */
-                }
-            }
-
-            return true;
-        }
-
-        // check how far the hit wall extends straight into the given direction
-        REAL HitWallExtends( eCoord const & dir, eCoord const & origin )
-        {
-            if ( !ehit || !ehit->Other() )
-            {
-                return 1E+30;
-            }
-
-            REAL ret = -1E+30;
-            eCoord ends[2] = { *ehit->Point(), *ehit->Other()->Point() };
-            for ( int i = 1; i>=0; --i )
-            {
-                REAL newRet = eCoord::F( dir, ends[i]-origin );
-                if ( newRet > ret )
-                    ret = newRet;
-            }
-
-            return ret;
-        }
-
-        gCycle * hitOwner_;     // the owner of the hit wall
-        REAL     hitTime_;      // the time the hit wall was built at
-        REAL     hitDistance_;  // the distance of the wall to the cycle that built it
-        short    lrSuggestion_; // sensor's oppinon on whether moving to the left or right of the hit wall is recommended (-1 for left, +1 for right)
-        int      windingNumber_; // the number of turns (with sign) the cycle has taken
-    };
-
     gCycleChatBot( gCycle * owner )
-            : nextChatAI_( 0 )
+            : gAINavigator( owner )
+            , nextChatAI_( 0 )
             , timeOnChatAI_( 0 )
-            , lastTurn_( 0 )
-            , nextTurn_ ( 0 )
-            , turnedRecently_ ( 0 )
-            , owner_ ( owner )
-    {
-#ifdef RLBOT
-        rlDir = 1;
-        rlLastTime = -100;
-#endif
-    }
-
-    // describes walls we like. We like enemy walls. We like to go between them.
-    class WallHug
-    {
-    public:
-        gCycle const * owner_;  // the cycle the walls we like belong to
-        REAL lastTimeSeen_;    // the last time we saw such a wall
-
-        WallHug()
-                : owner_ ( NULL )
-                , lastTimeSeen_ ( 0 )
-        {
-        }
-    };
-
-    // promote seen walls to possible wallhug replacements
-    void FindHugReplacement( Sensor const & sensor )
-    {
-        gCycle const * owner = sensor.hitOwner_;
-        if (!owner)
-            return;
-
-        // store as possible replacement
-        if ( !hugReplacement_.owner_ && sensor.type != gSENSOR_SELF &&
-                owner != hugLeft_.owner_ &&
-                owner != hugRight_.owner_ )
-        {
-            hugReplacement_.owner_ = sensor.hitOwner_;
-            hugReplacement_.lastTimeSeen_ = nextChatAI_;
-        }
-
-        // update timestamps
-        if ( owner == hugLeft_.owner_ )
-            hugLeft_.lastTimeSeen_ = nextChatAI_;
-        if ( owner == hugRight_.owner_ )
-            hugRight_.lastTimeSeen_ = nextChatAI_;
-    }
-
-    // determines the distance between two sensors; the size should give the likelyhood
-    // to survive if you pass through a gap between the two selected walls
-    REAL Distance( Sensor const & a, Sensor const & b )
-    {
-        // make sure a is left from b
-        if ( a.Direction() * b.Direction() < 0 )
-            return Distance( b, a );
-
-        bool self = a.type == gSENSOR_SELF || b.type == gSENSOR_SELF;
-        bool rim  = a.type == gSENSOR_RIM || b.type == gSENSOR_RIM;
-
-        // avoid. own. walls.
-        REAL selfHatred = 1;
-        if ( a.type == gSENSOR_SELF )
-        {
-            selfHatred *= .5;
-            if ( a.lr > 0 )
-            {
-                selfHatred *= .5;
-                if ( b.type == gSENSOR_RIM )
-                    selfHatred *= .25;
-            }
-        }
-        if ( b.type == gSENSOR_SELF )
-        {
-            selfHatred *= .5;
-            if ( b.lr < 0 )
-            {
-                selfHatred *= .5;
-                if ( a.type == gSENSOR_RIM )
-                    selfHatred *= .25;
-            }
-        }
-
-        // some big distance to return if we don't know anything better
-        REAL bigDistance = owner_->MaxWallsLength();
-        if ( bigDistance <= 0 )
-            bigDistance = owner_->GetDistance();
-
-        if ( a.hitOwner_ != b.hitOwner_ )
-        {
-            // different owners? Great, there has to be a way through!
-            REAL ret =
-                a.hitDistance_ + b.hitDistance_;
-
-            if ( rim )
-            {
-                ret = bigDistance * .001 + ret * .01 + ( a.before_hit - b.before_hit).Norm();
-
-                // we love going between the rim and enemies
-                if ( !self )
-                    ret = bigDistance * 2;
-            }
-
-            // minimal factor should be 1, this path should never return something smaller than the
-            // paths where only one cycle's walls are hit
-            ret *= 16;
-
-            // or empty space
-            if ( a.type == gSENSOR_NONE || b.type == gSENSOR_NONE )
-                ret *= 2;
-
-            return ret * selfHatred;
-        }
-        else if ( rim )
-        {
-            // at least one rim wall? Take the distance between the hit positions.
-            return ( a.before_hit - b.before_hit).Norm() * selfHatred;
-        }
-        else if ( a.type == gSENSOR_NONE && b.type == gSENSOR_NONE )
-        {
-            // empty space! Woo!
-            return owner_->GetDistance() * 256;
-        }
-        else if ( a.lr != b.lr )
-        {
-            // different directions? Also great!
-            return ( fabsf( a.hitDistance_ - b.hitDistance_ ) + .25 * bigDistance ) * selfHatred;
-        }
-        /*
-        else if ( - 2 * a.lr * (a.windingNumber_ - b.windingNumber_ ) > owner_->Grid()->WindingNumber() )
-        {
-            // this looks like a way out to me
-            return fabsf( a.hitDistance_ - b.hitDistance_ ) * 10 * selfHatred;
-        }
-        */
-        else
-        {
-            // well, the longer the wall segment between the two points, the better.
-            return fabsf( a.hitDistance_ - b.hitDistance_ ) * selfHatred;
-        }
-
-        // default: hit distance
-        return ( a.before_hit - b.before_hit).Norm() * selfHatred;
+    {
+        settings_.range = sg_chatBotRange;
+        settings_.newWallBlindness = sg_chatBotNewWallBlindness;
     }
 
     static gCycleChatBot & Get( gCycle * cycle )
@@ -622,63 +355,27 @@
         return *cycle->chatBot_;
     }
 
-    bool CanMakeTurn( uActionPlayer * action )
+    REAL Think( REAL minStep )
     {
-        return owner_->CanMakeTurn( ( action == &gCycle::se_turnRight ) ? 1 : -1 );
+        UpdatePaths();
+        EvaluationManager manager( GetPaths() );
+        manager.Evaluate( SuicideEvaluator( *Owner(), sg_chatBotMinTimestep*1.1 ), 1 );
+        manager.Evaluate( SuicideEvaluator( *Owner(), minStep ), 1 );
+        manager.Reset();
+        manager.Evaluate( SpaceEvaluator( *Owner() ), 1 );
+        manager.Evaluate( PlanEvaluator(), .1 );
+        CycleControllerAction controller;
+        return manager.Finish( controller, *Owner(), minStep );
     }
 
-#ifdef RLBOT
-    int rlDir;
-    REAL rlLastTime;
-#endif
-
-    // does the main thinking
     void Activate( REAL currentTime )
     {
-#ifdef RLBOT
-        // hack chatbot for crazy turning
-        {
-            if (!owner_->Alive() || !owner_->Vulnerable() )
-            {
-                return;
-            }
-            if( fabs( rlLastTime - currentTime) > 1 )
-            {
-                owner_->Act( &gCycle::se_turnRight, 1 );
-                rlDir = -1;
-            }
-            else  if ( rlDir > 0 )
-            {
-                if( CanMakeTurn( &gCycle::se_turnRight ) )
-                {
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                    rlDir = -1;
-                }
-            }
-            else
-            {
-                if( CanMakeTurn( &gCycle::se_turnLeft ) )
-                {
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                    rlDir = 1;
-                }
-            }
-            rlLastTime = currentTime;
-            return;
-        }
-#endif
-
         // is it already time for activation?
         if ( currentTime < nextChatAI_ )
             return;
 
-        REAL lookahead = sg_chatBotRange;  // seconds to plan ahead
         REAL minstep   = sg_chatBotMinTimestep; // minimum timestep between thoughts in seconds
-        REAL maxstep   = sg_chatBotMinTimestep * 4 * ( 1 + .1 * tReproducibleRandomizer::GetInstance().Get() );  // maximum timestep between thoughts in seconds
+        REAL maxstep   = sg_chatBotMinTimestep * ( 1 + .5 * tReproducibleRandomizer::GetInstance().Get() );  // maximum timestep between thoughts in seconds
 
         // chat AI wasn't active yet, so don't start immediately
         if ( nextChatAI_ <= EPS )
@@ -689,11 +386,6 @@
 
         timeOnChatAI_ += currentTime - nextChatAI_;
 
-        // cylce data
-        REAL speed = owner_->Speed();
-        eCoord dir = owner_->Direction();
-        eCoord pos = owner_->Position();
-
         // make chat AI worse over time
         if ( sn_GetNetState() != nSTANDALONE )
         {
@@ -705,408 +397,26 @@
             }
         }
 
-        REAL range= speed * lookahead;
-        eCoord scanDir = dir * range;
-
-        REAL frontFactor = .5;
-
-        Sensor front(owner_,pos,scanDir);
-        front.detect(frontFactor);
-        owner_->enemyInfluence.AddSensor( front, sg_enemyChatbotTimePenalty, owner_ );
-
-        REAL minMoveOn = 0, maxMoveOn = 0, moveOn = 0;
-
-        // get extra time we get through rubber usage
-        REAL rubberGranted, rubberEffectiveness;
-        sg_RubberValues( owner_->player, speed, rubberGranted, rubberEffectiveness );
-        REAL rubberTime = ( rubberGranted - owner_->GetRubber() )*rubberEffectiveness/speed;
-        REAL rubberRatio = owner_->GetRubber()/rubberGranted;
-
-        if ( front.ehit )
-        {
-            turnedRecently_ = false;
-
-            // these checks can hit our last wall and fail. Temporarily set it to NULL.
-            tJUST_CONTROLLED_PTR< gNetPlayerWall > lastWall = owner_->lastWall;
-            owner_->lastWall = NULL;
-
-            REAL narrowFront = 1;
-
-            // cast four diagonal rays
-            Sensor forwardLeft ( owner_, pos, scanDir.Turn(+1,+1 ) );
-            Sensor backwardLeft( owner_, pos, scanDir.Turn(-1,+narrowFront) );
-            forwardLeft.detect(1);
-            backwardLeft.detect(1);
-            Sensor forwardRight ( owner_, pos, scanDir.Turn(+1,-1 ) );
-            Sensor backwardRight( owner_, pos, scanDir.Turn(-1,-narrowFront) );
-            forwardRight.detect(1);
-            backwardRight.detect(1);
-
-            // do we have a hug replacement candiate? If so, take it.
-            if ( hugReplacement_.owner_ && !hugLeft_.owner_ && !hugRight_.owner_ )
-            {
-                // first time hugging? let the status quo decide.
-                int lr = 0;
-                if ( backwardLeft.hitOwner_ == hugReplacement_.owner_ )
-                    lr--;
-                if ( forwardLeft.hitOwner_ == hugReplacement_.owner_ )
-                    lr--;
-                if ( backwardRight.hitOwner_ == hugReplacement_.owner_ )
-                    lr++;
-                if ( forwardRight.hitOwner_ == hugReplacement_.owner_ )
-                    lr++;
-
-                if ( lr > 0 )
-                    hugRight_ = hugReplacement_;
-                if ( lr < 0 )
-                    hugLeft_ = hugReplacement_;
-
-                hugReplacement_.owner_ = 0;
-            }
-
-            if ( hugReplacement_.owner_ )
-            {
-                if( hugLeft_.lastTimeSeen_ < hugRight_.lastTimeSeen_ )
-                {
-                    if ( hugReplacement_.lastTimeSeen_ > hugLeft_.lastTimeSeen_ )
-                        hugLeft_ = hugReplacement_;
-                }
-                else
-                {
-                    if ( hugReplacement_.lastTimeSeen_ > hugRight_.lastTimeSeen_ )
-                        hugRight_ = hugReplacement_;
-                }
-                hugReplacement_.owner_ = 0;
-            }
-
-            FindHugReplacement( front );
-            FindHugReplacement( forwardLeft );
-            FindHugReplacement( forwardRight );
-            FindHugReplacement( backwardLeft );
-            FindHugReplacement( backwardRight );
-
-            // determine survival chances in the four directions
-            REAL frontOpen = Distance ( forwardLeft, forwardRight );
-            REAL leftOpen  = Distance ( forwardLeft, backwardLeft );
-            REAL rightOpen = Distance ( forwardRight, backwardRight );
-            REAL rearOpen = Distance ( backwardLeft, backwardRight );
-
-            Sensor self( owner_, pos, scanDir.Turn(-1, 0) );
-            // fake entries
-            self.before_hit = pos;
-            self.windingNumber_ = owner_->windingNumber_;
-            self.type = gSENSOR_SELF;
-            self.hitDistance_ = 0;
-            self.hitOwner_ = owner_;
-            self.hitTime_ = currentTime;
-            self.lr = -1;
-            REAL rearLeftOpen = Distance( backwardLeft, self );
-            self.lr = 1;
-            REAL rearRightOpen = Distance( backwardRight, self );
-
-            /*
-            // override: don't camp (too much)
-            if ( forwardRight.type == gSENSOR_SELF &&
-                    forwardLeft.type == gSENSOR_SELF &&
-                    backwardRight.type == gSENSOR_SELF &&
-                    backwardLeft.type == gSENSOR_SELF &&
-                    front.type == gSENSOR_SELF &&
-                    forwardRight.lr == front.lr &&
-                    forwardLeft.lr == front.lr &&
-                    backwardRight.lr == front.lr &&
-                    backwardLeft.lr == front.lr &&
-                    frontOpen + leftOpen + rightOpen < owner_->GetDistance() * .5 )
-            {
-                turnedRecently_ = true;
-                if ( front.lr > 0 )
-                {
-                    if ( leftOpen > minstep * speed )
-                        // force a turn to the left
-                        rightOpen = 0;
-                    else if ( front.hit * range < 2 * minstep )
-                        // force a preliminary turn to the right that will allow us to reverse
-                        frontOpen = 0;
-                }
-                else
-                {
-                    if ( rightOpen > minstep * speed )
-                        // force a turn to the right
-                        leftOpen = 0;
-                    else if ( front.hit * range < 2 * minstep )
-                        // force a preliminary turn to the left that will allow us to reverse
-                        frontOpen = 0;
-                }
-            }
-            */
-
-            // override rim hugging
-            if ( forwardRight.type == gSENSOR_SELF &&
-                    forwardLeft.type == gSENSOR_RIM &&
-                    backwardRight.type == gSENSOR_SELF &&
-                    backwardLeft.type == gSENSOR_RIM &&
-                    // backwardLeft.hit < .1 &&
-                    forwardRight.lr == -1 &&
-                    backwardRight.lr == -1 )
-            {
-                turnedRecently_ = true;
-                if ( rightOpen > speed * ( owner_->GetTurnDelay() - rubberTime * .8 ) )
-                {
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                }
-                else
-                {
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                }
-            }
-
-            if ( forwardLeft.type == gSENSOR_SELF &&
-                    forwardRight.type == gSENSOR_RIM &&
-                    backwardLeft.type == gSENSOR_SELF &&
-                    backwardRight.type == gSENSOR_RIM &&
-                    // backwardRight.hit < .1 &&
-                    forwardLeft.lr == 1 &&
-                    backwardLeft.lr == 1 )
-            {
-                turnedRecently_ = true;
-                if ( leftOpen > speed * ( owner_->GetTurnDelay() - rubberTime * .8 ) )
-                {
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                    owner_->Act( &gCycle::se_turnLeft, 1 );
-                }
-                else
-                {
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                    owner_->Act( &gCycle::se_turnRight, 1 );
-                }
-            }
-
-            // get the best turn direction
-            uActionPlayer * bestAction = ( leftOpen > rightOpen ) ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
-            int             bestDir      = ( leftOpen > rightOpen ) ? 1 : -1;
-            REAL            bestOpen     = ( leftOpen > rightOpen ) ? leftOpen : rightOpen;
-            Sensor &        bestForward  = ( leftOpen > rightOpen ) ? forwardLeft : forwardRight;
-            Sensor &        bestBackward = ( leftOpen > rightOpen ) ? backwardLeft : backwardRight;
-
-            Sensor direct ( owner_, pos, scanDir.Turn( 0, bestDir) );
-            direct.detect( 1 );
-
-            // restore last wall
-            owner_->lastWall = lastWall;
-
-            // only turn if the hole has a shape that allows better entry after we do a zig-zag, or if we're past the good turning point
-            // see how the survival chance is distributed between forward and backward half
-            REAL forwardHalf  = Distance ( direct, bestForward );
-            REAL backwardHalf = Distance ( direct, bestBackward );
-
-            REAL forwardOverhang  = bestForward.HitWallExtends( bestForward.Direction(), pos );
-            REAL backwardOverhang  = bestBackward.HitWallExtends( bestForward.Direction(), pos );
-
-            // we have to move forward this much before we can hope to turn
-            minMoveOn = bestBackward.HitWallExtends( dir, pos );
-
-            // maybe the direct to the side sensor is better?
-            REAL minMoveOnOther = direct.HitWallExtends( dir, pos );
-
-            // determine how far we can drive on
-            maxMoveOn      = bestForward.HitWallExtends( dir, pos );
-            REAL maxMoveOnOther = front.HitWallExtends( dir, pos );
-            if ( maxMoveOn > maxMoveOnOther )
-                maxMoveOn = maxMoveOnOther;
-
-            if ( maxMoveOn > minMoveOnOther && forwardHalf > backwardHalf && direct.hitOwner_ == bestBackward.hitOwner_ )
-            {
-                backwardOverhang  = direct.HitWallExtends( bestForward.Direction(), pos );
-                minMoveOn = minMoveOnOther;
-            }
-
-            // best place to turn
-            moveOn = .5 * ( minMoveOn * ( 1 + rubberRatio ) + maxMoveOn * ( 1 - rubberRatio ) );
-
-            // hit the brakes before you hit anything and if it's worth it
-            bool brake = sg_brakeCycle > 0 &&
-                         front.hit * lookahead * sg_cycleBrakeDeplete < owner_->GetBrakingReservoir() &&
-                         sg_brakeCycle * front.hit * lookahead < 2 * speed * owner_->GetBrakingReservoir() &&
-                         ( maxMoveOn - minMoveOn ) > 0 &&
-                         owner_->GetBrakingReservoir() * ( maxMoveOn - minMoveOn ) < speed * owner_->GetTurnDelay();
-            if ( frontOpen < bestOpen &&
-                    ( forwardOverhang <= backwardOverhang || ( minMoveOn < 0 && moveOn < minstep * speed ) ) )
-            {
-                // FindHugReplacement( direct );
-                // REAL expectedBackwardHalf = ( direct.before_hit - bestBackward.before_hit ).Norm();
-
-                // if ( ( ( forwardHalf + backwardHalf > bestOpen * 2 || backwardHalf > frontOpen * 10 || backwardHalf > expectedBackwardHalf * 1.01 ) && frontOpen < bestOpen ) ||
-                // rubberTime * .5 + minspace * lookahead < minstep )
-                //                {
-                turnedRecently_ = true;
-
-                minMoveOn = maxMoveOn = moveOn = 0;
-
-                /*
-                if (
-                    ( ( ( bestBackward.type == gSENSOR_ENEMY || bestBackward.type == gSENSOR_TEAMMATE ) && bestBackward.hitDistance_ < bestBackward.hit * lookahead * speed ) ||
-                      direct.hit * lookahead + rubberTime < owner_->GetTurnDelay() ) &&
-                    ( bestBackward.hit * lookahead + rubberTime < owner_->GetTurnDelay() ||
-                      bestForward.hit * lookahead + rubberTime < owner_->GetTurnDelay() )
-                )
-                {
-                    // override: stupid turn into certain death, turn it around if that makes it less stupid
-                    uActionPlayer * newBestAction = ( leftOpen > rightOpen ) ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
-                    Sensor newDirect ( owner_, pos, scanDir.Turn( 0, -bestDir) );
-                    newDirect.detect( 1 );
-                    if ( newDirect.hit > direct.hit ||
-                            newDirect.hit * lookahead + rubberTime > owner_->GetTurnDelay() )
-                        owner_->Act( newBestAction, 1 );
-                }
-                else
-                */
-                {
-                    if ( !CanMakeTurn( bestAction ) )
-                    {
-                        nextChatAI_ = currentTime;
-                        return;
-                    }
-
-                    owner_->Act( bestAction, 1 );
-                }
-
-                brake = false;
-            }
-            else
-            {
-                // the best
-                REAL bestSoFar = frontOpen > bestOpen ? frontOpen : bestOpen;
-                bestSoFar *= ( 10 * ( 1 - rubberRatio ) + 1 );
-
-                if ( rearOpen > bestSoFar && ( rearLeftOpen > bestSoFar || rearRightOpen > bestSoFar ) )
-                {
-                    brake = false;
-                    turnedRecently_ = true;
-
-                    bool goLeft = rearLeftOpen > rearRightOpen;
-
-                    // dead end. reverse into the opposite direction of the front wall
-                    uActionPlayer * bestAction = goLeft ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
-                    uActionPlayer * otherAction = !goLeft ? &gCycle::se_turnLeft : &gCycle::se_turnRight;
-                    Sensor &        bestForward  = goLeft ? forwardLeft : forwardRight;
-                    Sensor &        bestBackward  = goLeft ? backwardLeft : backwardRight;
-                    Sensor &        otherForward  = !goLeft ? forwardLeft : forwardRight;
-                    Sensor &        otherBackward  = !goLeft ? backwardLeft : backwardRight;
-
-                    // space in the two directions available for turns
-                    REAL bestHit = bestForward.hit > bestBackward.hit ? bestBackward.hit : bestForward.hit;
-                    REAL otherHit = otherForward.hit > otherBackward.hit ? otherBackward.hit : otherForward.hit;
-
-                    bool wait = false;
-
-                    if ( !CanMakeTurn( bestAction ) )
-                    {
-                        nextChatAI_ = currentTime;
-                        return;
-                    }
-
-                    // well, after a short turn to the right if space is tight
-                    if ( bestHit * lookahead < owner_->GetTurnDelay() + rubberTime )
-                    {
-                        if ( otherHit < bestForward.hit * 2 && front.hit * lookahead > owner_->GetTurnDelay() * 2 )
-                        {
-                            // wait a bit, perhaps there will be a better spot
-                            wait = true;
-                        }
-                        else
-                        {
-                            if ( !CanMakeTurn( otherAction ) )
-                            {
-                                nextChatAI_ = currentTime;
-                                return;
-                            }
-
-                            owner_->Act( otherAction, 1 );
-
-                            // there needs to be space ahead to finish the maneuver correctly
-                            if ( maxMoveOn < speed * owner_->GetTurnDelay() )
-                            {
-                                // there isn't. oh well, turn into the wrong direction completely, see if I care
-                                owner_->Act( otherAction, 1 );
-                                wait = true;
-                            }
-                        }
-                    }
-
-                    if ( !wait )
-                    {
-                        owner_->Act( bestAction, 1 );
-                        owner_->Act( bestAction, 1 );
-                    }
-
-                    minMoveOn = maxMoveOn = moveOn = 0;
-                }
-            }
-
-            // execute brake command
-            owner_->Act( &gCycle::s_brake, brake ? 1 : -1 );
-
-            // swap hugged walls if we're in fact grinding them the other way round
-            if ( hugLeft_.owner_ == backwardRight.hitOwner_ ||
-                    hugRight_.owner_ == backwardLeft.hitOwner_ )
-            {
-                WallHug swap = hugRight_;
-                hugRight_ = hugLeft_;
-                hugLeft_ = swap;
-            }
-        }
-
-        // REAL mintime = minspace * lookahead;
-
-        // try again soon
-        //        REAL newmintime = mintime * .5 - minstep * .2 * tReproducibleRandomizer::GetInstance().Get();
-
-        // clamp
-        // if ( newmintime < minstep )
-        // newmintime = minstep;
-
-        // add slack, acceleration and rubber
-        // if ( owner_->acceleration > 0 )
-        // mintime -= owner_->acceleration * mintime * mintime / speed;
-        // mintime -= .1 * minstep - rubberTime * .3;
-
-        // if the next step gets us too close to the wall to do anything useful,
-        // bring us really close right away.
-        // if ( mintime - newmintime > minstep )
-        // {
-        // mintime = newmintime;
-        // }
-
-        REAL space = moveOn;
-        REAL minTime = space/speed;
-
-        if ( turnedRecently_ )
-            minTime = owner_->GetTurnDelay();
-
-        if ( minTime < minstep )
-            minTime = minstep;
-        if ( minTime > maxstep + minstep * 1.5 )
-        {
-            minTime = maxstep;
-        }
-        // minTime = 0;
-
-        nextChatAI_ = currentTime + minTime;
-        timeOnChatAI_ += minTime;
+        REAL minTime = Think( maxstep*2 );
+
+        if( minTime < 0 )
+        {
+            // try right again
+            nextChatAI_ = currentTime;
+        }
+        else
+        {
+            if ( minTime < minstep )
+                minTime = minstep;
+            if ( minTime > maxstep + minstep * 1.5 )
+            {
+                minTime = maxstep;
+            }
+            
+            nextChatAI_ = currentTime + minTime;
+            timeOnChatAI_ += minTime;
+        }
     }
-
-    REAL nextChatAI_;        //!< the next time the chat AI can be active
-private:
-    REAL timeOnChatAI_;      //!< the total time the player was on chat AI this round
-    short lastTurn_;         //!< the last turn the chat AI made
-    REAL nextTurn_;          //!< the next turn if one is planned
-    bool turnedRecently_;    //!< whether the cycle was turned or almost turned recently
-    gCycle * owner_;         //!< owner of chatbot
-
-    WallHug hugLeft_;              //!< the wall we like to have on our left side
-    WallHug hugRight_;             //!< the wall we like to have on our right side
-    WallHug hugReplacement_;       //!< a possible replacement candidate for one of the hugged walls
 };
 
 //  *****************************************************************
@@ -1704,7 +1014,7 @@
                            sg_cycleRubberSync);
 
 // how much rubber usage shortens the walls
-static REAL sg_cycleRubberWallShrink = 0;
+REAL sg_cycleRubberWallShrink = 0;
 static nSettingItemWatched<REAL>
 sg_cycleRubberWallShrinkConf("CYCLE_RUBBER_WALL_SHRINK",
                              sg_cycleRubberWallShrink,
@@ -4119,15 +3429,19 @@
         dir_eWall.Select();
     }
 }
+#endif
 
 gCycleWallsDisplayListManager::gCycleWallsDisplayListManager()
     : wallList_(0)
     , wallsWithDisplayList_(0)
+#ifndef DEDICATED
     , wallsWithDisplayListMinDistance_(0)
     , wallsInDisplayList_(0)
+#endif
 {
 }
 
+#ifndef DEDICATED
 bool gCycleWallsDisplayListManager::CannotHaveList( REAL distance, gCycle const * cycle )
 {
     return
@@ -6173,7 +5487,7 @@
 
 void gCycle::RightBeforeDeath( int numTries )
 {
-    if ( player )
+    if ( player && pendingTurns.size() == 0 )
     {
         player->RightBeforeDeath( numTries );
     }
@@ -6257,3 +5571,97 @@
 {
     return Alive() && lastTime > spawnTime_ + sg_cycleInvulnerableTime;
 }
+
+// *************
+// * wall info *
+// *************
+
+struct gWallInfoTemp
+{
+    // center of mass data
+    eCoord com;
+    REAL weight;
+    
+    // tail end
+    eCoord end;
+    eCoord endDir;
+
+    REAL smallestBlend;
+    
+    gWallInfoTemp()
+    : weight( 0 ), smallestBlend( HUGE ){}
+
+    void AddWall( gNetPlayerWall * wall, gCycle const & cycle, REAL totalLength )
+    {
+        if ( !wall || !wall->IsDangerousAnywhere( cycle.LastTime() ) )
+        {
+            return;
+        }
+
+        REAL len = wall->Pos(1) - wall->Pos(0); 
+        com += (wall->EndPoint(0) + wall->EndPoint(1))*len;
+        weight += len*2;
+        if( len > 0 )
+        {
+            REAL blend = ( ( cycle.GetDistance() - totalLength - wall->Pos(0) )/len );
+            if( blend >= 0 && blend < smallestBlend )
+            {
+                end = wall->EndPoint(0) + wall->Vec() * blend;
+                endDir = wall->Vec();
+                smallestBlend = blend;
+            }
+        }
+    }
+};
+
+// @param info the info to fill
+// @param totalLenght total length of wall to assume
+void gCycle::FillWallInfoFlexible( WallInfo & info, REAL totalLength ) const
+{
+    gWallInfoTemp temp;
+
+    gNetPlayerWall * run = displayList_.wallList_;
+    while( run )
+    {
+        temp.AddWall( run, *this, totalLength );
+        run = run->Next();
+    }
+
+    run = displayList_.wallsWithDisplayList_;
+    while( run )
+    {
+        temp.AddWall( run, *this, totalLength );
+        run = run->Next();
+    }
+
+    info.tailPos = temp.end;
+    info.tailDir = temp.endDir;
+    REAL norm = info.tailDir.Norm();
+    if( norm > 0 )
+        info.tailDir *= 1/norm;
+    if( temp.weight > 0 )
+    {
+        info.centerOfMass = temp.com*(1/temp.weight);
+    }
+}
+
+// @param info the info to fill
+// @param rubberRatio rubber usage ratio to assume
+// @param offset offset value to add to the wall length
+void gCycle::FillWallInfo( WallInfo & info, REAL rubberRatio, REAL offset ) const
+{
+    REAL max, effectiveness;
+    sg_RubberValues( Player(), verletSpeed_, max, effectiveness );
+    REAL totalLength = sg_CycleWallLengthFromDist( GetDistance() );
+    if ( totalLength > 0 )
+    {
+        totalLength -= rubberRatio * max;
+    }
+    FillWallInfoFlexible( info, totalLength + offset );
+}
+
+// @param info the info to fill
+void gCycle::FillWallInfo( WallInfo & info ) const
+{
+    FillWallInfoFlexible( info, ThisWallsLength() );
+}

=== modified file 'src/tron/gCycle.h'
--- src/tron/gCycle.h	2011-09-03 16:16:22 +0000
+++ src/tron/gCycle.h	2019-01-04 23:26:28 +0000
@@ -117,16 +117,22 @@
     const gCycleMovement* parent_;												// the cycle that is extrapolated
 };
 
+class gAINavigator;
 class gCycleChatBot;
 
-#ifndef DEDICATED
 class gCycleWallsDisplayListManager
 {
     friend class gNetPlayerWall;
+    friend class gCycle;
 
 public:
     gCycleWallsDisplayListManager();
 
+    bool Walls() const
+    {
+        return wallList_ || wallsWithDisplayList_;
+    }
+#ifndef DEDICATED
     //! checks whether a wall at a certain distance can have a display list
     static bool CannotHaveList( REAL distance, gCycle const * cycle );
 
@@ -138,23 +144,22 @@
 
     //! render all walls
     void RenderAll( eCamera const * camera, gCycle * cycle );
-    bool Walls() const
-    {
-        return wallList_ || wallsWithDisplayList_;
-    }
 
     void Clear( int inhibit = 0 )
     {
         displayList_.Clear( inhibit );
     }
+#endif
 private:
     gNetPlayerWall *                wallList_;                      //!< linked list of all walls
     gNetPlayerWall *                wallsWithDisplayList_;          //!< linked list of all walls with display list    
+
+#ifndef DEDICATED
     rDisplayList                    displayList_;                   //!< combined display list
     REAL                            wallsWithDisplayListMinDistance_; //!< minimal distance of the walls with display list
     int                             wallsInDisplayList_;            //!< number of walls in the current display list
+#endif
 };
-#endif
 
 // a complete lightcycle
 class gCycle: public gCycleMovement
@@ -172,6 +177,7 @@
     REAL timeCameIntoView;
 
     friend class gCycleChatBot;
+    friend class gAINavigator;
     std::auto_ptr< gCycleChatBot > chatBot_;
 
     bool dropWallRequested_; //!< flag indicating that someone requested a wall drop
@@ -211,9 +217,7 @@
 private:
     void TransferPositionCorrectionToDistanceCorrection();
 
-#ifndef DEDICATED
     gCycleWallsDisplayListManager displayList_;                     //!< display list manager
-#endif
 
     tCHECKED_PTR(gNetPlayerWall)	currentWall;                    //!< the wall that currenly is attached to the cycle
     tCHECKED_PTR(gNetPlayerWall)	lastWall;                       //!< the last wall that was attached to this cycle
@@ -354,6 +358,22 @@
     //	virtual void AddRef();
     //	virtual void Release();
 
+    //! information about walls
+    struct WallInfo
+    {
+        tCoord tailPos;      //!< the position of the end of the walls
+        tCoord tailDir;      //!< direction the tail is moving in
+        tCoord centerOfMass; //!< the center of the total walls
+    };
+    
+    //! fills in tail info, assuming the total wall lenght is the one given
+    void FillWallInfoFlexible( WallInfo & info, REAL totalLength ) const;
+
+    //! fills in tail info using the real wall length assuming the given rubber usage ratio
+    void FillWallInfo( WallInfo & info, REAL rubberRatio, REAL offset = 0 ) const;
+
+    //! fills in tail info using the real wall length
+    void FillWallInfo( WallInfo & info ) const;
 private:
     static	REAL	wallsStayUpDelay;			//!< the time the cycle walls stay up ( negative values: they stay up forever )
     static	REAL	wallsLength;				//!< the maximum total length of the walls

=== modified file 'src/tron/gCycleMovement.cpp'
--- src/tron/gCycleMovement.cpp	2014-01-03 23:23:09 +0000
+++ src/tron/gCycleMovement.cpp	2019-01-04 23:26:28 +0000
@@ -3719,7 +3719,6 @@
     REAL step=verletSpeed_*ts;
     tASSERT(isfinite(step));
 
-    int numTries = 0;
     bool emergency = false;
 
     rubberSpeedFactor = 1;
@@ -3829,7 +3828,15 @@
 
                     verletSpeed_=lastSpeed;
                     acceleration=lastAcceleration;
-                    return TimestepCore( rubberGetsActiveTime, false ) || TimestepCore( currentTime );
+                    if ( TimestepCore( rubberGetsActiveTime, false ) )
+                    {
+                        return true;
+                    }
+
+                    // inform AI of its impending doom
+                    RightBeforeDeath(1);
+
+                    return TimestepCore( currentTime );
                 }
             }
 #ifdef DEDICATED
@@ -3932,9 +3939,6 @@
             }
             */
 
-            // notify AIs of it
-            emergency = true;
-
             // calculate the step the rubber code should do based on the decay factor
             // calculated earler
             REAL rubberStep = space * rubberFactor;
@@ -3952,6 +3956,7 @@
 
             // clamp rubberneeded to the amout of rubber available
             REAL rubberAvailable = ( rubber_granted - rubber ) * rubberEffectiveness;
+
             if ( sn_GetNetState() != nCLIENT && rubberneeded > rubberAvailable && Vulnerable() )
             {
                 // rubber will run out this frame.
@@ -3969,7 +3974,18 @@
                             // need many attempts
                             verletSpeed_=lastSpeed;
                             acceleration=lastAcceleration;
-                            return TimestepCore( runOutTime, false ) || TimestepCore( currentTime );
+
+                            // simulate until rubber has run out
+                            if ( TimestepCore( runOutTime, false ) )
+                            {
+                                return true;
+                            }
+                            
+                            // inform AI of its impending doom
+                            RightBeforeDeath(0);
+
+                            // simulate rest of timestep
+                            return TimestepCore( currentTime );
                         }
                     }
                 }
@@ -3981,11 +3997,6 @@
             // update rubber usage
             rubber += rubberneeded / rubberEffectiveness;
 
-            numTries = int((sg_rubberCycleTime * ( rubber_granted - rubber ) - 1 )/(sg_rubberCycleTime * step*1.5 + 1));
-            int numTriesSpace = int(space*10/verletSpeed_);
-            if ( numTriesSpace < numTries )
-                numTriesSpace = 0;
-
             if ( step > 0 )
                 rubberSpeedFactor = 1 - rubberneeded/step;
             else
@@ -4063,7 +4074,6 @@
         verletSpeed_ = lastSpeed;
         acceleration = lastAcceleration;
         currentFace = lastFace;
-        numTries = 0;
 
         // don't simulate further
         return false;
@@ -4108,7 +4118,6 @@
                 verletSpeed_ = lastSpeed;
                 acceleration = lastAcceleration;
                 currentFace = lastFace;
-                numTries = 0;
                 emergency = true;
 
                 // don't simulate further
@@ -4135,7 +4144,6 @@
             if ( rubber < 0 )
                 rubber = 0;
 
-            numTries = 0;
             emergency = true;
         }
     }
@@ -4209,7 +4217,7 @@
     // give the AI a chance to evade just in time
     if (emergency)
     {
-        RightBeforeDeath(numTries);
+        RightBeforeDeath(0);
     }
 
 #ifdef DEBUGOUTPUT

=== modified file 'src/tron/gCycleMovement.h'
--- src/tron/gCycleMovement.h	2011-07-10 18:22:34 +0000
+++ src/tron/gCycleMovement.h	2019-01-04 23:26:28 +0000
@@ -42,6 +42,10 @@
 class gSensor;
 struct gMaxSpaceAheadHitInfo;
 
+extern void sg_RubberValues( ePlayerNetID const * player, REAL speed, REAL & max, REAL & effectiveness );
+extern REAL sg_brakeCycle;
+extern REAL sg_cycleBrakeDeplete;
+
 //! used to clear out dangerous information from hit info after simulation is done
 class gMaxSpaceAheadHitInfoClearer
 {

=== modified file 'src/tron/gGame.cpp'
--- src/tron/gGame.cpp	2013-11-23 23:37:48 +0000
+++ src/tron/gGame.cpp	2019-01-04 23:26:28 +0000
@@ -3175,8 +3175,8 @@
                     tJUST_CONTROLLED_PTR< eGameObject > e = gameObjects(i);
                     if ( e )
                     {
+                        e->EnsureBorn();
                         e->OnRoundBegin();
-                        e->EnsureBorn();
                     }
                 }
             }

=== modified file 'src/tron/gSensor.h'
--- src/tron/gSensor.h	2006-07-31 05:05:12 +0000
+++ src/tron/gSensor.h	2019-01-04 23:26:28 +0000
@@ -40,7 +40,7 @@
 public:
     gSensorWallType type;
 
-    gSensor(eGameObject *o,const eCoord &start,const eCoord &d)
+    gSensor(eGameObject const * o,const eCoord &start,const eCoord &d)
             :eSensor(o,start,d), type(gSENSOR_NONE){}
 
     virtual void PassEdge(const eWall *w,REAL time,REAL,int =1);

=== modified file 'src/tron/gWall.cpp'
--- src/tron/gWall.cpp	2013-10-28 22:02:36 +0000
+++ src/tron/gWall.cpp	2019-01-04 23:26:28 +0000
@@ -1591,13 +1591,11 @@
 
 void gNetPlayerWall::MyInitAfterCreation()
 {
-#ifndef DEDICATED
     // put yourself into rendering list
     if ( cycle_ )
     {
         Insert( cycle_->displayList_.wallList_ );
     }
-#endif
 
     //w=
 #ifdef DEBUG
@@ -2027,8 +2025,10 @@
 
 eCoord gNetPlayerWall::Vec()
 {
-    if ( edge_ ) return edge_->Vec();
-    else return eCoord();
+    return end - beg;
+    // Odd, this code would never return something useful, but was here.
+    // if ( edge_ ) return edge_->Vec();
+    // else return eCoord();
 }
 
 gPlayerWall *gNetPlayerWall::Wall(){

=== added file 'src/tron/zone/zAI.cpp'
--- src/tron/zone/zAI.cpp	1970-01-01 00:00:00 +0000
+++ src/tron/zone/zAI.cpp	2019-01-04 23:26:28 +0000
@@ -0,0 +1,290 @@
+/*
+
+*************************************************************************
+
+ArmageTron -- Just another Tron Lightcycle Game in 3D.
+Copyright (C) 2005  by 
+and the AA DevTeam (see the file AUTHORS(.txt) in the main source directory)
+
+**************************************************************************
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+  
+***************************************************************************
+
+*/
+
+#include "zAI.h"
+
+#include "zZone.h"
+#include "zShape.h"
+#include "gCycle.h"
+
+#include "eDebugLine.h"
+
+// *************************
+// * Zone attack/defense   *
+// *************************
+
+//!@param cycle the cycle to control
+//!@param zone  the zone to protect/attack
+//!@param random persistent random coordinates
+//!@papam maxstep the maximal delay until the next thought
+zZoneEvaluator::zZoneEvaluator( gCycle const & cycle, zZone const & zone, eCoord & random, REAL maxStep, gCycle * lastBlocker ): gAINavigator::FollowEvaluator( cycle )
+{
+    Init( cycle, zone, random, maxStep, lastBlocker );
+}
+
+zZoneEvaluator::~zZoneEvaluator(){}
+
+void zZoneEvaluator::Init( gCycle const & cycle, zZone const & zone, eCoord & random, REAL maxStep, gCycle * lastBlocker )
+{
+    zShape * shape = zone.getShape();
+    if ( !shape )
+    {
+        return;
+    }
+    
+    eCoord pos    = cycle_.Position();
+    eCoord center = shape->findCenter();
+
+    // REAL insideness = (pos-center).NormSquared()/(edge-center).NormSquared();
+        
+    eCoord tailToChase, tailToChaseVelocity;
+
+    if( zone.Team() == cycle.Team() )
+    {
+        gCycle::WallInfo info;
+            
+        // don't get the real tail. Instead, get a bit in front and extrapolate back.
+        REAL endOffset = cycle.GetTurnDelay();
+        if( maxStep > endOffset )
+        {
+            endOffset = maxStep;
+        }
+
+        cycle.FillWallInfo( info, .5, -endOffset*cycle.Speed() );
+
+        tailToChaseVelocity = info.tailDir * cycle.Speed();
+        tailToChase = info.tailPos - tailToChaseVelocity * endOffset;
+
+        {
+            // blend in standard circular path
+            REAL blend = 2 - cycle.GetDistance()/cycle.ThisWallsLength();
+            if ( blend > 0 )
+            {
+                if( blend > 1 )
+                {
+                    blend = 1;