twproxy2/director.cpp

#include "director.h"
#include <boost/format.hpp>
#include "boxes.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
  // do everything proxy_deactivate does ...
  // proxy_deactivate();
  active = false;
  // reset everything back to good state
  talk_direct = true;
  show_client = true;
  count = 0;
}

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 (chain) {
    chain->client_input(input);
    return;
  }

  if (active) {
    if (input == "Q" || input == "q") proxy_deactivate();
    return;
  } else if (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, const std::string &raw_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 at the TWGS main 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);
  }
   */
  if (chain) {
    chain->server_line(line, raw_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);
   */
  if (chain) chain->server_prompt(prompt);
}

void Director::proxy_activate(void) {
  active = true;  // yes, set keep-alive timer.
  to_server(" "); // start keep-alive timer.

  // set other values we need
  talk_direct = false;
  show_client = false;
  /*
  Wait a minute .. this might be confusing.
  Shouldn't I send them the current prompt?
  Just in case we abort in the middle of something?!?
  */
  old_prompt = current_prompt;
  old_raw_prompt = current_raw_prompt;
  to_client("\x1b[0m\n\r");

  /*
  ╔══════════════════════════════╗
  ║    TradeWars Proxy Active    ║
  ╚══════════════════════════════╝
     -=>
  */

  Boxes box(30, 1, true);
  box.boxcolor = "\x1b[1;33;44m";
  box.textcolor = "\x1b[1;33;44m";
  to_client(box.top());
  std::string output = "    TradeWars Proxy \x1b[5mActive\x1b[0;1;33;44m    ";
  to_client(box.row(output));
  to_client(box.bottom());

  std::shared_ptr<Dispatch> menu = std::make_shared<MenuDispatch>(*this);
  chain = menu;
  MenuDispatch *md = static_cast<MenuDispatch *>(&(*menu));
      md->menu_box_color = "\x1b[1;33;44m";
    md->menu_text_color = "\x1b[1;37;44m";
    md->menu_title = "Proxy Menu";
    md->menu_options_color = "\x1b[1;36;40m";

       md->menu_prompt =
        "\x1b[0;31;40m\xdb\xb2\xb1\xb0 \x1b[31;40mRED "
        "\x1b[32;40mGREEN\x1b[30;42m\xdb\xb2\xb1\xb0 \x1b[0m : "; 
      md->lazy = true;
       md->menu = {{"A", "Apple"}, {"B", "Blue"}, {"R", "Rabbit"}, {"Z", "ZOOO!"}};
    md->setNotify([this]() { this->menu_choice(); });
    menu->activate();
/*
  // Using InputDispatch  -- and see have_input
  std::shared_ptr<Dispatch> readline = std::make_shared<InputDispatch>(*this);
  chain = readline;
  InputDispatch *id = static_cast<InputDispatch *>(&(*readline));
  id->prompt = "\x1b[0m    \x1b[1;33;44m-=>\x1b[0m \x1b[1;37;44m";
  id->max_length = 15;
  id->setNotify([this]() { this->have_input(); });
  readline->activate();
*/

}

void Director::menu_choice(void) {
  MenuDispatch * md = dynamic_cast<MenuDispatch *>(&(*chain));
  if (md) {
    if (md->input.empty()) {
      to_client("Menu aborted.\n\r");
      proxy_deactivate();
      return;
    } else {
      std::string text = str(boost::format( "Back from Menu [%1%] was selected.\n\r") % md->input);
      to_client(text);

      md->activate();
    }
  }
}

void Director::have_input(void) {
  ++count;
  InputDispatch *id = dynamic_cast<InputDispatch *>(&(*chain));
  if (id) {
    std::string output =
        str(boost::format("Your Input (%2%): [%1%]\n\r") % id->input % count);
    to_client("\x1b[0m");
    to_client(output);
  } else {
    proxy_deactivate();
    return;
  }
  if (count > 3) {
    proxy_deactivate();
  } else {
    chain->activate();
  }
}

void Director::proxy_deactivate(void) {
  active = false;
  // reset everything back to good state
  talk_direct = true;
  show_client = true;
  /*
  current_prompt = old_prompt;
  current_raw_prompt = old_raw_prompt;
  */
  chain.reset();
  to_client("\n\r");
  to_client(current_raw_prompt);
}

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 << "]";
}