Initial working director, decoupled from Session.

This "locks up" when it activates --
but, it's a start!

It gives us the proxy message (on the menu).
It gives us easter eggs.

CMakeLists.txt

@@ -64,8 +64,8 @@ add_test(NAME test-galaxy
   COMMAND test-galaxy)
 
 
-
-ADD_EXECUTABLE( twproxy twproxy.cpp session.cpp dispatchers.cpp boxes.cpp galaxy.cpp )
+# dispatchers.cpp 
+ADD_EXECUTABLE( twproxy twproxy.cpp utils.cpp session.cpp boxes.cpp director.cpp galaxy.cpp )
 TARGET_LINK_LIBRARIES( twproxy ${Boost_LIBRARIES} pthread yaml-cpp)
 
 target_precompile_headers(twproxy PRIVATE pch.hpp)

director.cpp

@@ -0,0 +1,221 @@
+#include "director.h"
+
+#include "galaxy.h"
+#include "logging.h"
+#include "utils.h"
+
+Director::Director() {
+  BUGZ_LOG(warning) << "Director::Director()";
+
+  // active = false;
+  game = 0;  // not in a game
+  proxy_deactivate();
+}
+
+Director::~Director() { BUGZ_LOG(warning) << "Director::~Director()"; }
+
+void Director::client_input(const std::string &input) {
+  // If we're already active, don't try to activate.
+
+  if (!active && (input == "\x1b" || input == "~")) {
+    std::string &prompt = current_prompt; 
+    BUGZ_LOG(trace) << "CI: ACTIVATE prompt shows: [" << prompt << "]";
+
+    if (prompt == "Selection (? for menu): ") {
+      to_client(
+          "\n\rThere's not much we can do here.  Activate in-game at a "
+          "Command prompt.\n\r");
+      to_client(current_raw_prompt);
+      return;
+    }
+
+    // easter-eggs:
+
+    if (prompt == "Enter your choice: ") {
+      to_client(
+          "\n\r\x1b[1;36mI'd choose \x1b[1;37m`T`\x1b[1;36m, but "
+          "that's how I was coded.\n\r");
+      to_client(current_raw_prompt);
+      return;
+    }
+
+    // easter-egg
+    if (prompt == "[Pause]") {
+      to_client(" \x1b[1;36mPAWS\x1b[0m\n\r");
+      to_client(current_raw_prompt);
+      return;
+    }
+
+    if (prompt == "Planet command (?=help) [D] ") {
+      // future:  Activate at planet menu ?
+      return;
+    }
+    //
+    // The command prompt that we're looking for:
+    //
+    // "Command [TL=00:00:00]:[242] (?=Help)? : "
+    // the time, and the sector number vary...
+
+    if (prompt.substr(0, 9) == "Command [") {
+      int len = prompt.length();
+      if (prompt.substr(len - 14) == "] (?=Help)? : ") {
+        proxy_activate();
+        /*
+        to_client("\n\r\x1b[1;34mWELCOME!  This is where the proxy would "
+                  "activate.\n\r");
+        // active = true;
+        // show_client = true;  // because if something comes (unexpected)
+        // from the server? talk_direct = false;
+
+        // but we aren't activating (NNY)
+        to_client(get_prompt());
+        */
+        return;
+      }
+    }
+  }
+  // Ok...
+  if (talk_direct) to_server(input);
+
+  /*
+  if (emit_client_input)
+    emit_client_input(line);
+  */
+}
+
+void Director::server_line(const std::string &line) {
+  // check for if we entered game/left game
+
+  if (line.find("TradeWars Game Server   ") != std::string::npos) {
+    to_client("\rTradeWars Proxy v2++ READY (~ or ESC to activate)\n\r");
+    game = 0;
+    // reset "active game" -- we're back at the menu
+  }
+
+  if (line.find("Selection (? for menu): ") != std::string::npos) {
+    char ch = line[line.length() - 1];
+    if (ch >= 'A' && ch < 'Q') {
+      game = ch;
+      BUGZ_LOG(warning) << "GAME " << game << " activated!";
+    }
+    // not needed (handled by above Game Server check).
+    if (ch == 'Q') game = 0;
+  }
+
+  if (game) {
+    // in-game parsing here.
+  }
+
+  /*
+  if (emit_server_line) {
+    emit_server_line(line);
+  }
+   */
+}
+
+void Director::server_prompt(const std::string &prompt, const std::string &raw_prompt) {
+  current_prompt = prompt;
+  current_raw_prompt = raw_prompt;
+  /*
+  if (emit_server_prompt)
+    emit_server_prompt(prompt);
+   */
+}
+
+void Director::proxy_activate(void) {
+  active = true;  // sets Session keep-alive timer.
+  // set other values we need
+  talk_direct = false;
+  show_client = false;
+}
+
+void Director::proxy_deactivate(void) {
+  active = false;
+  // reset everything back to good state
+  talk_direct = true;
+  show_client = true;
+}
+
+void Director::SL_cimline(const std::string &line) {
+  if (line == ": ENDINTERROG") {
+    SL_parser = nullptr;
+    return;
+  }
+  if (line == ": ") {
+    // do I need to do anything special here for this?
+    return;
+  }
+  if (line.empty()) {
+    SL_parser = nullptr;
+    return;
+  }
+
+  // parse cimline
+  size_t pos = line.find('%');
+  std::string work = line;
+
+  if (pos == line.npos) {
+    // warpcim
+    BUGZ_LOG(fatal) << "warpcim: [" << line << "]";
+    auto warps = split(line);
+    sector_warps sw;
+    for (auto const &w : warps) {
+      if (sw.sector == 0) {
+        sw.sector = stoi(w);
+      } else {
+        sw.add(stoi(w));
+      }
+    }
+    BUGZ_LOG(fatal) << "warpcim: " << sw;
+
+  } else {
+    // portcim
+    struct port p = parse_portcim(line);
+    if (p.sector == 0)
+      BUGZ_LOG(fatal) << "portcim: [" << line << "]";
+    else
+      BUGZ_LOG(fatal) << "portcim: " << p;
+  }
+}
+
+void Director::SL_thiefline(const std::string &line) {
+  size_t pos = line.find("Suddenly you're Busted!");
+  bool busted = pos != line.npos;
+  if (busted) {
+    BUGZ_LOG(fatal) << "set bust";
+    SL_parser = nullptr;
+  } else {
+    pos = line.find("(You realize the guards saw you last time!)");
+    if (pos != line.npos) SL_parser = nullptr;
+  }
+
+  // Are those the two ways to exit from this state?
+}
+void Director::SL_sectorline(const std::string &line) {
+  BUGZ_LOG(fatal) << "sectorline: [" << line << "]";
+}
+
+void Director::SL_portline(const std::string &line) {
+  if (line.empty()) {
+    SL_parser = nullptr;
+    return;
+  }
+  BUGZ_LOG(info) << "portline : " << line;
+  size_t pos = line.find('%');
+  if (pos != line.npos) {
+    // Ok, this is a valid portline
+    std::string work = line;
+    replace(work, "Fuel Ore", "Fuel");
+    BUGZ_LOG(fatal) << "re.split? : [" << work << "]";
+  }
+}
+
+void Director::SL_warpline(const std::string &line) {
+  if (line.empty()) {
+    SL_parser = nullptr;
+    return;
+  }
+
+  // process warp line
+  BUGZ_LOG(fatal) << "warpline: [" << line << "]";
+}

director.h

@@ -0,0 +1,43 @@
+#include "session_common.h"
+
+class Director {
+ public:
+  StringFunc to_client;
+  StringFunc to_server;
+  // What about post ?
+
+  void client_input(const std::string &input);
+  void server_line(const std::string &line);
+  void server_prompt(const std::string &prompt, const std::string &raw_prompt);
+
+  bool active;
+  // not sure if I need these or not?
+  std::string current_raw_prompt;
+  std::string current_prompt;
+
+  void proxy_activate();
+  void proxy_deactivate();
+
+  char game;  // 0 = not in a game
+
+  // not sure on these...  or how I want to use them.
+  // maybe this is the place for these?!
+  // IF these are public -- Session can access them.  :P
+  bool show_client;
+  bool talk_direct;
+
+  // maybe these would work better?
+  std::function<void(bool)> set_show_client;
+  std::function<void(bool)> set_talk_direct;
+
+  Director();
+  ~Director();
+
+ private:
+  StringFunc SL_parser;
+  void SL_cimline(const std::string &line);
+  void SL_thiefline(const std::string &line);
+  void SL_sectorline(const std::string &line);
+  void SL_portline(const std::string &line);
+  void SL_warpline(const std::string &line);
+};

galaxy.cpp

@@ -1,8 +1,13 @@
 #include "galaxy.h"
+
 #include <boost/format.hpp>
+#include <exception>
 #include <ostream>
 #include <string>
 
+// c++ default exceptions list
+// https://en.cppreference.com/w/cpp/error/exception
+
 bool buysell::operator==(const buysell &rhs) const {
   return ((foe[0] == rhs.foe[0]) && (foe[1] == rhs.foe[1]) &&
           (foe[2] == rhs.foe[2]));
@@ -35,14 +40,12 @@ std::ostream &operator<<(std::ostream &os, const port &p) {
 
 sector_warps::sector_warps() {
   sector = 0;
-  for (int x = 0; x < MAX_WARPS; ++x)
-    warps[x] = 0;
+  for (int x = 0; x < MAX_WARPS; ++x) warps[x] = 0;
 }
 
 void sector_warps::add(sector_type new_sector) {
   for (int x = 0; x < MAX_WARPS; ++x) {
-    if (warps[x] == new_sector)
-      return;
+    if (warps[x] == new_sector) return;
     if (warps[x] == 0) {
       warps[x] = new_sector;
       return;
@@ -53,12 +56,11 @@ void sector_warps::add(sector_type new_sector) {
   throw std::out_of_range(message);
 }
 
-std::ostream& operator<<(std::ostream& os, const sector_warps& warps) {
+std::ostream &operator<<(std::ostream &os, const sector_warps &warps) {
   os << "Sector: " << warps.sector << " ";
   for (int x = 0; x < MAX_WARPS; ++x) {
     if (warps.warps[x] != 0) {
-      if (x != 0)
-        os << ",";
+      if (x != 0) os << ",";
       os << warps.warps[x];
     }
   }
@@ -98,7 +100,6 @@ struct port parse_portcim(const std::string line) {
 
   std::smatch matches;
   if (std::regex_match(line, matches, portrx)) {
-
 #ifdef GTEST_DEBUG
     for (size_t x = 1; x < matches.size(); ++x) {
       GTEST_COUT << x << " : " << matches[x] << std::endl;

galaxy.h

@@ -1,13 +1,11 @@
-#include <iostream>
-
-#include <string>
-#include <vector>
-
 #include <array>
 #include <cstdint>
+#include <iostream>
+#include <ostream>
 #include <regex>
 #include <stdexcept>
-#include <ostream>
+#include <string>
+#include <vector>
 
 enum PRODUCT { FUEL = 0, ORG = 1, EQUIP = 2 };
 
@@ -17,18 +15,17 @@ enum PRODUCT { FUEL = 0, ORG = 1, EQUIP = 2 };
 // typedef std::array<bool, 3> buysell;
 struct buysell {
   bool foe[3];
-  bool operator==(const buysell &rhs) const;
-  friend std::ostream& operator<<(std::ostream& os, const buysell& bs);  
+  bool operator==(const buysell& rhs) const;
+  friend std::ostream& operator<<(std::ostream& os, const buysell& bs);
 };
 
 // ostream& operator<<(std::ostream& os, const buysell& bs);
 
-
 // typedef std::array<char, 3> buysell_text;
 struct buysell_text {
   char txt[3];
-  bool operator==(const buysell_text &rhs) const;
-  friend std::ostream& operator<<(std::ostream& os, const buysell_text &bst);
+  bool operator==(const buysell_text& rhs) const;
+  friend std::ostream& operator<<(std::ostream& os, const buysell_text& bst);
 };
 
 #define MAX_WARPS 6
@@ -36,7 +33,7 @@ struct buysell_text {
 typedef uint16_t sector_type;
 
 struct sector_warps {
-  sector_type sector;   // Yes, for debug
+  sector_type sector;  // Yes, for debug
   // std::set<sector_type> warps;  // possibly
   sector_type warps[MAX_WARPS];
   // ports
@@ -45,7 +42,7 @@ struct sector_warps {
   sector_warps();
   void add(sector_type sector);
   // add() that adds warp to end of warps?
-  friend std::ostream& operator<<(std::ostream& os, const sector_warps& warps);  
+  friend std::ostream& operator<<(std::ostream& os, const sector_warps& warps);
 };
 
 /*
@@ -64,25 +61,25 @@ struct sector_warps {
 
 constexpr buysell get_buysell(uint8_t type) {
   switch (type) {
-  case 1: // BBS TTF
-    return {true, true, false};
-  case 2: // BSB TFT
-    return {true, false, true};
-  case 3: // SBB FTT
-    return {false, true, true};
-  case 4: // SSB FFT
-    return {false, false, true};
-  case 5: // SBS FTF
-    return {false, true, false};
-  case 6: // BSS TFF
-    return {true, false, false};
-  case 7: // SSS FFF
-    return {false, false, false};
-  case 8: // BBB TTT
-  case 9:
-    return {true, true, true};
-  default:
-    throw std::invalid_argument("invalid buysell type");
+    case 1:  // BBS TTF
+      return {true, true, false};
+    case 2:  // BSB TFT
+      return {true, false, true};
+    case 3:  // SBB FTT
+      return {false, true, true};
+    case 4:  // SSB FFT
+      return {false, false, true};
+    case 5:  // SBS FTF
+      return {false, true, false};
+    case 6:  // BSS TFF
+      return {true, false, false};
+    case 7:  // SSS FFF
+      return {false, false, false};
+    case 8:  // BBB TTT
+    case 9:
+      return {true, true, true};
+    default:
+      throw std::invalid_argument("invalid buysell type");
   }
 }
 
@@ -96,25 +93,25 @@ constexpr buysell_text text_from_buysell(const buysell market) {
 
 constexpr buysell_text text_from_type(uint8_t type) {
   switch (type) {
-  case 1:
-    return buysell_text{'B', 'B', 'S'};
-  case 2:
-    return buysell_text{'B', 'S', 'B'};
-  case 3:
-    return buysell_text{'S', 'B', 'B'};
-  case 4:
-    return buysell_text{'S', 'S', 'B'};
-  case 5:
-    return buysell_text{'S', 'B', 'S'};
-  case 6:
-    return buysell_text{'B', 'S', 'S'};
-  case 7:
-    return buysell_text{'S', 'S', 'S'};
-  case 8:
-  case 9:
-    return buysell_text{'B', 'B', 'B'};
-  default:
-    throw std::invalid_argument("invalid text_from_type type");
+    case 1:
+      return buysell_text{'B', 'B', 'S'};
+    case 2:
+      return buysell_text{'B', 'S', 'B'};
+    case 3:
+      return buysell_text{'S', 'B', 'B'};
+    case 4:
+      return buysell_text{'S', 'S', 'B'};
+    case 5:
+      return buysell_text{'S', 'B', 'S'};
+    case 6:
+      return buysell_text{'B', 'S', 'S'};
+    case 7:
+      return buysell_text{'S', 'S', 'S'};
+    case 8:
+    case 9:
+      return buysell_text{'B', 'B', 'B'};
+    default:
+      throw std::invalid_argument("invalid text_from_type type");
   }
 }
 
@@ -122,26 +119,26 @@ constexpr uint8_t type_from_buysell(const buysell market) {
   if (market.foe[0]) {
     if (market.foe[1]) {
       if (market.foe[2]) {
-        return 8; // BBB TTT
+        return 8;  // BBB TTT
       } else
-        return 1; // BBS TTF
+        return 1;  // BBS TTF
     } else {
       if (market.foe[2]) {
-        return 2; // BSB TFT
+        return 2;  // BSB TFT
       } else
-        return 6; // BSS TFF
+        return 6;  // BSS TFF
     }
   } else {
     if (market.foe[1]) {
       if (market.foe[2]) {
-        return 3; // SBB FTT
+        return 3;  // SBB FTT
       } else
-        return 5; // SBS FTF
+        return 5;  // SBS FTF
     } else {
       if (market.foe[2]) {
-        return 4; // SSB FFT
+        return 4;  // SSB FFT
       } else
-        return 7; // SSS FFF
+        return 7;  // SSS FFF
     }
   }
 }
@@ -151,7 +148,7 @@ struct port {
   uint8_t type;
   uint16_t amount[3];
   uint8_t percent[3];
-  friend std::ostream& operator<<(std::ostream& os, const port &p);
+  friend std::ostream& operator<<(std::ostream& os, const port& p);
 };
 
 struct port parse_portcim(const std::string line);
@@ -160,7 +157,7 @@ struct port parse_portcim(const std::string line);
 // STARDOCK = 9
 
 class GameData {
-public:
+ public:
   std::map<std::string, std::string> config;
   // warps;
   // ports;

session.cpp

@@ -1,119 +1,65 @@
 #include <boost/bind.hpp>
-#include <iostream>
-
 #include <boost/format.hpp>
+#include <functional>
+#include <iostream>
 // #include <boost/log/core.hpp>
 // #include <boost/log/trivial.hpp>
 
 #include <regex>
+#include <string>
 
 #include "config.h"
+#include "galaxy.h"
 #include "logging.h"
 #include "session.h"
-
-#include "galaxy.h"
-
-#include <string>
+#include "utils.h"
 
 // #include <boost/log/attributes/named_scope.hpp>
 
-bool replace(std::string &str, const std::string &from, const std::string &to) {
-  size_t start_pos = str.find(from);
-  if (start_pos == std::string::npos)
-    return false;
-  do {
-    str.replace(start_pos, from.length(), to);
-  } while ((start_pos = str.find(from)) != std::string::npos);
-  return true;
-}
-
-bool replace(std::string &str, const char *from, const char *to) {
-  size_t start_pos = str.find(from);
-  if (start_pos == std::string::npos)
-    return false;
-  do {
-    str.replace(start_pos, strlen(from), to);
-  } while ((start_pos = str.find(from)) != std::string::npos);
-  return true;
-}
-
-void ansi_clean(std::string &str) {
-  static std::regex ansi_cleaner("\x1b\[[0-9;]*[A-Zmh]",
-                                 std::regex_constants::ECMAScript);
-  str = std::regex_replace(str, ansi_cleaner, "");
-}
-
-void high_ascii(std::string &str) {
-  // the + replaces all of them into one.  I want each high ascii replaced with
-  // #.
-  static std::regex high_cleaner("[\x80-\xff]",
-                                 std::regex_constants::ECMAScript);
-  str = std::regex_replace(str, high_cleaner, "#");
-}
-
-std::smatch ansi_newline(const std::string &str) {
-  static std::regex ansi_nl("\x1b\[[0-9;]*[JK]",
-                            std::regex_constants::ECMAScript);
-  std::smatch m;
-  std::regex_search(str, m, ansi_nl);
-  return m;
-}
-
-std::string clean_string(const std::string &source) {
-  std::string clean = source;
-
-  replace(clean, "\n", "\\n");
-  replace(clean, "\r", "\\r");
-  replace(clean, "\b", "\\b");
-
-  // ANSI too
-  ansi_clean(clean);
-  // BUGZ_LOG(error) << "cleaned: " << clean;
-  high_ascii(clean);
-
-  replace(clean, "\x1b", "^");
-
-  return clean;
-}
-
-std::vector<std::string> split(const std::string &line) {
-  static std::regex rx_split("[^\\s]+");
-  std::vector<std::string> results;
-
-  for (auto it = std::sregex_iterator(line.begin(), line.end(), rx_split);
-       it != std::sregex_iterator(); ++it) {
-    results.push_back(it->str());
-  }
-  return results;
-}
-
 Session::Session(boost::asio::ip::tcp::socket socket,
                  boost::asio::io_service &io_service, std::string hostname,
                  std::string port)
-    : main(this), socket_(std::move(socket)), io_service_{io_service},
-      resolver_{io_service}, server_{io_service}, prompt_timer_{io_service},
-      keep_alive_{io_service}, host{hostname}, port{port} {
+    : socket_(std::move(socket)),
+      io_service_{io_service},
+      resolver_{io_service},
+      server_{io_service},
+      prompt_timer_{io_service},
+      keep_alive_{io_service},
+      host{hostname},
+      port{port} {
   BUGZ_LOG(info) << "Session::Session()";
   // server_sent = 0;
   time_ms = 50;
-  if (CONFIG["prompt_timeout"])
-    time_ms = CONFIG["prompt_timeout"].as<int>();
+  if (CONFIG["prompt_timeout"]) time_ms = CONFIG["prompt_timeout"].as<int>();
 
   keepalive_secs = 45;
-  if (CONFIG["keepalive"])
-    keepalive_secs = CONFIG["keepalive"].as<int>();
-}
+  if (CONFIG["keepalive"]) keepalive_secs = CONFIG["keepalive"].as<int>();
 
-void Session::start(void) {
-  // BOOST_LOG_NAMED_SCOPE();
+  // Initialize the director
+  director.to_server = boost::bind(&Session::to_server, this, _1);
+  director.to_client = boost::bind(&Session::to_client, this, _1);
 
-  // If I want the file and line number information, here's how to do it:
-  // BUGZ_LOG(info) << boost::format("(%1%:%2%) ") % __FILE__ % __LINE__
+  // replace emit_ with below:  if (director.server_line)
+  // director.server_line(s);
+  /*
+    emit_server_line = [this](const std::string &s) {
+      if (director.server_line) {
+        director.server_line(s);
+      }
+    };
+    emit_server_prompt = [this](const std::string &s) {
+      if (director.server_prompt) {
+        director.server_prompt(s);
+      }
+    };
+    emit_client_input ...  => director.client_input
+  */
+}
 
+void Session::start(void) {
   BUGZ_LOG(info) << "Session::start()";
-  auto self(shared_from_this());
-  // read_buffer.reserve(1024);
-  // do_write("Welcome!\n");
+  // auto self(shared_from_this());
+
   client_read();
 }
 
@@ -156,8 +102,6 @@ void Session::on_connect(const boost::system::error_code error) {
   // We've connected to the server!  WOOT WOOT!
   // BOOST_LOG_NAMED_SCOPE("Session");
 
-  SL_parser = nullptr;
-
   if (!error) {
     BUGZ_LOG(info) << "Connected to " << host;
     to_client("Connected...\n\r");
@@ -195,7 +139,9 @@ void Session::on_connect(const boost::system::error_code error) {
  */
 void Session::on_server_line(const std::string &line) {
   BUGZ_LOG(info) << "SL: [" << line << "]";
+  director.server_line(line);
 
+#ifdef DECOUPLE
   if (line.find("TradeWars Game Server   ") != std::string::npos) {
     to_client("\rTradeWars Proxy v2++ READY (~ or ESC to activate)\n\r");
     game = 0;
@@ -228,8 +174,7 @@ void Session::on_server_line(const std::string &line) {
       BUGZ_LOG(warning) << "GAME " << game << " activated!";
     }
     // not needed (handled by above Game Server check).
-    if (ch == 'Q')
-      game = 0;
+    if (ch == 'Q') game = 0;
   }
 
   // Do I need to run through the tests (below) before calling the parser here?
@@ -267,93 +212,8 @@ void Session::on_server_line(const std::string &line) {
   // should I have an internal emit_server_line for parsing sections?
   // rather then having a weird state machine to track where we are?
 
-  if (emit_server_line)
-    emit_server_line(line);
-}
-
-void Session::SL_cimline(const std::string &line) {
-  if (line == ": ENDINTERROG") {
-    SL_parser = nullptr;
-    return;
-  }
-  if (line == ": ") {
-    // do I need to do anything special here for this?
-    return;
-  }
-  if (line.empty()) {
-    SL_parser = nullptr;
-    return;
-  }
-
-  // parse cimline
-  size_t pos = line.find('%');
-  std::string work = line;
-
-  if (pos == line.npos) {
-    // warpcim
-    BUGZ_LOG(fatal) << "warpcim: [" << line << "]";
-    auto warps = split(line);
-    sector_warps sw;
-    for( auto const & w : warps) {
-      if (sw.sector == 0) {
-        sw.sector = stoi(w);
-      } else {
-        sw.add(stoi(w));
-      }
-    }
-    BUGZ_LOG(fatal) << "warpcim: " << sw;
-
-  } else {
-    // portcim
-    struct port p = parse_portcim(line);
-    if (p.sector == 0)
-      BUGZ_LOG(fatal) << "portcim: [" << line << "]";
-    else
-      BUGZ_LOG(fatal) << "portcim: " << p;
-  }
-}
-
-void Session::SL_thiefline(const std::string &line) {
-  size_t pos = line.find("Suddenly you're Busted!");
-  bool busted = pos != line.npos;
-  if (busted) {
-    BUGZ_LOG(fatal) << "set bust";
-    SL_parser = nullptr;
-  } else {
-    pos = line.find("(You realize the guards saw you last time!)");
-    if (pos != line.npos)
-      SL_parser = nullptr;
-  }
-
-  // Are those the two ways to exit from this state?
-}
-void Session::SL_sectorline(const std::string &line) {
-  BUGZ_LOG(fatal) << "sectorline: [" << line << "]";
-}
-
-void Session::SL_portline(const std::string &line) {
-  if (line.empty()) {
-    SL_parser = nullptr;
-    return;
-  }
-  BUGZ_LOG(info) << "portline : " << line;
-  size_t pos = line.find('%');
-  if (pos != line.npos) {
-    // Ok, this is a valid portline
-    std::string work = line;
-    replace(work, "Fuel Ore", "Fuel");
-    BUGZ_LOG(fatal) << "re.split? : [" << work << "]";
-  }
-}
-
-void Session::SL_warpline(const std::string &line) {
-  if (line.empty()) {
-    SL_parser = nullptr;
-    return;
-  }
-
-  // process warp line
-  BUGZ_LOG(fatal) << "warpline: [" << line << "]";
+  if (emit_server_line) emit_server_line(line);
+#endif
 }
 
 /**
@@ -401,7 +261,6 @@ void Session::process_lines(std::string &received) {
   // I also need to break on r"\x1b[\[0-9;]*JK", treat these like \n
 
   while ((pos = server_prompt.find('\n', 0)) != std::string::npos) {
-
     std::string line;
 
     std::smatch m = ansi_newline(server_prompt);
@@ -522,11 +381,11 @@ void Session::set_prompt_timer(void) {
 
 void Session::reset_prompt_timer(void) { prompt_timer_.cancel(); }
 
-void Session::on_server_prompt(const std::string &prompt) {
+// probably no longer needed --
+void Session::on_server_prompt(const std::string &prompt,
+                               const std::string &raw_prompt) {
   BUGZ_LOG(warning) << "SP: [" << prompt << "]";
-  if (emit_server_prompt) {
-    emit_server_prompt(prompt);
-  }
+  director.server_prompt(prompt, raw_prompt);
 }
 
 void Session::on_prompt_timeout(const boost::system::error_code error) {
@@ -539,7 +398,7 @@ void Session::on_prompt_timeout(const boost::system::error_code error) {
 
       std::string clean = clean_string(server_prompt);
       if (!clean.empty()) {
-        on_server_prompt(clean);
+        on_server_prompt(clean, server_prompt);
       }
       // BUGZ_LOG(trace) << "SP: [" << server_prompt << "]";
     }
@@ -609,9 +468,10 @@ void Session::on_resolve(
 }
 
 void Session::client_input(const std::string &input) {
-
   BUGZ_LOG(info) << "CI: " << input;
+  director.client_input(input);
 
+#ifdef DECOUPLE
   // Is "proxy" active
   if (active) {
     // do something amazing with the user's input.
@@ -621,8 +481,9 @@ void Session::client_input(const std::string &input) {
       BUGZ_LOG(trace) << "CI: ACTIVATE prompt shows: [" << prompt << "]";
 
       if (prompt == "Selection (? for menu): ") {
-        to_client("\n\rThere's not much we can do here.  Activate in-game at a "
-                  "Command prompt.\n\r");
+        to_client(
+            "\n\rThere's not much we can do here.  Activate in-game at a "
+            "Command prompt.\n\r");
         to_client(get_prompt());
         return;
       }
@@ -630,8 +491,9 @@ void Session::client_input(const std::string &input) {
       // easter-eggs:
 
       if (prompt == "Enter your choice: ") {
-        to_client("\n\r\x1b[1;36mI'd choose \x1b[1;37m`T`\x1b[1;36m, but "
-                  "that's how I was coded.\n\r");
+        to_client(
+            "\n\r\x1b[1;36mI'd choose \x1b[1;37m`T`\x1b[1;36m, but "
+            "that's how I was coded.\n\r");
         to_client(get_prompt());
         return;
       }
@@ -682,8 +544,10 @@ void Session::client_input(const std::string &input) {
   if (emit_client_input) {
     emit_client_input(input);
   }
+#endif
 }
 
+/*
 DispatchSettings Session::save_settings(void) {
   DispatchSettings ss{emit_server_line, emit_server_prompt, emit_client_input,
                       show_client, talk_direct};
@@ -700,7 +564,7 @@ void Session::restore_settings(const DispatchSettings &ss) {
 
 void Session::proxy_activate(void) {
   active = true;
-  start_keepin_alive(); // kickstart the keepalive timer
+  start_keepin_alive();  // kickstart the keepalive timer
   main.setNotify([this](void) { this->proxy_deactivate(); });
   main.activate();
 }
@@ -711,11 +575,12 @@ void Session::proxy_deactivate(void) {
   to_client(get_prompt());
   // to_client(" \b");
 }
+*/
 
 void Session::client_read(void) {
   auto self(shared_from_this());
 
-  boost::asio::async_read( // why can't I async_read_some here?
+  boost::asio::async_read(  // why can't I async_read_some here?
       socket_, boost::asio::buffer(read_buffer, sizeof(read_buffer) - 1),
       boost::asio::transfer_at_least(1),
       [this, self](boost::system::error_code ec, std::size_t length) {
@@ -779,7 +644,6 @@ void Session::to_client(const std::string &message) {
       socket_, boost::asio::buffer(message),
       [this, self](boost::system::error_code ec, std::size_t /*length*/) {
         if (!ec) {
-
         } else {
           BUGZ_LOG(warning) << "2C: write failed? closed? Server.shutdown()";
           if (connected) {
@@ -792,11 +656,11 @@ void Session::to_client(const std::string &message) {
 
 void Session::to_server(const std::string &message) {
   auto self(shared_from_this());
+  BUGZ_LOG(trace) << "2S: " << message;
   boost::asio::async_write(
       server_, boost::asio::buffer(message),
       [this, self](boost::system::error_code ec, std::size_t /*length*/) {
         if (!ec) {
-
         } else {
           BUGZ_LOG(warning) << "S: write failed? closed? socket.shutdown()";
           // we're no longer connected.
@@ -805,7 +669,7 @@ void Session::to_server(const std::string &message) {
         }
       });
 
-  if (active) {
+  if (director.active) {
     start_keepin_alive();
   }
 }
@@ -820,7 +684,7 @@ void Session::start_keepin_alive(void) {
 void Session::stayin_alive(const boost::system::error_code error) {
   if (error != boost::asio::error::operation_aborted) {
     // stayin' alive, stayin' alive...
-    if (active) {
+    if (director.active) {
       to_server(" ");
       BUGZ_LOG(warning) << "Session::stayin_alive()";
     }
@@ -830,8 +694,11 @@ void Session::stayin_alive(const boost::system::error_code error) {
 Server::Server(boost::asio::io_service &io_service,
                const boost::asio::ip::tcp::endpoint &endpoint,
                const std::string &host, const std::string &port)
-    : io_service_{io_service}, acceptor_{io_service_, endpoint},
-      signal_{io_service, SIGUSR1, SIGTERM}, host_{host}, port_{port} {
+    : io_service_{io_service},
+      acceptor_{io_service_, endpoint},
+      signal_{io_service, SIGUSR1, SIGTERM},
+      host_{host},
+      port_{port} {
   keep_accepting = true;
 
   BUGZ_LOG(info) << "Server::Server()";

session.h

@@ -7,8 +7,10 @@
 #include <map>
 #include <string>
 
+#include "director.h"
 #include "session_common.h"
 
+// don't want this here!
 #include "dispatchers.h"
 
 #define MAX_BUFFER 256
@@ -19,7 +21,7 @@ The Session:
  */
 
 class Session : public std::enable_shared_from_this<Session> {
-public:
+ public:
   Session(boost::asio::ip::tcp::socket socket,
           boost::asio::io_service &io_service, std::string hostname,
           std::string port);
@@ -33,21 +35,25 @@ public:
   void to_client(const std::string &message);
   void to_server(const std::string &message);
 
-  DispatchSettings save_settings(void);
-  void restore_settings(const DispatchSettings &ss);
+  /*
+    DispatchSettings save_settings(void);
+    void restore_settings(const DispatchSettings &ss);
+  */
 
-  // what uses these? how do you use these?
-  StringFunc emit_server_line;
-  StringFunc emit_server_prompt;
-  StringFunc emit_client_input;
+  // The session line parsing needs show_client
+
+  // these move to Director
   bool show_client = true;
   bool talk_direct = true;
 
   void post(notifyFunc nf);
 
-private:
+ private:
+  Director director;
+
   void on_server_line(const std::string &line);
-  void on_server_prompt(const std::string &prompt);
+  void on_server_prompt(const std::string &prompt,
+                        const std::string &raw_prompt);
 
   void parse_auth(void);
   void on_connect(const boost::system::error_code error);
@@ -64,13 +70,16 @@ private:
   void split_lines(std::string line);
   void process_lines(std::string &received);
 
-private:
-  StringFunc SL_parser;
-  void SL_cimline(const std::string &line);
-  void SL_thiefline(const std::string &line);
-  void SL_sectorline(const std::string &line);
-  void SL_portline(const std::string &line);
-  void SL_warpline(const std::string &line);
+ private:
+  /*
+    Move to director  -?
+    StringFunc SL_parser;
+    void SL_cimline(const std::string &line);
+    void SL_thiefline(const std::string &line);
+    void SL_sectorline(const std::string &line);
+    void SL_portline(const std::string &line);
+    void SL_warpline(const std::string &line);
+  */
 
   void set_prompt_timer(void);
   void reset_prompt_timer(void);
@@ -80,13 +89,18 @@ private:
   int time_ms;
   int keepalive_secs;
 
-  MainDispatch main;
-  void proxy_activate(void);
-  void proxy_deactivate(void);
+  // Move this to director.  This controls if the "keep alive" fires or not.
+  bool active = false;
+  /*  Move to director.
+    MainDispatch main;
+    void proxy_activate(void);
+    void proxy_deactivate(void);
 
-  // std::stack<Dispatch *> director;
+    // std::stack<Dispatch *> director;
 
-  bool active = false;
+    bool active = false;
+
+  */
 
   /**
    * The client's socket
@@ -130,13 +144,6 @@ private:
    * This needs to be reset/cleared if there's a \r (carriage return).
    */
   std::string server_prompt;
-  /**
-   * FAIL-WHALE: This was supposed to hold the number of characters
-   * already sent to the user at this point in time, but I'm having
-   * a hard time tracking those.
-   *
-   */
-  // int server_sent;
 
   /**
    * The client read buffer.
@@ -184,14 +191,13 @@ so I probably won't move that just yet.  [NNY!]
 */
 
 class Server {
-
-public:
+ public:
   Server(boost::asio::io_service &io_service,
          const boost::asio::ip::tcp::endpoint &endpoint,
          const std::string &host, const std::string &port);
   ~Server();
 
-private:
+ private:
   void do_accept(void);
   void on_signal(const boost::system::error_code &ec, int signal);
 

utils.cpp

@@ -0,0 +1,73 @@
+#include "utils.h"
+
+#include <regex>
+#include <string>
+#include <vector>
+
+bool replace(std::string &str, const std::string &from, const std::string &to) {
+  size_t start_pos = str.find(from);
+  if (start_pos == std::string::npos) return false;
+  do {
+    str.replace(start_pos, from.length(), to);
+  } while ((start_pos = str.find(from)) != std::string::npos);
+  return true;
+}
+
+bool replace(std::string &str, const char *from, const char *to) {
+  size_t start_pos = str.find(from);
+  if (start_pos == std::string::npos) return false;
+  do {
+    str.replace(start_pos, strlen(from), to);
+  } while ((start_pos = str.find(from)) != std::string::npos);
+  return true;
+}
+
+void ansi_clean(std::string &str) {
+  static std::regex ansi_cleaner("\x1b\[[0-9;]*[A-Zmh]",
+                                 std::regex_constants::ECMAScript);
+  str = std::regex_replace(str, ansi_cleaner, "");
+}
+
+void high_ascii(std::string &str) {
+  // the + replaces all of them into one.  I want each high ascii replaced with
+  // #.
+  static std::regex high_cleaner("[\x80-\xff]",
+                                 std::regex_constants::ECMAScript);
+  str = std::regex_replace(str, high_cleaner, "#");
+}
+
+std::smatch ansi_newline(const std::string &str) {
+  static std::regex ansi_nl("\x1b\[[0-9;]*[JK]",
+                            std::regex_constants::ECMAScript);
+  std::smatch m;
+  std::regex_search(str, m, ansi_nl);
+  return m;
+}
+
+std::string clean_string(const std::string &source) {
+  std::string clean = source;
+
+  replace(clean, "\n", "\\n");
+  replace(clean, "\r", "\\r");
+  replace(clean, "\b", "\\b");
+
+  // ANSI too
+  ansi_clean(clean);
+  // BUGZ_LOG(error) << "cleaned: " << clean;
+  high_ascii(clean);
+
+  replace(clean, "\x1b", "^");
+
+  return clean;
+}
+
+std::vector<std::string> split(const std::string &line) {
+  static std::regex rx_split("[^\\s]+");
+  std::vector<std::string> results;
+
+  for (auto it = std::sregex_iterator(line.begin(), line.end(), rx_split);
+       it != std::sregex_iterator(); ++it) {
+    results.push_back(it->str());
+  }
+  return results;
+}

utils.h

@@ -0,0 +1,16 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <string>
+#include <regex>
+#include <vector>
+
+bool replace(std::string &str, const std::string &from, const std::string &to);
+bool replace(std::string &str, const char *from, const char *to);
+void ansi_clean(std::string &str);
+void high_ascii(std::string &str);
+std::smatch ansi_newline(const std::string &str);
+std::string clean_string(const std::string &source);
+std::vector<std::string> split(const std::string &line);
+
+#endif