Merge pull request Blizzard#166 from kcalderone/master

Added option to set feature layer size. Foced game to run in windowed…

Author: Kevin Calderone

examples/feature_layers.cc

@@ -11,26 +11,32 @@
 
 using namespace sc2;
 
-void DrawFeatureLayer(const SC2APIProtocol::ImageData& image_data, int width, int height, int off_x, int off_y, int sz_x, int sz_y) {
-    assert(width);
-    assert(height);
-    renderer::Matrix(image_data.data().c_str(), off_x, off_y, sz_x, sz_y, width, height, 255, 0, 0);
+const float kCameraWidth = 24.0f;
+const int kFeatureLayerSize = 80;
+const int kPixelDrawSize = 5;
+const int kDrawSize = kFeatureLayerSize * kPixelDrawSize;
+
+void DrawFeatureLayer(const SC2APIProtocol::ImageData& image_data, int width, int height, int off_x, int off_y) {
+    renderer::Matrix(image_data.data().c_str(), off_x, off_y, kPixelDrawSize, kPixelDrawSize, width, height, 255, 0, 0);
 }
 
 class RenderAgent : public Agent {
 public:
     virtual void OnGameStart() final {
-        renderer::Initialize("Feature layers", 50, 50, 640, 640);
+        renderer::Initialize("Feature layers", 50, 50, 2 * kDrawSize, 2 * kDrawSize);
     }
 
     virtual void OnStep() final {
         const SC2APIProtocol::Observation* observation = Observation()->GetRawObservation();
+
         const SC2APIProtocol::FeatureLayersMap& m = observation->feature_layer_data().map_renders();
-        DrawFeatureLayer(m.unit_density(), m.width(), m.height(), 0, 0, 5, 5);
-        DrawFeatureLayer(m.selected(), m.width(), m.height(), 320, 0, 5, 5);
+        DrawFeatureLayer(m.unit_density(), m.width(), m.height(), 0, 0);
+        DrawFeatureLayer(m.selected(), m.width(), m.height(), kDrawSize, 0);
+
         const SC2APIProtocol::FeatureLayersMinimap& mi = observation->feature_layer_data().minimap_renders();
-        DrawFeatureLayer(mi.camera(), mi.width(), mi.height(), 0, 320, 5, 5);
-        DrawFeatureLayer(mi.height_map(), mi.width(), mi.height(), 320, 320, 5, 5);
+        DrawFeatureLayer(mi.camera(), mi.width(), mi.height(), 0, kDrawSize);
+        DrawFeatureLayer(mi.height_map(), mi.width(), mi.height(), kDrawSize, kDrawSize);
+
         renderer::Render();
     }
 
@@ -46,7 +52,8 @@ int main(int argc, char* argv[]) {
         return 1;
     }
 
-    coordinator.SetFeatureLayers(true);
+    FeatureLayerSettings settings(kCameraWidth, kFeatureLayerSize, kFeatureLayerSize, kFeatureLayerSize, kFeatureLayerSize);
+    coordinator.SetFeatureLayers(settings);
 
     // Add the custom bot, it will control the players.
     RenderAgent bot;

include/sc2api/sc2_control_interfaces.h

@@ -6,7 +6,7 @@
 namespace sc2 {
 
 struct ProcessInfo;
-struct RenderSettings;
+struct InterfaceSettings;
 
 class ControlInterface {
 public:
@@ -15,7 +15,7 @@ class ControlInterface {
     virtual bool RemoteSaveMap(const void* data, int data_size, std::string remote_path) = 0;
     virtual bool CreateGame(const std::string& map_path, const std::vector<PlayerSetup>& players) = 0;
 
-    virtual bool RequestJoinGame(PlayerSetup setup, bool feature_layers=false, RenderSettings* render = nullptr, const Ports& ports = Ports()) = 0;
+    virtual bool RequestJoinGame(PlayerSetup setup, const InterfaceSettings& settings, const Ports& ports = Ports()) = 0;
     virtual bool WaitJoinGame() = 0;
 
     // Single player.
@@ -59,7 +59,7 @@ class ReplayControlInterface {
     virtual bool IgnoreReplay(const ReplayInfo& replay_info) = 0;
 
     virtual bool GatherReplayInfo(const std::string& path) = 0;
-    virtual bool LoadReplay(const std::string& replay_path, bool feature_layers, uint32_t player_id) = 0;
+    virtual bool LoadReplay(const std::string& replay_path, const InterfaceSettings& settings, uint32_t player_id) = 0;
     virtual bool WaitForReplay() = 0;
 
     virtual const ReplayInfo& GetReplayInfo() const = 0;

include/sc2api/sc2_coordinator.h

@@ -25,7 +25,7 @@ class Coordinator {
     bool LoadSettings(int argc, char** argv, const std::string& game_settings = "game_settings.ini");
     void SetMultithreaded(bool value);
     void SetRealtime(bool value);
-    void SetFeatureLayers(bool value);
+    void SetFeatureLayers(const FeatureLayerSettings& settings);
     void SetRender(const RenderSettings& settings);
     void AddCommandLine(const std::string& option);
     void SetParticipants(const std::vector<PlayerSetup>& participants);

include/sc2api/sc2_game_settings.h

@@ -46,16 +46,33 @@ struct RenderSettings {
     int minimap_y_  = 300;
 };
 
+struct FeatureLayerSettings {
+    FeatureLayerSettings () = default;
+    FeatureLayerSettings (float camera_width, int map_x, int map_y, int minimap_x, int minimap_y)
+        : camera_width_(camera_width), map_x_(map_x), map_y_(map_y), minimap_x_(minimap_x), minimap_y_(minimap_y) 
+    {}
+    float camera_width_ = 24.0f;
+    int map_x_ = 64;
+    int map_y_ = 64;
+    int minimap_x_ = 64;
+    int minimap_y_  = 64;
+};
+
+struct InterfaceSettings {
+    InterfaceSettings();
+
+    bool use_feature_layers_;
+    FeatureLayerSettings feature_layer_settings_;
+    bool use_render_;
+    RenderSettings render_settings_;
+};
+
 struct GameSettings {
     GameSettings();
 
     std::string map_name_;
     std::vector<PlayerSetup> player_setup_;
     Ports ports_;
-    bool use_feature_layers_;
-
-    bool use_render_;
-    RenderSettings render_settings_;
 };
 
 struct ReplaySettings {
@@ -64,7 +81,6 @@ struct ReplaySettings {
     // Fill with replays to analyze.
     std::vector<std::string> replay_file_;
     std::string replay_dir_;
-    bool use_feature_layers_;
     uint32_t player_id_;
 };
 

src/sc2api/sc2_client.cc

@@ -1110,7 +1110,7 @@ class ControlImp : public ControlInterface {
     bool Connect(const std::string& address, int port, int timeout_ms) override;
     bool CreateGame(const std::string& map_path, const std::vector<PlayerSetup>& players) override;
 
-    bool RequestJoinGame(PlayerSetup setup, bool feature_layers=false, RenderSettings* render = nullptr, const Ports& ports = Ports()) override;
+    bool RequestJoinGame(PlayerSetup setup, const InterfaceSettings& settings, const Ports& ports = Ports()) override;
     bool WaitJoinGame() override;
 
     bool RequestEndGame() override;
@@ -1313,7 +1313,7 @@ bool ControlImp::CreateGame(const std::string& map_path, const std::vector<Playe
     return success;
 }
 
-bool ControlImp::RequestJoinGame(PlayerSetup setup, bool feature_layers, RenderSettings* render, const Ports& ports) {
+bool ControlImp::RequestJoinGame(PlayerSetup setup, const InterfaceSettings& settings, const Ports& ports) {
     observation_imp_->ClearFlags();
 
     is_multiplayer_ = ports.IsValid();
@@ -1339,18 +1339,23 @@ bool ControlImp::RequestJoinGame(PlayerSetup setup, bool feature_layers, RenderS
         }
     }
 
-    SC2APIProtocol::InterfaceOptions* interface_options = request_join_game->mutable_options();
-    interface_options->set_raw(true);
-    interface_options->set_score(true);
-    if (feature_layers) {
-        interface_options->set_allocated_feature_layer(new SC2APIProtocol::SpatialSetup());
-    }
-    if (render) {
-        SC2APIProtocol::SpatialSetup* render_setup = interface_options->mutable_render();
-        render_setup->set_map_resolution_x(render->map_x_);
-        render_setup->set_map_resolution_y(render->map_y_);
-        render_setup->set_minimap_resolution_x(render->minimap_x_);
-        render_setup->set_minimap_resolution_x(render->minimap_y_);
+    SC2APIProtocol::InterfaceOptions* options = request_join_game->mutable_options();
+    options->set_raw(true);
+    options->set_score(true);
+    if (settings.use_feature_layers_) {
+        SC2APIProtocol::SpatialSetup* setupProto = options->mutable_feature_layer();
+        setupProto->set_camera_width(settings.feature_layer_settings_.camera_width_);
+        setupProto->set_map_resolution_x(settings.feature_layer_settings_.map_x_);
+        setupProto->set_map_resolution_y(settings.feature_layer_settings_.map_y_);
+        setupProto->set_minimap_resolution_x(settings.feature_layer_settings_.minimap_x_);
+        setupProto->set_minimap_resolution_y(settings.feature_layer_settings_.minimap_y_);
+    }
+    if (settings.use_render_) {
+        SC2APIProtocol::SpatialSetup* setupProto = options->mutable_render();
+        setupProto->set_map_resolution_x(settings.render_settings_.map_x_);
+        setupProto->set_map_resolution_y(settings.render_settings_.map_y_);
+        setupProto->set_minimap_resolution_x(settings.render_settings_.minimap_x_);
+        setupProto->set_minimap_resolution_y(settings.render_settings_.minimap_y_);
     }
 
     if (!proto_.SendRequest(request)) {

src/sc2api/sc2_coordinator.cc

@@ -46,10 +46,12 @@ int LaunchProcesses(ProcessSettings& process_settings, std::vector<Client*> clie
         std::vector<std::string> cl = {
             "-listen", process_settings.net_address_,
             "-port", std::to_string(pi.port_),
-            "-offline",
             "-gamestatelogging",
         };
 
+        // DirectX will fail if multiple games try to launch in fullscreen mode. Force them into windowed mode.
+        cl.push_back("-displayMode 0");
+
         cl.push_back("-simulationSpeed");
         if (process_settings.real_time_) {
             cl.push_back("1");
@@ -142,6 +144,7 @@ class CoordinatorImp {
 
     GameSettings game_settings_;
     ReplaySettings replay_settings_;
+    InterfaceSettings interface_settings_;
     ProcessSettings process_settings_;
 
     CoordinatorImp();
@@ -217,7 +220,7 @@ void CoordinatorImp::StartReplay() {
 
             // If the replay isn't being pruned based on replay info start it.
             if (!r->ReplayControl()->IgnoreReplay(r->ReplayControl()->GetReplayInfo())) {
-                r->ReplayControl()->LoadReplay(file, replay_settings_.use_feature_layers_, replay_settings_.player_id_);
+                r->ReplayControl()->LoadReplay(file, interface_settings_, replay_settings_.player_id_);
             }
         }
 
@@ -430,8 +433,7 @@ void CoordinatorImp::StartGame() {
     int i = 0;
     for (auto c : agents_) {
         bool game_join_request = c->Control()->RequestJoinGame(game_settings_.player_setup_[i++],
-            game_settings_.use_feature_layers_,
-            game_settings_.use_render_ ? &game_settings_.render_settings_ : nullptr,
+            interface_settings_,
             game_settings_.ports_);
 
         assert(game_join_request);
@@ -606,17 +608,18 @@ void Coordinator::SetRealtime(bool value) {
     imp_->process_settings_.real_time_ = value;
 }
 
-void Coordinator::SetFeatureLayers(bool value) {
+void Coordinator::SetFeatureLayers(const FeatureLayerSettings& settings) {
     // Feature Layers must be set before LaunchStarcraft is called.
     assert(!imp_->starcraft_started_);
-    imp_->game_settings_.use_feature_layers_ = value;
+    imp_->interface_settings_.use_feature_layers_ = true;
+    imp_->interface_settings_.feature_layer_settings_= settings;
 }
 
 void Coordinator::SetRender(const RenderSettings& settings) {
     // Render must be set before LaunchStarcraft is called.
     assert(!imp_->starcraft_started_);
-    imp_->game_settings_.use_render_ = true;
-    imp_->game_settings_.render_settings_ = settings;
+    imp_->interface_settings_.use_render_ = true;
+    imp_->interface_settings_.render_settings_ = settings;
 }
 
 bool Coordinator::SetReplayPath(const std::string& path) {

src/sc2api/sc2_game_settings.cc

@@ -18,17 +18,20 @@ ProcessSettings::ProcessSettings(bool realtime,
     multi_threaded_(multi_threaded) {
 }
 
+InterfaceSettings::InterfaceSettings() :
+    use_feature_layers_(false),
+    use_render_(false) {
+}
+
 GameSettings::GameSettings() :
     map_name_(""),
     player_setup_(),
-    ports_(),
-    use_feature_layers_(false) {
+    ports_() {
 }
 
 ReplaySettings::ReplaySettings() :
     replay_file_(),
     replay_dir_(),
-    use_feature_layers_(false),
     player_id_(1) {
 }
 

src/sc2api/sc2_replay_observer.cc

@@ -1,6 +1,7 @@
 #include "sc2api/sc2_replay_observer.h"
 #include "sc2api/sc2_control_interfaces.h"
 #include "sc2api/sc2_proto_to_pods.h"
+#include "sc2api/sc2_game_settings.h"
 
 #include <iostream>
 
@@ -22,7 +23,7 @@ class ReplayControlImp : public ReplayControlInterface {
     virtual bool IgnoreReplay(const ReplayInfo& replay_info) override;
 
     virtual bool GatherReplayInfo(const std::string& path) override;
-    virtual bool LoadReplay(const std::string& replay_path, bool feature_layers, uint32_t player_id) override;
+    virtual bool LoadReplay(const std::string& replay_path, const InterfaceSettings& settings, uint32_t player_id) override;
     virtual bool WaitForReplay() override;
 
     virtual const ReplayInfo& GetReplayInfo() const override;
@@ -130,21 +131,31 @@ bool ReplayControlImp::GatherReplayInfo(const std::string& path) {
     return true;
 }
 
-bool ReplayControlImp::LoadReplay(const std::string& replay_path, bool feature_layers, uint32_t player_id) {
+bool ReplayControlImp::LoadReplay(const std::string& replay_path, const InterfaceSettings& settings, uint32_t player_id) {
     // Send the request.
     GameRequestPtr request = control_interface_->Proto().MakeRequest();
     SC2APIProtocol::RequestStartReplay* start_replay_request = request->mutable_start_replay();
     start_replay_request->set_replay_path(replay_path);
     start_replay_request->set_observed_player_id(player_id);
+
     SC2APIProtocol::InterfaceOptions* options = start_replay_request->mutable_options();
     options->set_raw(true);
     options->set_score(true);
-    if (feature_layers) {
-        options->set_allocated_feature_layer(new SC2APIProtocol::SpatialSetup());
+    if (settings.use_feature_layers_) {
+        SC2APIProtocol::SpatialSetup* setupProto = options->mutable_feature_layer();
+        setupProto->set_camera_width(settings.feature_layer_settings_.camera_width_);
+        setupProto->set_map_resolution_x(settings.feature_layer_settings_.map_x_);
+        setupProto->set_map_resolution_y(settings.feature_layer_settings_.map_y_);
+        setupProto->set_minimap_resolution_x(settings.feature_layer_settings_.minimap_x_);
+        setupProto->set_minimap_resolution_y(settings.feature_layer_settings_.minimap_y_);
+    }
+    if (settings.use_render_) {
+        SC2APIProtocol::SpatialSetup* setupProto = options->mutable_render();
+        setupProto->set_map_resolution_x(settings.render_settings_.map_x_);
+        setupProto->set_map_resolution_y(settings.render_settings_.map_y_);
+        setupProto->set_minimap_resolution_x(settings.render_settings_.minimap_x_);
+        setupProto->set_minimap_resolution_y(settings.render_settings_.minimap_y_);
     }
-
-    // TODO: Update this feature.
-    //options->set_enable_render(render);
 
     if (!control_interface_->Proto().SendRequest(request)) {
         std::cerr << "LoadReplay: load replay request failed." << std::endl;

tests/test_app.cc

@@ -93,7 +93,6 @@ bool TestHang(int argc, char** argv) {
     if (!coordinator.LoadSettings(argc, argv)) {
         return false;
     }
-    coordinator.SetFeatureLayers(true);
 
     // Add the custom bot, it will control the players.
     AppTestBotHang bot1;
@@ -119,7 +118,6 @@ bool TestCrash(int argc, char** argv) {
     if (!coordinator.LoadSettings(argc, argv)) {
         return false;
     }
-    coordinator.SetFeatureLayers(true);
 
     // Add the custom bot, it will control the players.
     AppTestBotCrash bot1;

tests/test_feature_layer.cc

@@ -272,7 +272,8 @@ bool TestFeatureLayers(int argc, char** argv) {
     if (!coordinator.LoadSettings(argc, argv)) {
         return false;
     }
-    coordinator.SetFeatureLayers(true);
+
+    coordinator.SetFeatureLayers(FeatureLayerSettings());
 
     // Add the custom bot, it will control the players.
     FeatureLayerTestBot bot;