Update to latest protobuf and sc2-proto-rs (#41)

* Update to latest protobuf and sc2-proto-rs

* Fix broken test

Cargo.toml

@@ -19,8 +19,8 @@ requires-dist = ["portpicker", "aiohttp"]
 
 
 [dependencies]
-sc2-proto = { git = "https://github.com/UltraMachine/sc2-proto-rs.git" }
-protobuf = { version = "^2.20.0", features = ["with-bytes"] }
+sc2-proto = { git = "https://github.com/aiarena/sc2-proto-rs.git" }
+protobuf = { version = "^3.1.0", features = ["with-bytes"] }
 log = "^0.4.13"
 shellexpand = "^2.1.0"
 regex = "^1.4.3"

src/controller.rs

@@ -334,7 +334,7 @@ impl Controller {
                     }
                     Ok(ref m) if m.has_join_game() => {
                         info!("Game join");
-                        PlaylistAction::JoinGame(m.get_join_game().clone())
+                        PlaylistAction::JoinGame(m.join_game().clone())
                     }
                     Ok(other) => {
                         error!("Unsupported message in playlist {:?}", other);

src/handler/lobby.rs

@@ -1,9 +1,9 @@
 //! Game manages a single unstarted handler, including its configuration
 
 use log::{error, info};
+use protobuf::{EnumOrUnknown, MessageField};
 use std::thread::JoinHandle;
 
-use protobuf::RepeatedField;
 use sc2_proto::sc2api::RequestJoinGame;
 
 use crate::maps::find_map;
@@ -86,8 +86,7 @@ impl GameLobby {
         r_create_game.set_local_map(r_local_map);
         r_create_game.set_realtime(self.config.realtime());
 
-        let p_cfgs: Vec<_> = players.iter().map(CreateGamePlayer::as_proto).collect();
-        r_create_game.set_player_setup(RepeatedField::from_vec(p_cfgs));
+        r_create_game.player_setup = players.iter().map(CreateGamePlayer::as_proto).collect();
 
         let mut request = Request::new();
         request.set_create_game(r_create_game);
@@ -112,12 +111,9 @@ impl GameLobby {
         let response = self.players[0].sc2_query(proto)?;
 
         assert!(response.has_create_game());
-        let resp_create_game = response.get_create_game();
+        let resp_create_game = response.create_game();
         if resp_create_game.has_error() {
-            error!(
-                "Could not create handler: {:?}",
-                resp_create_game.get_error()
-            );
+            error!("Could not create handler: {:?}", resp_create_game.error());
             return None;
         } else {
             info!("Game created successfully");
@@ -135,7 +131,7 @@ impl GameLobby {
         use sc2_proto::sc2api::Request;
 
         let mut r_join_game = RequestJoinGame::new();
-        r_join_game.set_options(player_data.ifopts);
+        r_join_game.options = MessageField::from_option(Some(player_data.ifopts));
         r_join_game.set_race(player_data.race.to_proto());
         portconfig.apply_proto(&mut r_join_game, self.players.len() == 1);
 
@@ -166,10 +162,10 @@ impl GameLobby {
         for player in self.players.iter_mut() {
             let response = player.sc2_recv()?;
             assert!(response.has_join_game());
-            let resp_join_game = response.get_join_game();
-            player.player_id = Some(resp_join_game.get_player_id());
+            let resp_join_game = response.join_game();
+            player.player_id = Some(resp_join_game.player_id());
             if resp_join_game.has_error() {
-                error!("Could not join handler: {:?}", resp_join_game.get_error());
+                error!("Could not join handler: {:?}", resp_join_game.error());
                 return None;
             } else {
                 info!("Game join successful");
@@ -221,10 +217,10 @@ impl CreateGamePlayer {
         let mut ps = PlayerSetup::new();
         match self {
             Self::Participant => {
-                ps.set_field_type(PlayerType::Participant);
+                ps.type_ = Some(EnumOrUnknown::new(PlayerType::Participant));
             }
             Self::Observer => {
-                ps.set_field_type(PlayerType::Observer);
+                ps.type_ = Some(EnumOrUnknown::new(PlayerType::Observer));
             }
         }
         ps

src/handler/player.rs

@@ -4,7 +4,6 @@ use std::fmt;
 use std::io::ErrorKind::{ConnectionAborted, ConnectionReset, TimedOut, WouldBlock};
 use std::time::Instant;
 
-use protobuf::Clear;
 use protobuf::Message;
 use sc2_proto::sc2api::{Request, RequestJoinGame, RequestSaveReplay, Response, Status};
 use websocket::result::WebSocketError;
@@ -235,7 +234,7 @@ impl Player {
             if response.has_save_replay() {
                 match File::create(&path) {
                     Ok(mut buffer) => {
-                        let data: &[u8] = response.get_save_replay().get_data();
+                        let data: &[u8] = response.save_replay().data();
                         buffer
                             .write_all(data)
                             .expect("Could not write to replay file");
@@ -291,20 +290,20 @@ impl Player {
             }
             // Check for debug requests
             if config.disable_debug() && req.has_debug() {
-                debug_response.set_id(req.get_id());
+                debug_response.set_id(req.id());
                 self.client_respond(&debug_response);
                 continue;
             } else if req.has_leave_game() {
                 surrender = true;
                 break;
             }
             for tag in req
-                .get_action()
+                .action()
                 .actions
                 .iter()
-                .filter(|a| a.has_action_chat() && a.get_action_chat().has_message())
+                .filter(|a| a.action_chat.has_message())
                 .filter_map(|x| {
-                    let msg = x.get_action_chat().get_message();
+                    let msg = x.action_chat.message();
                     if msg.contains("Tag:") {
                         msg.strip_prefix("Tag:").map(String::from)
                     } else {
@@ -328,10 +327,10 @@ impl Player {
             };
 
             response.merge_from_bytes(&response_raw).ok()?;
-            self.sc2_status = Some(response.get_status());
+            self.sc2_status = Some(response.status());
             if response.has_game_info() {
-                for pi in response.mut_game_info().mut_player_info().iter_mut() {
-                    if pi.get_player_id() != self.player_id.unwrap() {
+                for pi in response.mut_game_info().player_info.iter_mut() {
+                    if pi.player_id() != self.player_id.unwrap() {
                         pi.race_actual = pi.race_requested;
                     }
                 }
@@ -363,14 +362,14 @@ impl Player {
                 } else {
                     self.frame_time
                 };
-                let obs = response.get_observation();
-                let obs_results = obs.get_player_result();
-                self.game_loops = obs.get_observation().get_game_loop();
+                let obs = response.observation();
+                let obs_results = &obs.player_result;
+                self.game_loops = obs.observation.game_loop();
                 if !obs_results.is_empty() {
                     // Game is over and results available
                     let mut results_by_id: Vec<(u32, PlayerResult)> = obs_results
                         .iter()
-                        .map(|r| (r.get_player_id(), PlayerResult::from_proto(r.get_result())))
+                        .map(|r| (r.player_id(), PlayerResult::from_proto(r.result())))
                         .collect();
                     results_by_id.sort();
                     let results: Vec<_> = results_by_id.into_iter().map(|(_, v)| v).collect();
@@ -484,14 +483,14 @@ pub struct PlayerData {
 impl PlayerData {
     pub fn from_join_request(req: RequestJoinGame, archon: bool) -> Self {
         Self {
-            race: Race::from_proto(req.get_race()),
+            race: Race::from_proto(req.race()),
             name: if req.has_player_name() {
-                Some(req.get_player_name().to_owned())
+                Some(req.player_name().to_owned())
             } else {
                 None
             },
             ifopts: {
-                let mut ifopts = req.get_options().clone();
+                let mut ifopts = req.options.unwrap();
                 ifopts.set_raw_affects_selection(!archon);
                 ifopts
             },
@@ -514,13 +513,13 @@ impl Default for Visibility {
 pub fn clear_request(req: &mut Request) {
     req.request = None;
     req.id = None;
-    req.unknown_fields.clear();
+    req.mut_unknown_fields().clear();
 }
 
 pub fn clear_response(response: &mut Response) {
     response.response = None;
     response.id = None;
     response.error.clear();
     response.status = None;
-    response.unknown_fields.clear();
+    response.mut_unknown_fields().clear();
 }

src/portconfig.rs

@@ -1,8 +1,8 @@
 //! Full port configuration
 
 use portpicker::pick_unused_port;
+use protobuf::MessageField;
 
-use protobuf::RepeatedField;
 use sc2_proto::sc2api::{PortSet, RequestJoinGame};
 
 /// Full set of ports needed by SC2
@@ -34,12 +34,12 @@ impl PortConfig {
             let mut server_ps = PortSet::new();
             server_ps.set_game_port(self.server_game as i32);
             server_ps.set_base_port(self.server_base as i32);
-            req.set_server_ports(server_ps);
+            req.server_ports = MessageField::from_option(Some(server_ps));
 
             let mut client_ps = PortSet::new();
             client_ps.set_game_port(self.client_game as i32);
             client_ps.set_base_port(self.client_base as i32);
-            req.set_client_ports(RepeatedField::from_vec(vec![client_ps]));
+            req.client_ports = vec![client_ps];
         }
     }
 }
@@ -53,7 +53,7 @@ mod tests {
         let mut request = RequestJoinGame::new();
         let port_config = PortConfig::new().expect("Could not create port config");
         port_config.apply_proto(&mut request, false);
-        assert!(request.has_server_ports());
+        assert!(request.server_ports.is_some());
         assert!(request.has_shared_port());
     }
 }