class Plan
{
    private:
        std::deque sub_plans_;
    public:
        virtual void execute(SOLDIERTYPE* pSoldier) {std::for_each(sub_plans_.begin(),
                sub_plans_.end(), [] (Plan* p) {p->execute;})}// Oh right, no λ-expressions without C++11... so when did you say we wanted to migrate?
        virtual void add_sub_plan(Plan* p) {sub_plans_.push_back(p);}
};

class PickupItemPlan: public Plan {...};
class MovementPlan: public Plan {...};
class ExplorationPlan: public Plan {...};

class PlanFactory
{
    private:
    public:
        virtual Plan* generate_plan(const SOLDIERTYPE* pSoldier) = 0;
        virtual void update_plan(const SOLDIERTYPE* pSoldier, Plan* plan_to_update) = 0;
};

class EliteSniperPlanFactory : public PlanFactory
{
    private:
    public:
        virtual Plan* generate_plan(const SOLDIERTYPE* pSoldier)
        {
            Plan* result = new Plan(pSoldier);
            result->add_sub_plan(new SeekCoverPlan(pSoldier));
            result->add_sub_plan(new AimAtDirectionPlan(pSoldier));
            result->add_sub_plan(new DontMovePlan(pSoldier)); // Hey, I've got no clue about military strategy, but my snipers don't run at the nearest enemy they hear...
            return result;
        }
...
};

class CivilianPlanFactory: public PlanFactory {...};


class ScriptingPlanFactory: public PlanFactory
{
        virtual Plan* generate_plan(const SOLDIERTYPE* pSoldier)
        {
            Plan* result = new Plan(pSoldier);
            while(ReadScript(pSoldier->script_filename))
                result->add_sub_plan(script.step()); // well, that's a little oversimplified, I know, but you get the idea.
            return result;
        }
};

// in some global structure:
std::vector planners_; // where would that be, exactly? Haven't looked much outside the AI code yet...
// initialization:
planners_[0] = new /* ConcretePlanFactory defined by ini_file_planner_for_type_0_plans; I won't bore you with impl detail... */
planners_[1] = new ...
...

#include "sgp.h"
#include "Sound Control.h"
#include "overhead types.h"
#include "overhead.h"
#include "Event Pump.h"
#include "weapons.h"
#include "Animation Control.h"
#include "sys globals.h"
#include "Handle UI.h"
#include "Isometric Utils.h"
#include "worldman.h"
#include "math.h"
#include "points.h"
#include "ai.h"
#include "los.h"
#include "renderworld.h"
#include "opplist.h"
#include "interface.h"
#include "message.h"
#include "campaign.h"
#include "items.h"
#include "text.h" 
#include "Soldier Profile.h"
#include "tile animation.h"
#include "Dialogue Control.h"
#include "SkillCheck.h"
#include "explosion control.h"
#include "Quests.h"
#include "Physics.h"
#include "Random.h"
#include "Vehicles.h"
#include "bullets.h"
#include "morale.h"
#include "meanwhile.h"
#include "SkillCheck.h"
#include "gamesettings.h"
#include "SaveLoadMap.h"
#include "Debug Control.h"
#include "expat.h"
#include "XML.h"
#endif 

#include "sgp.h"
#include "Sound Control.h"
#include "expat.h"
#include "XML.h"

[Modularized Tactical AI] 
; DO NOT, repeat NOT add 'comments', spaces, or other stuff after the factory
; names. The ini reader doesn't separate it from the data string.
; Factory_n is used for any npc with bAIIndex set to n. Currently, the index is
; copied from bTeam; I hope that somebody can integrate it into the map editor
; soon. Then you can add any number of indices (up to 65535, that is), but they
; must be consecutive.

; Currently implemented factories:
; NullPlanFactory - makes an NPC do absolutely nothing
; LegacyAIPlanFactory - makes an NPC behave "as before"

; Increase NumFactories accordingly
NumFactories = 11

; not used
Factory_0  = NullPlanFactory

; 'OUR_TEAM', so not really used either (?) 
Factory_1  = NullPlanFactory

; 'ENEMY_TEAM'
Factory_2  = LegacyAIPlanFactory

; CREATURE_TEAM
Factory_3  = LegacyAIPlanFactory

; MILITIA_TEAM
Factory_4  = LegacyAIPlanFactory

; CIV_TEAM
Factory_5  = LegacyAIPlanFactory

; PLAYER_PLAN (?) 
Factory_6  = LegacyAIPlanFactory

; LAN_TEAM_ONE
Factory_7  = LegacyAIPlanFactory

; LAN_TEAM_TWO
Factory_8  = LegacyAIPlanFactory

; LAN_TEAM_THREE
Factory_9  = LegacyAIPlanFactory

; LAN_TEAM_FOUR
Factory_10 = LegacyAIPlanFactory

Plan* LegacyAIPlanFactory::create_plan(SOLDIERTYPE* npc, const AIInputData& input)
  {
      ... 
      if(npc->ubBodyType == CROW)
      {   
          CrowSeekCorpsePlan* seek_corpse = new CrowSeekCorpsePlan(npc);
          CrowPeckPlan* peck = new CrowPeckPlan(npc, seek_corpse->get_corpse_grid());
          PlanList* find_supper = new PlanList(npc);
          find_supper->add_subplan(seek_corpse);
          find_supper->add_subplan(peck);
          return find_supper;
      }   
      ... 
  }

Plan* LegacyAIPlanFactory::update_plan(SOLDIERTYPE* npc, const AIInputData& input)
  {
      ... 
      if(npc->ubBodyType == CROW && input.is_sound_event())
      {   
          if(!dynamic_cast(npc->ai_masterplan_)) // make sure this crow doesn't already plan to fly away
          {   
              if(npc->ai_masterplan_)
                  delete npc->ai_masterplan_;
              npc->ai_masterplan_ = new CrowFlyAwayPlan(npc);
          }   
          return;
      }   
  }

class RandomPointIter
{   
    private:
    public:
        RandomPointIter() {}; 
        INT32 operator*() {return rand() % MAX_MAP_POS;}
        RandomPointIter operator++() {return *this;}
        RandomPointIter operator++(int) {return *this;}
        bool operator==(const RandomPointIter& other) const {return false;}
        bool operator!=(const RandomPointIter& other) const {return true;}
};