hharry.cfg level=4 back calling console_char()

We now have a test where we verify that our effect
doesn't affect ANSI color output.

hharry.cpp

@@ -367,6 +367,11 @@ int main(int argc, char *argv[]) {
   if (!file_output_open((const char *)logfile.c_str()))
     return 2;
 
+  for (auto cit = CONFIG.begin(); cit != CONFIG.end(); ++cit) {
+    ZF_LOGD("Config {%s}:{%s}", (const char *)cit->first.c_str(),
+            (const char *)cit->second.c_str());
+  }
+
   ZF_LOGI("Node: %d", node);
   if (!username.empty()) {
     locate_user(username.c_str());
@@ -504,8 +509,11 @@ int main(int argc, char *argv[]) {
           play.assign(buffer);
           if (harry_level())
             mangle(STDOUT_FILENO, play);
-          else
+          else {
             write(STDOUT_FILENO, play.data(), play.size());
+            console_receive(&console, play);
+          }
+
           /*
           ZF_LOGI("console_receive");
           console_receive(&console, buffer);
@@ -570,8 +578,8 @@ int main(int argc, char *argv[]) {
             // my guess at this point would be zmodem xfer
             ZF_LOGI("Buffer %lu bytes, write only...", buffer.size());
 
-            // console_receive(&console, buffer);
             write(STDOUT_FILENO, buffer.data(), buffer.size());
+            console_receive(&console, buffer);
             buffer.clear();
           }
 

render.cpp

@@ -579,6 +579,14 @@ void render_effect(int fd, char ch) {
   int l;
   char space = ' ';
   char bs = '\b';
+  termchar tc;
+
+  tc = console_char(&console, ch);
+  if (tc.in_ansi) {
+    // We are inside ANSI command, so
+    write(fd, &ch, 1);
+    return;
+  }
 
   switch (effect) {
   case 1:

test-render.cpp

@@ -62,7 +62,7 @@ TEST_F(RenderFixture, ColorTest) {
   ASSERT_GT(fd, 0);
   std::string colors("^C01One^C02Two^C03Three^C04Four");
   render(fd, colors);
-  
+
   int lfd = open(filename, O_RDONLY);
   char buffer[100];
   int len = read(lfd, buffer, sizeof(buffer));
@@ -93,4 +93,25 @@ TEST_F(RenderFixture, ColorTest) {
   }
   ASSERT_EQ(color, 4);
 }
+
+TEST_F(RenderFixture, ColorEffectTest) {
+  std::string colors("^S1^R1\x1b[1;33;44mMEOW!\x1b[0m");
+  render(fd, colors);
+
+  int lfd = open(filename, O_RDONLY);
+  char buffer[100];
+  int len = read(lfd, buffer, sizeof(buffer));
+  if (len == -1) {
+    ASSERT_EQ(errno, 0);
+  }
+  buffer[len] = 0;
+  close(lfd);
+
+  ASSERT_EQ(strstr(buffer, "\x1b[1;33;44m"), buffer);
+  GTEST_COUT << "buffer:" << buffer << std::endl;
+
+  ASSERT_EQ(len, 29);
+  ASSERT_STREQ(buffer, "\x1b[1;33;44mM \bE \bO \bW \b! \b\x1b[0m");
+}
+
 } // namespace

utils.cpp

@@ -1,5 +1,7 @@
 #include "utils.h"
+#include <algorithm> // transform
 #include <fstream>
+#include <sstream>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -283,6 +285,54 @@ std::string &find_new_text(std::ifstream &infile,
   return line;
 }
 
+void string_toupper(std::string &str) {
+  std::transform(str.begin(), str.end(), str.begin(), ::toupper);
+}
+
+void string_trim(std::string &value) {
+  while (*value.begin() == ' ')
+    value.erase(value.begin());
+  while (*(value.end() - 1) == ' ')
+    value.erase(value.end() - 1);
+}
+
+std::map<std::string, std::string> read_configfile(std::string filename) {
+  std::ifstream file(filename);
+  std::string line;
+  std::map<std::string, std::string> config;
+  if (!file.is_open())
+    return config;
+
+  while (std::getline(file, line)) {
+    if ((line[0] == '#') || (line[0] == ';'))
+      continue;
+    if (line.empty())
+      continue;
+
+    // I'm not so sure this part is very good.
+
+    std::istringstream is_line(line);
+    std::string key;
+    if (std::getline(is_line, key, '=')) {
+      string_trim(key);
+      string_toupper(key);
+
+      std::string value;
+      if (std::getline(is_line, value)) {
+        string_trim(value);
+
+        config[key] = value;
+        /*
+                std::cout << "Key: [" << key << "] Value: [" << value << "]"
+                          << std::endl;
+        */
+      }
+    }
+  }
+
+  return config;
+}
+
 IConv::IConv(const char *to, const char *from) : ic(iconv_open(to, from)) {}
 IConv::~IConv() { iconv_close(ic); }
 
@@ -300,6 +350,8 @@ static IConv converter("UTF-8", "CP437");
 
 static time_t last_time = 0;
 
+std::map<std::string, std::string> CONFIG = read_configfile("hharry.cfg");
+
 /*
  * harry_level:
  *
@@ -312,21 +364,30 @@ static time_t last_time = 0;
 int harry_level(void) {
   struct tm *tmp;
   time_t now = time(NULL);
+  static int last = 0;
+
+  auto search = CONFIG.find("LEVEL");
+  if (search != CONFIG.end()) {
+    last = stoi(search->second);
+    return last;
+  }
+
   if (last_time < now + 10) {
     last_time = now;
     // Do our every 10 second checks here
 
     tmp = gmtime(&now);
     if (tmp->tm_mon != 9)
-      return 0;
+      return (last = 0);
     if (tmp->tm_mday < 8)
-      return 1;
+      return (last = 1);
     if (tmp->tm_mday < 15)
-      return 2;
+      return (last = 2);
     if (tmp->tm_mday < 22)
-      return 3;
-    return 4;
+      return (last = 3);
+    return (last = 4);
   }
+  return last;
 }
 
 /*

utils.h

@@ -2,6 +2,7 @@
 #define UTILS_H
 
 #include <fstream>
+#include <map>
 #include <string>
 
 // http://c-faq.com/lib/randrange.html
@@ -21,7 +22,7 @@ int random_activate(int w);
  */
 
 char *repr(const char *data);
-const char * logrepr(const char * input);
+const char *logrepr(const char *input);
 const char *strnstr(const char *source, int len, const char *needle);
 int rstrnstr(const char *buffer, int len, const char *find);
 int string_insert(char *buffer, int max_length, int pos, const char *insert);
@@ -30,6 +31,11 @@ void pcopy(char *pstring, char *str);
 std::string &find_new_text(std::ifstream &infile,
                            std::streampos &last_position);
 
+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;
+
 int harry_level(void);
 
 #include <iconv.h>

wordplay.cpp

@@ -359,6 +359,7 @@ int mangle(int fd, std::string &buffer) {
     render(fd, buffer);
   } else {
     write(fd, buffer.data(), buffer.size());
+    console_receive(&console, buffer);
   }
   return need_render;
 }