Working mangle (ansi cls). The rest to do.

hharry.cpp

@@ -18,7 +18,6 @@ using namespace std;
 #include <ctype.h>
 #include <stdlib.h> // random()
 
-
 /* Log level guideline:
  * - ZF_LOG_FATAL - happened something impossible and absolutely unexpected.
  *   Process can't continue and must be terminated.
@@ -51,7 +50,7 @@ using namespace std;
 
 // When debugging low-level, use this:
 // #define ZF_LOG_LEVEL ZF_LOG_VERBOSE
-// Except this doesn't work.  It needs to be anywere the 
+// Except this doesn't work.  It needs to be anywere the
 // zf_log.h is included.
 
 // LOGGING with file output
@@ -79,14 +78,12 @@ static int file_output_open(const char *const log_path) {
   return 1;
 }
 
-void log_flush(void) {
-  fflush(g_log_file);
-}
+void log_flush(void) { fflush(g_log_file); }
 
 // END LOGGING
 
-#include "utils.h"
 #include "terminal.h"
+#include "utils.h"
 
 struct console_details console;
 
@@ -392,12 +389,13 @@ int main(int argc, char *argv[]) {
             ZF_LOGV_MEM(buffer, size, "TIMEOUT buffer size=%d", size);
           } else {
             */
-          ZF_LOGI_MEM(buffer.data(), buffer.size(), "TIMEOUT buffer size=%lu", buffer.size());            
+          ZF_LOGI_MEM(buffer.data(), buffer.size(), "TIMEOUT buffer size=%lu",
+                      buffer.size());
           // ZF_LOGI("TIMEOUT buffer size=%lu", buffer.size());
           // }
           // console_receive(&console, buffer, size);
-          ZF_LOGI("console_string");
-          console_string(&console, buffer);
+          ZF_LOGI("console_receive");
+          console_receive(&console, buffer);
           // write(STDOUT_FILENO, buffer, size);
           ZF_LOGI("write buffer");
           write(STDOUT_FILENO, buffer.data(), buffer.size());
@@ -433,7 +431,7 @@ int main(int argc, char *argv[]) {
             // found something!
 
             pos += 2;
-            // play = buffer.substr() wipes out play's reserve. 
+            // play = buffer.substr() wipes out play's reserve.
             // play = buffer.substr(0, pos);
             play.assign(buffer, 0, pos);
             ZF_LOGI("play %lu size, %lu cap", play.size(), play.capacity());

render.cpp

@@ -291,6 +291,123 @@ int send_file(int fd, int x, int y, char *filename) {
   return 1;
 }
 
+int digit(std::string str, size_t &pos, int digits = 1) {
+  int i = 0;
+
+  while (digits > 0) {
+    if (std::isdigit(str[pos])) {
+      i *= 10;
+      i += str[pos] - '0';
+      pos++;
+    } else {
+      ZF_LOGE("digit fail");
+    }
+    digits--;
+  };
+  return i;
+}
+
+/**
+ * process_trigger( fd, str, &pos )
+ *
+ * This process a command trigger.
+ * It has seen TRIGGER, and now it is
+ * processing whatever comes after it.
+ * It will perform the process, and
+ * update pos to whatever is next.
+ */
+void process_trigger(int fd, std::string str, size_t &pos) {
+  char ch = str[pos];
+  int i, x, y;
+  pos++;
+  switch (ch) {
+  case 'D':
+    i = digit(str, pos, 2);
+
+    if ((i > 0) && (i < 80)) {
+      ZF_LOGI("DEL %02d", i);
+
+      for (x = 0; x < i; x++) {
+        write(fd, "\b \b", 3);
+      }
+    };
+    break;
+
+  case 'C': {
+    i = 0;
+    if (str[pos] == 'R') {
+      pos++;
+      const char *restore = color_restore(&console);
+      write(fd, restore, strlen(restore));
+      break;
+    }
+    i = digit(str, pos, 2);
+    write_color(fd, i);
+  } break;
+
+  // no longer takes a filename.  :)
+  case 'F':
+  case 'f': {
+    int UsePos = 0;
+    if (ch == 'f') {
+      UsePos = 1;
+      x = digit(str, pos, 2);
+      y = digit(str, pos, 2);
+      ZF_LOGI("file at (%d, %d)", x, y);
+    }
+    ZF_LOGD("IMAGE (%d lines)", image_size);
+    if (UsePos) {
+      send_image(fd, x, y);
+    } else {
+      send_image(fd);
+    };
+  } break;
+
+  case 'G': {
+    x = digit(str, pos, 2);
+    y = digit(str, pos, 2);
+    char buffer[20]; // row ; column H
+    int slen;
+    ZF_LOGD("GOTO (%d,%d)", x, y);
+    slen = snprintf(buffer, sizeof(buffer), "\x1b[%d;%dH", y, x);
+    if (slen >= sizeof(buffer)) {
+      ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(buffer));
+      buffer[0] = 0;
+    }
+    write(fd, buffer, strlen(buffer));
+  } break;
+
+  case 'R': {
+    i = digit(str, pos);
+    if ((i > 0) && (i < 10)) {
+      ZF_LOGI("RENDER %d", i);
+      current_render.effect = i;
+    } else {
+      current_render.effect = 0;
+    }
+  } break;
+  case 'S': {
+    i = digit(str, pos);
+    if ((i > 0) && (i < 10)) {
+      ZF_LOGI("SPEED %d", i);
+      current_render.speed = i;
+    } else {
+      current_render.speed = 0;
+    }
+  } break;
+  case 'P': {
+    i = digit(str, pos);
+    if ((i > 0) && (i < 10)) {
+      ZF_LOGI("PAWS %d", i);
+      // sleep(i);
+      if (!render_overlimit) {
+        sleep(i);
+      };
+    }
+  } break;
+  }
+}
+
 /**
  * process_trigger( fd, *cp )
  *
@@ -554,3 +671,45 @@ void render(int fd, const char *string_out, int len) {
     cp++;
   }
 }
+
+/**
+ * render( fd, string_out )
+ *
+ * Render an entire string.
+ * Handles TRIGGER.
+ * Renders with effects.
+ */
+void render(int fd, std::string string_out) {
+  reset_render();
+  time_t start = time(NULL);
+  size_t pos = 0;
+  int elapsed;
+  size_t tpos;
+
+  while ((tpos = string_out.find(TRIGGER, pos)) != std::string::npos) {
+    while (pos != tpos) {
+      elapsed = time(NULL) - start;
+      if (elapsed > SLEEP_LIMIT) {
+        render_overlimit = 1;
+        current_render.speed = 0;
+      }
+
+      render_effect(fd, string_out[pos]);
+      pos++;
+    }
+
+    pos += strlen(TRIGGER);
+    process_trigger(fd, string_out, pos);
+  }
+
+  while (pos < string_out.size()) {
+    elapsed = time(NULL) - start;
+    if (elapsed > SLEEP_LIMIT) {
+      render_overlimit = 1;
+      current_render.speed = 0;
+    }
+
+    render_effect(fd, string_out[pos]);
+    pos++;
+  }
+}

render.h

@@ -1,6 +1,8 @@
 #ifndef RENDER_H
 #define RENDER_H
 
+#include <string>
+
 struct render {
   int speed;
   int effect;
@@ -15,9 +17,11 @@ int send_file(int fd, char *filename);
 void send_goto(int fd, int x, int y);
 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);
 void render(int fd, const char *string_out, int len);
-void render_image(const char ** lines, int size);
+void render(int fd, std::string string_out);
+void render_image(const char **lines, int size);
 
 #define TRIGGER "^"
 // Max limit we'll sleep before ignoring effects/speed.

terminal.cpp

@@ -373,7 +373,7 @@ void console_string(struct console_details *cdp, const char *chars) {
 
 // extern void log_flush(void);
 
-void console_string(struct console_details *cdp, std::string chars) {
+void console_receive(struct console_details *cdp, std::string chars) {
 
   ZF_LOGI("console_char %lu chars", chars.size());
 
@@ -386,7 +386,6 @@ void console_string(struct console_details *cdp, std::string chars) {
   // the C++ way
   for (auto strit = chars.begin(); strit != chars.end(); strit++)
     console_char(cdp, *strit);
-
 }
 
 void console_receive(struct console_details *cdp, const char *chars, int len) {

terminal.h

@@ -15,17 +15,11 @@ struct console_details {
   int status;  // 0, 1 or 5 (Blink)
 };
 
-enum ANSI_TYPE {
-  START,
-  CURSOR,
-  COLOR, 
-  CLEAR,
-  OTHER
-};
+enum ANSI_TYPE { START, CURSOR, COLOR, CLEAR, OTHER };
 
 struct termchar {
   int in_ansi;
-  ANSI_TYPE ansi;  // undefined if in_ansi is false
+  ANSI_TYPE ansi; // undefined if in_ansi is false
 };
 
 void console_init(struct console_details *cdp);
@@ -36,5 +30,5 @@ ANSI_TYPE console_ansi(struct console_details *cdp, const char *ansi);
 termchar console_char(struct console_details *cdp, char ch);
 void console_string(struct console_details *cdp, const char *chars);
 void console_receive(struct console_details *cdp, const char *chars, int len);
-void console_string(struct console_details *cdp, std::string chars);
+void console_receive(struct console_details *cdp, std::string chars);
 #endif

wordplay.cpp

@@ -1,21 +1,26 @@
+#include "images.h"
+#include "lastseen.h"
 #include "render.h"
 #include "terminal.h"
 #include "utils.h"
-#include "lastseen.h"
-#include "images.h"
+#include <regex.h>
 #include <string.h>
 #include <string>
-#include <regex.h>
 
 #include "zf_log.h"
- 
+
 #include <unistd.h> // write
 
 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
   char buffer[100];
@@ -28,25 +33,12 @@ void harry_idle_event(int fd) {
   const char *cp;
   static LastSeen last_seen_harry_event(2);
 
-  // Remember the last phrase used,
-  // and don't repeat (the last two)!
-
   do {
     r = randint((sizeof(phrases) / sizeof(char *)));
-    // r = random() % ((sizeof(phrases) / sizeof(char *)) - 1);
   } while (last_seen_harry_event.seen_before(r));
 
-  // ZF_LOGD("%d => %d %d", r, last_seen_harry_event[0],
-  // last_seen_harry_event[1]);
-
   cp = phrases[r];
   int color = random() % 15 + 1;
-  /*
-  int color = random() % 16;
-  if (color == 0) {
-    color++;
-  } // If it's 0 let's make it 1.   // color = (random() % 15) + 1
-  */
 
   slen = snprintf(buffer, sizeof(buffer), "^S2^C%02d%s^P2^CR^D%02d", color, cp,
                   (int)strlen(cp));
@@ -55,7 +47,9 @@ void harry_idle_event(int fd) {
     buffer[0] = 0;
   }
   ZF_LOGD("harry_event: render(%d, \"%s\")", fd, buffer);
-  render(fd, buffer, strlen(buffer));
+  std::string str(buffer);
+  // render(fd, buffer, strlen(buffer));
+  render(fd, str);
 }
 
 void init_harry() {
@@ -404,8 +398,8 @@ int mangle(int fd, const char *buffer, int len) {
         if (!images[r].cls) {
           int x = 0, y = 0;
 
-          x = randint(79 - images[r].width);
-          y = randint(24 - images[r].size);
+          x = randint(79 - images[r].width) + 1;
+          y = randint(24 - images[r].size) + 1;
 
           int slen;
           // render image, home cursor
@@ -675,9 +669,186 @@ int harry_happens(time_t *last_event, int wakeup) {
   return 0;
 }
 
+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++;
+
+  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));
+    char restore_color[30];
+    strncpy(restore_color, color_restore(&temp_console), sizeof(restore_color));
+
+    if (random_activate(3)) {
+      char display[100] = "";
+      int slen;
+      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));
+
+      char fgoto[32];
+
+      if (!images[r].cls) {
+        int x = 0, y = 0;
+
+        x = randint(79 - images[r].width) + 1;
+        y = randint(24 - images[r].size) + 1;
+
+        int slen;
+        // render image, home cursor
+        slen = snprintf(fgoto, sizeof(fgoto), "^f%02d%02d\x1b[1;1H", x, y);
+        if (slen >= sizeof(fgoto)) {
+          ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(fgoto));
+          fgoto[0] = 0;
+        }
+      } else {
+        strcpy(fgoto, "^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);
+
+      slen = snprintf(display, sizeof(display), "%s%s%s^P3",
+                      needs_cls ? "\x1b[2J" : "", fgoto, restore_color);
+      if (slen >= sizeof(display)) {
+        ZF_LOGE("snprintf %d > size %d", slen, (int)sizeof(display));
+        display[0] = 0;
+      }
+      ZF_LOGI("mangle(ANSI_CLS): %d file inserted %s", r, repr(display));
+
+      // Move the buffer so there's room for the display string.
+      buffer.insert(pos, display);
+      work.insert(pos, std::string(strlen(display), ' '));
+      return 1; // need_render = 1;
+    } else {
+      if (random_activate(4)) {
+        int r;
+        char display[100] = "";
+        int slen;
+
+        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) {
+          // 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 {
+          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);
+        };
+        if (slen >= sizeof(display)) {
+          ZF_LOGE("snprintf %d > size %d (Phrase: %d, %s)", slen,
+                  (int)sizeof(display), r, phrasing[r]);
+          display[0] = 0;
+        }
+
+        // sprintf(display, "^P1^S3^C%02d%s^S0^R0%s^P1", color, phrasing[r],
+        // restore_color);
+        // 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));
+
+        // Move the buffer so there's room for the display string.
+        buffer.insert(pos, display);
+        work.insert(pos, std::string(strlen(display), ' '));
+        return 1; // need_render = 1;
+      }
+    }
+  }
+}
 
 int mangle(int fd, std::string buffer) {
   // a simple default for now.
-  ZF_LOGI_MEM(buffer.data(), buffer.size(), "mangle(%d): %lu bytes", fd, buffer.size());
-  write(fd, buffer.data(), buffer.size());
+  ZF_LOGI_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;
+
+  work.assign(buffer);
+
+  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 (need_render) {
+    render(fd, buffer);
+  } else {
+    write(fd, buffer.data(), buffer.size());
+  }
+  return need_render;
 }