json GameState::to_json()

in dipcc/dipcc/cc/game_state.cc [640:716]

• 64 lines of code
• 20 McCabe index (conditional complexity)

json GameState::to_json() {
  json j;
  auto &all_possible_orders(this->get_all_possible_orders());

  // builds
  for (Power power : POWERS) {
    int n_homes = 0;
    j["builds"][power_str(power)]["homes"] = vector<string>();
    if (this->get_phase().phase_type == 'A') {
      for (Loc center : home_centers(power)) {
        auto it = all_possible_orders.find(center);
        if (it != all_possible_orders.end() && it->second.size() > 0) {
          j["builds"][power_str(power)]["homes"].push_back(loc_str(center));
          n_homes++;
        }
      }
    }
    j["builds"][power_str(power)]["count"] =
        phase_.phase_type == 'A' ? std::min(this->get_n_builds(power), n_homes)
                                 : 0;
  }

  // centers
  for (const auto &p : centers_) {
    j["centers"][power_str(p.second)].push_back(loc_str(p.first));
  }

  // homes
  for (Power power : POWERS) {
    j["homes"][power_str(power)] = vector<string>();
    for (Loc center : home_centers(power)) {
      auto owner_it = this->get_centers().find(center);
      if (owner_it != this->get_centers().end() && owner_it->second == power) {
        j["homes"][power_str(power)].push_back(loc_str(center));
      }
    }
  }

  // name
  j["name"] = this->get_phase().to_string();

  // retreats
  for (Power power : POWERS) {
    j["retreats"][power_str(power)] =
        std::map<string, string>(); // init with arbitrary empty map
  }
  if (this->get_phase().phase_type == 'R') {
    for (OwnedUnit &unit : this->get_dislodged_units()) {
      auto key = unit.unowned().to_string();
      auto orders_it = all_possible_orders.find(unit.loc);
      JCHECK(orders_it != all_possible_orders.end(),
             "Dislodged unit has no retreat orders in to_json: " +
                 loc_str(unit.loc));
      for (auto &order : orders_it->second) {
        if (order.get_type() == OrderType::R) {
          j["retreats"][power_str(unit.power)][key].push_back(
              loc_str(order.get_dest()));
        }
      }
    }
  }

  // units
  for (Power power : POWERS) {
    j["units"][power_str(power)] = std::vector<string>();
  }
  for (const auto &p : units_) {
    j["units"][power_str(p.second.power)].push_back(
        p.second.unowned().to_string());
  }
  for (const auto &p : dislodged_units_) {
    j["units"][power_str(p.first.power)].push_back(
        "*" + p.first.unowned().to_string());
  }

  return j;
}