twproxy2/galaxy.h

#ifndef GALAXY_H
#define GALAXY_H

#include <array>
#include <cstdint>
#include <iostream>
#include <ostream>
#include <regex>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>

#include "yaml-cpp/yaml.h"

enum PRODUCT { FUEL = 0, ORG = 1, EQU = 2 };

// Class 0 : Special
// Class 9 : StarDock BBB

// 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);
};

// #define MAX_WARPS 6

typedef uint16_t sector_type;
typedef uint8_t port_type;

struct sector_warps {
  sector_type sector;  // Yes, for debug
  // std::set<sector_type> warps;  // possibly
  std::set<sector_type> warps;
  // sector_type warps[MAX_WARPS];
  // ports
  // planets
  // ctor that zeros everything out?
  sector_warps();
  void add(sector_type sector);
  // add() that adds warp to end of warps?
  friend std::ostream& operator<<(std::ostream& os, const sector_warps& warps);
  // bool operator==(const sector_warps& rhs) const;
  // void sort(void);
};

/*
1 : "BBS", TTF
2 : "BSB", TFT
3 : "SBB", FTT
4 : "SSB", FFT
5 : "SBS", FTF
6 : "BSS", TFF
7 : "SSS", FFF
8 : "BBB", TTT
9 : "BBB", TTT
*/

/* convert type to buysell flag values, buy = true */

constexpr buysell get_buysell(port_type 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
    case 9:
      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(port_type 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:
    case 9:
      return buysell_text{'B', 'B', 'B'};
    default:
      throw std::invalid_argument("invalid text_from_type type");
  }
}

constexpr buysell invert_buysell(const buysell market) {
  if (market.foe[0]) {
    if (market.foe[1]) {
      if (market.foe[2]) {
        return {false, false, false};  // BBB TTT
      } else
        return {false, false, true};  // BBS TTF
    } else {
      if (market.foe[2]) {
        return {false, true, false};  // BSB TFT
      } else
        return {false, true, true};  // BSS TFF
    }
  } else {
    if (market.foe[1]) {
      if (market.foe[2]) {
        return {true, false, false};  // SBB FTT
      } else
        return {true, false, true};  // SBS FTF
    } else {
      if (market.foe[2]) {
        return {true, true, false};  // SSB FFT
      } else
        return {true, true, true};  // SSS FFF
    }
  }
}

/**
 * Find possible trades with these two port types
 *
 * 0 = NONE
 * 1 = GOOD OE trade pair
 * 2 = OK trade pair
 * 3 = FAIR (one buys, one sells)
 *
 * This will probably be expanded in the future to return:
 *    What port(s) to trade with.  (pos, return top 2)
 *
 * @param port1
 * @param port2
 * @return int
 */
int trade_type(port_type port1, port_type port2);
struct trade_type_result {
  int type;
  buysell trades;
};
trade_type_result trade_type_info(port_type port1, port_type port2);

struct port_pair_type {
  int type;
  sector_type s1, s2;
};

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 {
  sector_type sector;
  uint8_t type;
  uint16_t amount[3];
  uint8_t percent[3];
  bool unknown(void);
  // port();
  friend std::ostream& operator<<(std::ostream& os, const port& p);
};

struct port parse_portcim(const std::string line);

// SPECIAL = 0
// STARDOCK = 9

class Galaxy {
 public:
  Galaxy();
  ~Galaxy();

  void reset(void);
  YAML::Node config;
  YAML::Node meta;

  int burnt_percent;

  // warps;
  // ports;
  std::map<sector_type, port> ports;
  std::map<sector_type, sector_warps> warps;

  void add_warp(sector_warps);
  void add_port(sector_type sector, int port_class);
  void add_port(port);

  void save(void);
  void load(void);

  std::vector<port_pair_type> find_best_trades(void);
  std::vector<port_pair_type> find_trades(sector_type sector,
                                          bool highest = true);
  void sort_port_pair_type(std::vector<port_pair_type>& pptv);

  char game;
  std::string username;
};

#endif