7 files changed, 131 insertions(+), 46 deletions(-)

M Cargo.lock
M api/Cargo.toml
M client/src/gateway.ts
M client/src/protocol/message_c2s.ts
M server/src/handler.rs
M spacetime
M spacetime_py/spacetime.py

@@ 3291,6 3291,30 @@ dependencies = [
 ]
 
 [[package]]
+name = "starkingdoms-api"
+version = "0.1.0"
+dependencies = [
+ "actix-files",
+ "actix-request-identifier",
+ "actix-web",
+ "hmac",
+ "jwt",
+ "log",
+ "once_cell",
+ "openssl",
+ "reqwest",
+ "sea-orm",
+ "serde",
+ "sha2",
+ "simple_logger",
+ "starkingdoms_api_entities",
+ "starkingdoms_api_migration",
+ "tera",
+ "toml 0.7.3",
+ "ulid",
+]
+
+[[package]]
 name = "starkingdoms-protocol"
 version = "0.1.0"
 dependencies = [


@@ 3321,30 3345,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "starkingdoms-server-api"
-version = "0.1.0"
-dependencies = [
- "actix-files",
- "actix-request-identifier",
- "actix-web",
- "hmac",
- "jwt",
- "log",
- "once_cell",
- "openssl",
- "reqwest",
- "sea-orm",
- "serde",
- "sha2",
- "simple_logger",
- "starkingdoms_api_entities",
- "starkingdoms_api_migration",
- "tera",
- "toml 0.7.3",
- "ulid",
-]
-
-[[package]]
 name = "starkingdoms_api_entities"
 version = "0.1.0"
 dependencies = [

@@ 1,5 1,5 @@
 [package]
-name = "starkingdoms-server-api"
+name = "starkingdoms-api"
 version = "0.1.0"
 edition = "2021"
 

@@ 67,11 67,26 @@ export async function gateway_connect(gateway_url: string, username: string): Ga
     }
     client.ping_timeout = setTimeout(ping_fn, 5 * 1000);
 
-    let handshake_start_msg = MessageC2SHello.encode({
-        version: 1,
-        requestedUsername: username,
-        nextState: State.Play
-    }).finish();
+    let handshake_start_msg;
+    if (global.can_beam_out) {
+        handshake_start_msg = MessageC2SHello.encode({
+            version: 2,
+            requestedUsername: username,
+            nextState: State.Play,
+            user: window.localStorage.getItem("user")!,
+            token: window.localStorage.getItem("token")!
+        }).finish();
+    } else {
+        handshake_start_msg = MessageC2SHello.encode({
+            version: 2,
+            requestedUsername: username,
+            nextState: State.Play,
+            // @ts-ignore
+            user: null,
+            // @ts-ignore
+            token: null
+        }).finish();
+    }
     client.socket.send(encode(MessageC2SHello_packetInfo.type, handshake_start_msg));
 
     client.socket.addEventListener('message', async (msg) => {

@@ 12,6 12,8 @@ export interface MessageC2SHello {
   requestedUsername: string;
   /** The state the connection will go into after the handshake. */
   nextState: State;
+  token: string;
+  user: string;
 }
 
 export enum MessageC2SHello_packetInfo {


@@ 244,7 246,7 @@ export function messageC2SAuthenticateAndBeamOut_packetInfoToJSON(
 }
 
 function createBaseMessageC2SHello(): MessageC2SHello {
-  return { version: 0, requestedUsername: "", nextState: 0 };
+  return { version: 0, requestedUsername: "", nextState: 0, token: "", user: "" };
 }
 
 export const MessageC2SHello = {


@@ 258,6 260,12 @@ export const MessageC2SHello = {
     if (message.nextState !== 0) {
       writer.uint32(24).int32(message.nextState);
     }
+    if (message.token !== "") {
+      writer.uint32(34).string(message.token);
+    }
+    if (message.user !== "") {
+      writer.uint32(42).string(message.user);
+    }
     return writer;
   },
 


@@ 289,6 297,20 @@ export const MessageC2SHello = {
 
           message.nextState = reader.int32() as any;
           continue;
+        case 4:
+          if (tag != 34) {
+            break;
+          }
+
+          message.token = reader.string();
+          continue;
+        case 5:
+          if (tag != 42) {
+            break;
+          }
+
+          message.user = reader.string();
+          continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
         break;


@@ 303,6 325,8 @@ export const MessageC2SHello = {
       version: isSet(object.version) ? Number(object.version) : 0,
       requestedUsername: isSet(object.requestedUsername) ? String(object.requestedUsername) : "",
       nextState: isSet(object.nextState) ? stateFromJSON(object.nextState) : 0,
+      token: isSet(object.token) ? String(object.token) : "",
+      user: isSet(object.user) ? String(object.user) : "",
     };
   },
 


@@ 311,6 335,8 @@ export const MessageC2SHello = {
     message.version !== undefined && (obj.version = Math.round(message.version));
     message.requestedUsername !== undefined && (obj.requestedUsername = message.requestedUsername);
     message.nextState !== undefined && (obj.nextState = stateToJSON(message.nextState));
+    message.token !== undefined && (obj.token = message.token);
+    message.user !== undefined && (obj.user = message.user);
     return obj;
   },
 


@@ 323,6 349,8 @@ export const MessageC2SHello = {
     message.version = object.version ?? 0;
     message.requestedUsername = object.requestedUsername ?? "";
     message.nextState = object.nextState ?? 0;
+    message.token = object.token ?? "";
+    message.user = object.user ?? "";
     return message;
   },
 };

@@ 165,27 165,27 @@ pub async fn handle_client(mgr: ClientManager, entities: Arc<RwLock<EntityHandle
                                     handle: player_handle,
                                     input: Default::default(),
                                     addr: remote_addr,
-                                    auth_token: pkt.token.clone(),
-                                    auth_user: pkt.user.clone()
+                                    auth_token: None,
+                                    auth_user: None
                                 };
 
                                 let mut e_write_handle = entities.write().await;
 
-                                if let Some(user) = pkt.user {
-                                    if let Some(token) = pkt.token {
-                                        info!("[{}] * Beamin: beaming in {} as {} with token {}", remote_addr, username, user, token);
+                                if !pkt.user.is_empty() && !pkt.token.is_empty() {
+                                    player.auth_token = Some(pkt.token.clone());
+                                    player.auth_user = Some(pkt.user.clone());
+                                    info!("[{}] * Beamin: beaming in {} as {} with token {}", remote_addr, username, pkt.user, pkt.token);
 
-                                        let player_data = match load_player_data_from_api(&token, &user, &std::env::var("STK_API_KEY").unwrap()).await {
-                                            Ok(d) => d,
-                                            Err(e) => {
-                                                warn!("[{}] * Beamin: ABORTED. API returned error: {}", remote_addr, e);
-                                                e_write_handle.entities.insert(get_entity_id(), Entity::Player(player));
-                                                continue;
-                                            }
-                                        };
+                                    let player_data = match load_player_data_from_api(&pkt.token, &pkt.user, &std::env::var("STK_API_KEY").unwrap()).await {
+                                        Ok(d) => d,
+                                        Err(e) => {
+                                            warn!("[{}] * Beamin: ABORTED. API returned error: {}", remote_addr, e);
+                                            e_write_handle.entities.insert(get_entity_id(), Entity::Player(player));
+                                            continue;
+                                        }
+                                    };
 
-                                        player.load_api_data(&player_data);
-                                    }
+                                    player.load_api_data(&player_data);
                                 }
 
                                 e_write_handle.entities.insert(get_entity_id(), Entity::Player(player));

@@ 28,6 28,10 @@ sub_help() {
   echo "    build_server - Compile the game server" # done
   echo "    run_server_prod - Compile and run the game server with optimizations enabled" # done
   echo "    build_server_prod - Compile the game server with optimizations enabled" # done
+  echo "    run_api - Compile and run the API server"
+  echo "    build_api - Compile the API server"
+  echo "    run_api_prod - Compile and run the API server with optimizations enabled"
+  echo "    build_api_prod - Compile the API server with optimizations enabled"
   echo "    install_tooling - Install the compilation utilities required for compiling StarKingdoms" # done
   echo "    build_assets - Compile spritesheets in all three texture sizes for textures-fast" # done
   echo "    build_assets_full - Compile spritesheets in full size for textures-fast" # done


@@ 106,6 110,30 @@ sub_run_server_prod() {
   exec "$SCRIPT_DIR/target/release/starkingdoms-server"
 }
 
+sub_build_api() {
+  check_all
+  exec_spacetime api dev "$SCRIPT_DIR" "$SERVER_MODS"
+  exec_ninja api
+}
+sub_run_api() {
+  check_all
+  exec_spacetime api dev "$SCRIPT_DIR" "$SERVER_MODS"
+  exec_ninja api
+  cd api && exec "$SCRIPT_DIR/target/debug/starkingdoms-api"
+}
+
+sub_build_api_prod() {
+  check_all
+  exec_spacetime api prod "$SCRIPT_DIR" "$SERVER_MODS"
+  exec_ninja api
+}
+sub_run_api_prod() {
+  check_all
+  exec_spacetime api prod "$SCRIPT_DIR" "$SERVER_MODS"
+  exec_ninja api
+  cd api && exec "$SCRIPT_DIR/target/release/starkingdoms-api"
+}
+
 sub_build_assets() {
   check_all
   exec_spacetime asset dev "$SCRIPT_DIR"

@@ 75,6 75,18 @@ def gen_rules_for_server(root, env, writer, modules):
     writer.build([f'{root}/target/{out_dir}/starkingdoms-server'], 'cargo-server', ['server/Cargo.toml'])
     writer.build(['server'], 'phony', [f'{root}/target/{out_dir}/starkingdoms-server'])
 
+def gen_rules_for_api(root, env, writer, modules):
+    if env == 'dev':
+        out_dir = 'debug'
+        writer.rule('cargo-api', f'cargo build --bin starkingdoms-api --features "{modules}"',
+                    depfile=f'{root}/target/debug/starkingdoms-api.d', pool='console')
+    elif env == 'prod':
+        out_dir = 'release'
+        writer.rule('cargo-api', f'cargo build --bin starkingdoms-api --release --features "{modules}"',
+                    depfile=f'{root}/target/release/starkingdoms-api.d', pool='console')
+
+    writer.build([f'{root}/target/{out_dir}/starkingdoms-api'], 'cargo-api', ['server/Cargo.toml'])
+    writer.build(['api'], 'phony', [f'{root}/target/{out_dir}/starkingdoms-api'])
 
 def gen_inkscape(root, assets, writer, files_375, files_full, files_125):
     gen_inkscape_rules_for_asset_sizes(writer)


@@ 144,6 156,8 @@ def main():
             generate_assets_build_command(root, assets, writer)
         elif target == 'server':
             gen_rules_for_server(root, env, writer, modules)
+        elif target == 'api':
+            gen_rules_for_api(root, env, writer, modules)
 
     print(f'[spacetime] Configured build')