horrible-harry/wordplay.cpp

#include "charman.h"
#include "images.h"
#include "lastseen.h"
#include "logs_utils.h"
#include "render.h"
#include "terminal.h"
#include "utils.h"
#include "zf_log.h"
#include <iomanip>
#include <regex>
#include <sstream>
#include <string.h>
#include <string>
#include <unistd.h> // write
#include <vector>

extern struct console_details console;

#define BSIZE 512

/*
 * harry_idle_event(fd)
 *
 * User is idle, let's let them know we're here.  HAHAHA!
 *
 */
void harry_idle_event(int fd) {
  // Make something happen
  std::ostringstream buffer;
  int r;
  int level = harry_level();
  if (!level)
    return;

  // This is no where near finished, BUT!
  // Do not put any ^ codes in these -- the strlen() would be wrong.
  const char *phrases[] = {"Hahaha",    "Snicker, snicker", "Boo!",
                           "MeOW",      "I see U",          "Arrooo!",
                           "Ahh-wooo!", "Aaaooo!"};

  static LastSeen last_seen_harry_event(2);

  do {
    r = randint((sizeof(phrases) / sizeof(char *)));
  } while (last_seen_harry_event.seen_before(r));

  int color = randint(15) + 1;
  // %02d = std::setfill('0') << std::setw(2) << (int)

  buffer << "^CS^S2^C" << std::setfill('0') << std::setw(2) << color
         << phrases[r] << "^P2^CR^D" << std::setw(2) << strlen(phrases[r]);

  std::string str = buffer.str();
  ZF_LOGD("harry_event: render(%d, \"%s\")", fd, str.c_str());
  render(fd, str);
}

void init_harry() {
  // init_have_seen(last_seen_harry_event, MAX_HARRY_EVENT_DUPS);
  // ZF_LOGD("init => %d %d", last_seen_harry_event[0],
  // last_seen_harry_event[1]);
  console_init(&console);
}

// char words[] = "[a-zA-Z]+( [a-zA-Z]+)+";

int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
  static int ANSI_CLS_count = 0;
  ZF_LOGI("seen: ANSI_CLS");
  ANSI_CLS_count++;

  int level = harry_level();
  if (!level)
    return 0;

  if (ANSI_CLS_count > 1) {

    // if (random_activate((level + 1) / 2)) {
    if (random_activate(level * 5)) {
      std::ostringstream display;
      int needs_cls = 0;

      struct image {
        const char **lines;
        int size;
        int cls;
        int width; // height = size
      } images[] = {{ghost, sizeof(ghost) / sizeof(char *), 1, 0},
                    {ghead, sizeof(ghead) / sizeof(char *), 1, 0},
                    {wolf, sizeof(wolf) / sizeof(char *), 1, 0},
                    {panther, sizeof(panther) / sizeof(char *), 1, 0},
                    {bat, sizeof(bat) / sizeof(char *), 1, 0},
                    {icu, sizeof(icu) / sizeof(char *), 0, 20},
                    {skull, sizeof(skull) / sizeof(char *), 0, 19},
                    {skullblink, sizeof(skullblink) / sizeof(char *), 0, 19}};

      static LastSeen last_files(2);
      int r;

      do {
        r = randint((sizeof(images) / sizeof(image)));
      } while (last_files.seen_before(r));

      std::string fgoto;

      if (!images[r].cls) {
        int x = 0, y = 0;

        x = randint(79 - images[r].width) + 1;
        y = randint(24 - images[r].size) + 1;

        display << "^CS^f" << std::setfill('0') << std::setw(2) << x
                << std::setw(2) << y << "\x1b[1;1H";
        fgoto = display.str();
        // reset display
        display.str(std::string());
        display.clear();
      } else {
        fgoto.assign("^CS^F");
      }

      needs_cls = images[r].cls;

      // I get what's happening.  Mystic moves cursor to home, CLS, cursor
      // home. When we get here, we're ALWAYS at the top of the screen...
      // Hence our bat isn't displayed at the end of the screen.

      // This is before the actual CLS, so we CLS before displaying our files.
      // I tried a ^P2 before doing this .. but I'd rather have the picture up
      // right away I think.

      // Ok, yes, there's no filename being sent.  :P
      render_image(images[r].lines, images[r].size);

      display << (needs_cls ? "\x1b[2J" : "") << fgoto << "^CR^P3";

      std::string display_output = display.str();

      ZF_LOGI("mangle(ANSI_CLS): %d file inserted %s", r,
              repr(display_output.c_str()));

      // Move the buffer so there's room for the display string.
      buffer.insert(pos, display_output);
      work.insert(pos, std::string(display_output.size(), ' '));
      return 1; // need_render = 1;
    } else {
      // if (random_activate((level + 1) / 2)) {
      if (random_activate(level * 5)) {
        int r;
        std::ostringstream display;

        const char *phrasing[] = {
            "^R1Haha^P1ha^P1ha", "Poof!", "Got U", "Anyone there?",
            "^R1Knock, ^P1Knock",
            /*
            This picks random color and position -- then
            homes cursor and changes to another color.  (This can be seen.)
             */
            "^G0101^C07^S9Segmentation fault (core dumped)^P2"};
        static LastSeen last_phrasing(2);

        ZF_LOGI("mangle(ANSI_CLS)");

        do {
          r = randint(sizeof(phrasing) / sizeof(char *));
        } while (last_phrasing.seen_before(r));

        int color = randint(14) + 1;
        int x = randint(30) + 1;
        int y = randint(15) + 1;

        /*
        Don't have it pause there before moving the cursor.

        Move the cursor, get the color changed, THEN pause.
        Then act all crazy.

        NOTE:  Make sure if you use any ^R Render effects, turn them off
        before trying to display the restore_color.  :P   ^R0 Also, make
        sure you re-home the cursor ^G0101 because that's where they are
        expecting the cursor to be!  (At least it's how Mystic does it.)

        HOME, CLS, HOME, ...  Not sure what others do there.  We'll see.
        */

        if (strncmp(phrasing[r], "^G", 2) == 0) {
          display << "^CS^S3^P1" << phrasing[r] << "^S0^R0^CR^P1^G0101";
          // This starts with a GOTO, so don't use our random position
        } else {
          display << "^CS^G" << std::setw(2) << std::setfill('0') << x
                  << std::setw(2) << y << "^S3^C" << std::setw(2) << color
                  << "^P1" << phrasing[r] << "^S0^R0^CR^P1^G0101";
        };

        std::string display_output = display.str();

        // Added debug statement so we can identify what was sent... color,
        // number picked and what that is
        ZF_LOGD("mangle(ANSI_CLS): Inserted color=%02d r=%d phrase='%s'", color,
                r, phrasing[r]);
        ZF_LOGI("mangle(ANSI_CLS): %d %s", r, repr(display_output.c_str()));

        // Move the buffer so there's room for the display string.
        buffer.insert(pos, display_output);
        work.insert(pos, std::string(display_output.size(), ' '));
        return 1; // need_render = 1;
      }
    }
  }
  return 0;
}

int mangle(int fd, std::string &buffer) {
  // a simple default for now.
  // ZF_LOGV("mangle [%s]", logrepr(buffer.c_str()));
  ZF_LOGV_LR("mangle:", buffer);
  /*
  ZF_LOGV_MEM(buffer.data(), buffer.size(), "mangle(%d): %lu bytes", fd,
              buffer.size());
  */

  int need_render = 0;
  int mangled = 0;
  int mangled_chars = 0;
  static std::string work;
  static size_t work_size = 0;

  work.assign(buffer);

  // This should allow us to monitor any memory allocations
  if (work.capacity() != work_size) {
    ZF_LOGD("work cap %lu -> %lu", work_size, work.capacity());
    work_size = work.capacity();
  }

  int level = harry_level();
  std::ostringstream new_buffer;
  std::smatch match;

  if (level) {
    // Strings are good, but Regex is better
    // Mystic BBS v1.12 A43 for Linux Node 1
    // Mystic BBS Version 1.12 A45
    static int bbs_match = 0;

    if (!bbs_match) {
      std::regex bbs_what(
          "(?:Mystic BBS Version [0-9.]+ A[0-9]+)|(?:Mystic BBS "
          "v[0-9.]+ A[0-9]+ for Linux Node [0-9]+)");
      // std::regex bbs_what("Mystic BBS Version [0-9.]+ A[0-9]+");
      // std::regex_constants::ECMAScript);

      // Mystic BBS v[0-9.]+ A[0-9]+ for Linux Node [0-9]+

      if (std::regex_search(buffer, match, bbs_what)) {
        // We have a match
        ZF_LOGD("bbs_seen");
        bbs_match = 1;
        std::string old_string =
            buffer.substr(match.position(0), match.length(0));

        // Build a new and better string
        std::string new_string;
        const char *bbs_systems[] = {
            "Haunted BBS",   "Harry's BBS", "Scary BBS Software",
            "Screaming BBS", "Fright BBS",  "Gravestone BBS",
        };
        const char *operating_systems[] = {
            "OS/360",   "CP/M",       "OS/9",
            "Xenix",    "MS-DOS",     "PC-DOS",
            "DR-DOS",   "QNX",        "Novell Netware",
            "AmigaOS",  "Windows NT", "Windows CE",
            "AIX",      "OS/2",       "OS/400",
            "NeXTSTEP", "MINIX",      "Solaris",
            "Plan 9",   "FreeBSD",    "Windows 95",
            "Palm OS",  "Mac OS X",   "Windows XP",
            "DESQview",
        };

        int r = randint(sizeof(bbs_systems) / sizeof(char *));
        new_buffer << bbs_systems[r] << " v" << randint(10) << "."
                   << randint(80);
        new_buffer << " for ";

        r = randint(sizeof(operating_systems) / sizeof(char *));
        new_buffer << operating_systems[r] << " Node " << randint(150 * level);
        new_string = new_buffer.str();
        // reset buffer
        new_buffer.str(std::string());
        new_buffer.clear();

        replace(buffer, old_string, new_string);
        replace(work, old_string, new_string);
        level = 0; // temp turn off the manglers!  ;)
      }
    }

    static int author_match = 0;

    if (!author_match) {
      static std::regex author("Copyright \\(C\\) [0-9-]+ By James Coyle");

      if (std::regex_search(buffer, match, author)) {
        // We have a match
        ZF_LOGD("author seen");
        author_match = 1;
        std::string old_author =
            buffer.substr(match.position(0), match.length(0));

        // Build a new and better string
        const char *coder_names[] = {"Horrible Harry", "Ghost Writer",
                                     "Sands of Time", "Spector Software",
                                     "Creepy Coder"};
        if (randint(10) < 5)
          new_buffer << "Copyfright ";
        else
          new_buffer << "Copyright ";

        new_buffer << "(C) " << 1000 + randint(999) << "-" << randint(24000)
                   << " By ";
        int r = randint(sizeof(coder_names) / sizeof(char *));
        new_buffer << coder_names[r];
        std::string new_author = new_buffer.str();

        replace(buffer, old_author, new_author);
        replace(work, old_author, new_author);
        level = 0;
      }
    }
  }

  const char *ANSI_CLS = "\x1b[2J";
  size_t pos = buffer.find(ANSI_CLS);

  if (pos != std::string::npos) {
    if (level)
      if (mangle_clrscr(buffer, work, pos)) {
        need_render = 1;
      }
  }

  static std::string text;
  static std::vector<int> text_offsets;
  size_t stri;

  text.clear();
  text_offsets.clear();

  for (stri = 0; stri < buffer.size(); ++stri) {
    termchar tc = console_char(&console, work[stri]);

    if (tc.in_ansi) {
      if (tc.ansi != START) {
        // Ok, this is something.  What is it?
        // ZF_LOGV("ANSI type %d at %lu", tc.ansi, stri);
        switch (tc.ansi) {
        case CURSOR:
        case CLEAR:
        case OTHER:
          text.append(1, '.');
          text_offsets.push_back(-1);
          break;
        case START:
        case COLOR:
          // text.append(1, ' ');
          // text_offsets.push_back(-1);
          // color changes show as nothing in the text string.
          break;
        }
      }
    } else {
      // These should never get out of sync ...
      if (text.size() != text_offsets.size()) {
        ZF_LOGE("Error: text != text_offsets %lu != %lu", text.size(),
                text_offsets.size());
      }
      text.append(1, work[stri]);
      text_offsets.push_back(stri);
    }
  }

  // Control buffer debugging output.
#ifndef NO_BUFFER_DEBUG
  // ZF_LOGV_LR("mangle:", buffer);
  ZF_LOGV_LR("Buffer:", buffer);
  ZF_LOGV_LR("Work:", work);
  ZF_LOGV_LR("Text:", text);
  // ZF_LOGV("Buffer: %s", logrepr(buffer.c_str()));
  // ZF_LOGV("Work: %s", logrepr(work.c_str()));
  // ZF_LOGV("Text: %s", logrepr(text.c_str()));

  // ZF_LOGV_MEM(buffer.data(), buffer.size(), "Buffer:");
  // ZF_LOGV_MEM(work.data(), work.size(), "Work:");
  // ZF_LOGV_MEM(text.data(), text.size(), "Text Buffer:");

  // Output vector contents
  std::ostringstream oss;
  int comma = 0;
  for (auto it = std::begin(text_offsets); it != std::end(text_offsets); ++it) {
    if (comma) {
      oss << ", ";
    };
    comma++;
    oss << *it;
    if (comma == 30) {
      std::string temp_output = oss.str();
      ZF_LOGV("Vector: %s", temp_output.c_str());
      // reset ostringstream
      oss.str(std::string());
      oss.clear();
      comma = 0;
    }
  }
  std::string vector_output = oss.str();
  ZF_LOGV("Vector: %s", vector_output.c_str());

  // reset oss (if we need it)
  oss.str(std::string());
  oss.clear();
#endif

  // Begin the mangle process 2.0
  if (level) {
    ZF_LOGD("CharMan");
    CharMan cm(buffer, work, text, text_offsets);
    ZF_LOGD("CharMan %d, %d chars, render %d", cm.mangle_count, cm.mangle_chars,
            cm.need_render);
    if (cm.need_render)
      need_render = 1;
  };

  if (need_render) {
    render(fd, buffer);
  } else {
    write(fd, buffer.data(), buffer.size());
    console_receive(&console, buffer);
  }
  return need_render;
}