Working on galaxy, parsing, etc.

galaxy.cpp

@@ -0,0 +1,71 @@
+#include "galaxy.h"
+
+#include <ostream>
+
+bool buysell::operator==(const buysell &rhs) const {
+  return ((foe[0] == rhs.foe[0]) && (foe[1] == rhs.foe[1]) &&
+          (foe[2] == rhs.foe[2]));
+}
+
+std::ostream &operator<<(std::ostream &os, const buysell &bs) {
+  os << bs.foe[0] << bs.foe[1] << bs.foe[2];
+  return os;
+}
+
+bool buysell_text::operator==(const buysell_text &rhs) const {
+  return ((txt[0] == rhs.txt[0]) && (txt[1] == rhs.txt[1]) &&
+          (txt[2] == rhs.txt[2]));
+}
+
+std::ostream &operator<<(std::ostream &os, const buysell_text &bst) {
+  os << '"' << bst.txt[0] << bst.txt[1] << bst.txt[2] << '"';
+  return os;
+}
+
+struct port parse_portcim(const std::string line) {
+  struct port p;
+  p.sector = std::stoi(line);
+  //  20 - 1708  97% -  710  56%    287  15%
+  static std::regex portrx(
+      "[ ]*([0-9]+) (.)[ ]+([0-9]+)[ ]+([0-9]+%) (.)[ "
+      "]+([0-9]+)[ ]+([0-9]+%) (.)[ ]+([0-9]+)[ ]+([0-9]+%)[ ]*",
+      std::regex_constants::ECMAScript);
+
+  // sector + amount pct + amount pct + amount pct
+  // 1      2 3      4   5 6      7   8 9      10
+
+  // GTEST_COUT << "Sector: " << p.sector << std::endl;
+  // GTEST_COUT << "Line: [" << line << "]" << std::endl;
+
+  buysell port_buysell;
+
+  std::smatch matches;
+  if (std::regex_match(line, matches, portrx)) {
+    if (matches.size() != 11) {
+      // GTEST_COUT << "Now you have 101 problems." << std::endl;
+      p.sector = 0;
+      p.type = 0;
+      return p;
+    }
+    // GTEST_COUT << "matches: " << matches.size() << std::endl;
+    p.sector = stoi(matches[1]);
+    // GTEST_COUT << "sector: " << matches[1] << std::endl;
+    // for (int x = 1; x < 11; ++x) {
+    //   GTEST_COUT << x << " : " << matches[x] << std::endl;
+    // }
+    for (int x = 0; x < 3; ++x) {
+      int pos = x * 3;
+      port_buysell.foe[x] = matches[pos + 2] == "-";
+      p.amount[x] = stoi(matches[pos + 3]);
+      p.percent[x] = stoi(matches[pos + 4]);
+    }
+    p.type = type_from_buysell(port_buysell);
+    // GTEST_COUT << "port is type " << (int)p.type << std::endl;
+    return p;
+  } else {
+    // GTEST_COUT << "regex_match failed." << std::endl;
+    p.type = 0;
+    p.sector = 0;
+    return p;
+  }
+}

galaxy.h

@@ -0,0 +1,142 @@
+#include <iostream>
+
+#include <string>
+#include <vector>
+
+#include <array>
+#include <cstdint>
+#include <regex>
+#include <stdexcept>
+#include <ostream>
+
+enum PRODUCT { FUEL = 0, ORG = 1, EQUIP = 2 };
+// typedef std::array<bool, 3> buysell;
+struct buysell {
+  bool foe[3];
+  bool operator==(const buysell &rhs) const;
+  friend std::ostream& operator<<(std::ostream& os, const buysell& bs);  
+};
+
+// ostream& operator<<(std::ostream& os, const buysell& bs);
+
+
+// typedef std::array<char, 3> buysell_text;
+struct buysell_text {
+  char txt[3];
+  bool operator==(const buysell_text &rhs) const;
+  friend std::ostream& operator<<(std::ostream& os, const buysell_text &bst);
+};
+
+/*
+1 : "BBS", TTF
+2 : "BSB", TFT
+3 : "SBB", FTT
+4 : "SSB", FFT
+5 : "SBS", FTF
+6 : "BSS", TFF
+7 : "SSS", FFF
+8 : "BBB", TTT
+*/
+
+/* convert type to buysell flag values, buy = true */
+
+constexpr buysell get_buysell(uint8_t type) {
+  switch (type) {
+  case 1: // BBS TTF
+    return {true, true, false};
+  case 2: // BSB TFT
+    return {true, false, true};
+  case 3: // SBB FTT
+    return {false, true, true};
+  case 4: // SSB FFT
+    return {false, false, true};
+  case 5: // SBS FTF
+    return {false, true, false};
+  case 6: // BSS TFF
+    return {true, false, false};
+  case 7: // SSS FFF
+    return {false, false, false};
+  case 8: // BBB TTT
+    return {true, true, true};
+  default:
+    throw std::invalid_argument("invalid buysell type");
+  }
+}
+
+constexpr buysell_text text_from_buysell(const buysell market) {
+  buysell_text text{'?', '?', '?'};
+  for (int x = 0; x < 3; ++x) {
+    text.txt[x] = market.foe[x] ? 'B' : 'S';
+  }
+  return text;
+}
+
+constexpr buysell_text text_from_type(uint8_t type) {
+  switch (type) {
+  case 1:
+    return buysell_text{'B', 'B', 'S'};
+  case 2:
+    return buysell_text{'B', 'S', 'B'};
+  case 3:
+    return buysell_text{'S', 'B', 'B'};
+  case 4:
+    return buysell_text{'S', 'S', 'B'};
+  case 5:
+    return buysell_text{'S', 'B', 'S'};
+  case 6:
+    return buysell_text{'B', 'S', 'S'};
+  case 7:
+    return buysell_text{'S', 'S', 'S'};
+  case 8:
+    return buysell_text{'B', 'B', 'B'};
+  default:
+    throw std::invalid_argument("invalid text_from_type type");
+  }
+}
+
+constexpr uint8_t type_from_buysell(const buysell market) {
+  if (market.foe[0]) {
+    if (market.foe[1]) {
+      if (market.foe[2]) {
+        return 8; // BBB TTT
+      } else
+        return 1; // BBS TTF
+    } else {
+      if (market.foe[2]) {
+        return 2; // BSB TFT
+      } else
+        return 6; // BSS TFF
+    }
+  } else {
+    if (market.foe[1]) {
+      if (market.foe[2]) {
+        return 3; // SBB FTT
+      } else
+        return 5; // SBS FTF
+    } else {
+      if (market.foe[2]) {
+        return 4; // SSB FFT
+      } else
+        return 7; // SSS FFF
+    }
+  }
+}
+
+struct port {
+  uint16_t sector;
+  uint8_t type;
+  uint16_t amount[3];
+  uint8_t percent[3];
+};
+
+struct port parse_portcim(const std::string line);
+
+// SPECIAL = 0
+// STARDOCK = 9
+
+class GameData {
+public:
+  std::map<std::string, std::string> config;
+  // warps;
+  // ports;
+};