Harry level > 2, mangles intro.

render.cpp

@@ -1,12 +1,12 @@
+#include "render.h"
+#include "terminal.h"
+#include "zf_log.h"
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h> // usleep
-
-#include "render.h"
-#include "terminal.h"
-#include "zf_log.h"
+#include <vector>
 
 extern const char *strnstr(const char *source, int len, const char *needle);
 extern const char *repr(const char *data);
@@ -241,6 +241,7 @@ int send_image(int fd, int x, int y) {
   return 1;
 }
 
+#ifdef UNWANTED
 int send_file(int fd, char *filename) {
   FILE *fp;
   char buffer[100];
@@ -290,6 +291,7 @@ int send_file(int fd, int x, int y, char *filename) {
   fclose(fp);
   return 1;
 }
+#endif
 
 int digit(std::string str, size_t &pos, int digits = 1) {
   int i = 0;
@@ -307,6 +309,8 @@ int digit(std::string str, size_t &pos, int digits = 1) {
   return i;
 }
 
+static std::vector<console_details> console_history;
+
 /**
  * process_trigger( fd, str, &pos )
  *
@@ -335,9 +339,21 @@ void process_trigger(int fd, std::string str, size_t &pos) {
 
   case 'C': {
     i = 0;
+    if (str[pos] == 'S') {
+      pos++;
+      console_history.push_back(console);
+      ZF_LOGI("saved color.");
+      break;
+    }
     if (str[pos] == 'R') {
       pos++;
-      const char *restore = color_restore(&console);
+      if (console_history.empty()) {
+        ZF_LOGE("Trying to Color Restore from empty vector!");
+        break;
+      }
+      console_details old_color = console_history.back();
+      console_history.pop_back();
+      const char *restore = color_restore(&old_color);
       write(fd, restore, strlen(restore));
       break;
     }

render.h

@@ -13,9 +13,11 @@ int ms_sleep(unsigned int ms);
 void render_sleep(void);
 
 void write_color(int fd, int color);
-int send_file(int fd, char *filename);
 void send_goto(int fd, int x, int y);
+/*
+int send_file(int fd, char *filename);
 int send_file(int fd, int x, int y, char *filename);
+*/
 const char *process_trigger(int fd, const char *cp);
 void process_trigger(int fd, std::string str, size_t &pos);
 void render_effect(int fd, char ch);

utils.cpp

@@ -333,6 +333,14 @@ std::map<std::string, std::string> read_configfile(std::string filename) {
   return config;
 }
 
+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;
+    str.replace(start_pos, from.length(), to);
+    return true;
+}
+
 IConv::IConv(const char *to, const char *from) : ic(iconv_open(to, from)) {}
 IConv::~IConv() { iconv_close(ic); }
 

utils.h

@@ -35,6 +35,7 @@ void string_toupper(std::string &str);
 void string_trim(std::string &value);
 std::map<std::string, std::string> read_configfile(std::string filename);
 extern std::map<std::string, std::string> CONFIG;
+bool replace(std::string& str, const std::string& from, const std::string& to);
 
 int harry_level(void);
 

wordplay.cpp

@@ -1,18 +1,17 @@
+#include "charman.h"
 #include "images.h"
 #include "lastseen.h"
 #include "render.h"
 #include "terminal.h"
 #include "utils.h"
+#include "zf_log.h"
 #include <iomanip>
-// #include <regex.h>
+#include <regex>
 #include <sstream>
 #include <string.h>
 #include <string>
 #include <vector>
 
-#include "charman.h"
-#include "zf_log.h"
-
 #include <unistd.h> // write
 
 extern struct console_details console;
@@ -48,8 +47,8 @@ void harry_idle_event(int fd) {
   int color = randint(15) + 1;
   // %02d = std::setfill('0') << std::setw(2) << (int)
 
-  buffer << "^S2^C" << std::setfill('0') << std::setw(2) << color << phrases[r]
-         << "^P2^CR^D" << std::setw(2) << strlen(phrases[r]);
+  buffer << "^CS^S2^C" << std::setfill('0') << std::setw(2) << color
+         << phrases[r] << "^P2^CR^D" << std::setw(2) << strlen(phrases[r]);
 
   /*
   slen = snprintf(buffer, sizeof(buffer), "^S2^C%02d%s^P2^CR^D%02d", color, cp,
@@ -84,12 +83,14 @@ int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
     return 0;
 
   if (ANSI_CLS_count > 1) {
+    /*
     // get the restore color value
     struct console_details temp_console;
     memcpy(&temp_console, &console, sizeof(console));
     console_receive(&temp_console, buffer.substr(0, pos));
     std::string restore_color;
     restore_color.assign(color_restore(&temp_console));
+    */
 
     if (random_activate(3)) {
       std::ostringstream display;
@@ -124,7 +125,7 @@ int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
         x = randint(79 - images[r].width) + 1;
         y = randint(24 - images[r].size) + 1;
 
-        display << "^f" << std::setfill('0') << std::setw(2) << x
+        display << "^CS^f" << std::setfill('0') << std::setw(2) << x
                 << std::setw(2) << y << "\x1b[1;1H";
         fgoto = display.str();
         // reset display
@@ -134,7 +135,7 @@ int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
         // render image, home cursor
         // slen = snprintf(fgoto, sizeof(fgoto), "^f%02d%02d\x1b[1;1H", x, y);
       } else {
-        fgoto.assign("^F");
+        fgoto.assign("^CS^F");
       }
 
       needs_cls = images[r].cls;
@@ -150,8 +151,7 @@ int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
       // Ok, yes, there's no filename being sent.  :P
       render_image(images[r].lines, images[r].size);
 
-      display << (needs_cls ? "\x1b[2J" : "") << fgoto << restore_color
-              << "^P3";
+      display << (needs_cls ? "\x1b[2J" : "") << fgoto << "^CR^P3";
 
       // slen = snprintf(display, sizeof(display), "%s%s%s^P3",
       //                 needs_cls ? "\x1b[2J" : "", fgoto, restore_color);
@@ -205,17 +205,15 @@ int mangle_clrscr(std::string &buffer, std::string &work, size_t pos) {
         */
 
         if (strncmp(phrasing[r], "^G", 2) == 0) {
-          display << "^S3^P1" << phrasing[r] << "^S0^R0" << restore_color
-                  << "^P1^G0101";
+          display << "^CS^S3^P1" << phrasing[r] << "^S0^R0^CR^P1^G0101";
           // This starts with a GOTO, so don't use our random position
           // slen = snprintf(display, sizeof(display),
           // "^S3^P1%s^S0^R0%s^P1^G0101",
           //                 phrasing[r], restore_color);
         } else {
-          display << "^G" << std::setw(2) << std::setfill('0') << x
+          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" << restore_color
-                  << "^P1^G0101";
+                  << "^P1" << phrasing[r] << "^S0^R0^CR^P1^G0101";
           // slen = snprintf(display, sizeof(display),
           //                "^G%02d%02d^S3^C%02d^P1%s^S0^R0%s^P1^G0101", x, y,
           //                color, phrasing[r], restore_color);
@@ -263,13 +261,84 @@ int mangle(int fd, std::string &buffer) {
     work_size = work.capacity();
   }
 
+  int level = harry_level();
+
+  if (level > 2) {
+    // Strings are good, but Regex is better
+    // Mystic BBS v1.12 A43 for Linux Node 1
+    static std::regex bbs("Mystic BBS v[0-9.]+ A[0-9]+ for Linux Node [0-9]+");
+    std::smatch match;
+
+    if (std::regex_search(buffer, match, bbs)) {
+      // We have a match
+      std::string old_string =
+          buffer.substr(match.position(0), match.length(0));
+
+      // Build a new and better string
+      std::ostringstream new_buffer;
+      std::string new_string;
+      const char *bbs_systems[] = {"Haunted BBS", "Harry's BBS",
+                                   "Scary Software BBS", "Screaming 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"};
+
+      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(100 * 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; // turn off the manglers!  ;)
+
+      static std::regex author("Copyright \\(C\\) [0-9-]+ By James Coyle");
+      std::smatch match;
+
+      if (std::regex_search(buffer, match, author)) {
+        // We have a match
+        std::string old_author =
+            buffer.substr(match.position(0), match.length(0));
+
+        // Build a new and better string
+        std::string new_author;
+        const char *coder_names[] = {"Horrible Harry", "Ghost Writer",
+                                     "Sands of Time", "Spector Software",
+                                     "Creepy Coder"};
+        if (randint(10) < 4)
+          new_buffer << "Copywrong ";
+        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];
+        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 (mangle_clrscr(buffer, work, pos)) {
-      need_render = 1;
-    }
+    if (level)
+      if (mangle_clrscr(buffer, work, pos)) {
+        need_render = 1;
+      }
   }
 
   // Ok, maybe the work string was a bad idea?
@@ -348,7 +417,6 @@ int mangle(int fd, std::string &buffer) {
   oss.clear();
 
   // Begin the mangle process 2.0
-  int level = harry_level();
   if (level) {
     ZF_LOGD("CharMan");
     CharMan cm(buffer, work, text, text_offsets);