allow world reloading

diff --git a/skaterift.c b/skaterift.c
index b7bb6cd86a1e51b6b8244df73a69528e00078c81..3457671f6eead92d47481c2ec8808161514ad72b 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -287,9 +287,9 @@ void vg_pre_update(void)
    if( k_tools_mode ) return;
 
    steam_update();
+   skaterift_change_client_world_preupdate();
+
    if( skaterift.op == k_async_op_clientloading ) return;
-   if( world_static.load_state == k_world_loader_preload )
-      skaterift_change_client_world_preupdate();
 
    draw_origin_axis();
    skateshop_autostart_loading();

diff --git a/world.h b/world.h
index 93bc195b4e241c58cfe3c0d9fc83c58b11b5a359..49d1aaea690849f6fb32bfb3e645901940d9d33d 100644 (file)
--- a/world.h
+++ b/world.h
@@ -256,6 +256,8 @@ struct world_static {
       k_world_loader_load
    }
    load_state;
+
+   bool clear_async_op_when_done;
 }
 extern world_static;
 

diff --git a/world_load.c b/world_load.c
index c275c7aee5b3c5fbe1d31c56baebee793da8f987..312d61a09b15d937d7a16d0c800ba70bdf0391ed 100644 (file)
--- a/world_load.c
+++ b/world_load.c
@@ -165,16 +165,19 @@ struct world_load_complete_data{
    enum world_purpose purpose;
 };
 
-static void skaterift_world_load_done( void *payload, u32 size ){
+static void skaterift_world_load_done( void *payload, u32 size )
+{
    struct world_load_complete_data *data = payload;
    world_instance *world = &world_static.instances[ data->purpose ];
 
    vg_msg sav;
    vg_msg_init( &sav, data->save.buf, data->save.len );
 
-   if( data->purpose != k_world_purpose_hub ){
+   if( data->purpose != k_world_purpose_hub )
+   {
       vg_msg player_frame = sav;
-      if( vg_msg_seekframe( &player_frame, "player" ) ){
+      if( vg_msg_seekframe( &player_frame, "player" ) )
+      {
          vg_msg_getkvvecf( &player_frame, "position", k_vg_msg_v3f, 
                            world->player_co, NULL );
       }
@@ -183,6 +186,12 @@ static void skaterift_world_load_done( void *payload, u32 size ){
    world_entity_start( world, &sav );
    world->status = k_world_status_loaded;
    world_static.load_state = k_world_loader_none;
+
+   if( world_static.clear_async_op_when_done )
+   {
+      skaterift.op = k_async_op_none;
+      world_static.clear_async_op_when_done = 0;
+   }
 }
 
 /*
@@ -275,22 +284,29 @@ void skaterift_world_load_thread( void *_args )
    vg_async_stall();
 }
 
-/* holding pattern before we can start loading the new world, since we might be
- * waiting for audio to stop */
 void skaterift_change_client_world_preupdate(void)
 {
-   for( u32 i=1; i<k_world_max; i++ ){
+   if( world_static.load_state != k_world_loader_preload )
+      return;
+
+   /* holding pattern before we can start loading the new world, since we might 
+    * be waiting for audio to stop */
+   for( u32 i=1; i<k_world_max; i++ )
+   {
       world_instance *inst = &world_static.instances[i];
       
-      if( inst->status == k_world_status_unloading ){
-         if( world_freeable( inst ) ){
+      if( inst->status == k_world_status_unloading )
+      {
+         if( world_freeable( inst ) )
+         {
             world_free( inst );
          }
          return;
       }
    }
 
-   if( vg_loader_availible() ){
+   if( vg_loader_availible() )
+   {
       vg_info( "worlds cleared, begining load\n" );
       world_static.load_state = k_world_loader_load;
 
@@ -308,40 +324,57 @@ void skaterift_change_client_world_preupdate(void)
    }
 }
 
-/* places all loaded worlds into unloading state */
+/* 
+ * places all loaded worlds into unloading state, pass NULL to reload the world 
+ */
 void skaterift_change_world_start( addon_reg *reg )
 {
-   if( world_static.active_instance != 0 )
-      vg_error( "Cannot change worlds while in non-root world\n" );
-   else{
-      if( world_static.instance_addons[ k_world_purpose_client ] == reg ){
-         vg_warn( "World is already loaded\n" );
+   if( world_static.instance_addons[ k_world_purpose_client ] == reg )
+   {
+      vg_warn( "World is already loaded\n" );
+      return;
+   }
+
+   if( !reg )
+   {
+      if( world_static.instance_addons[ k_world_purpose_client ] )
+      {
+         reg = world_static.instance_addons[ k_world_purpose_client ];
+         world_static.clear_async_op_when_done = 1;
+      }
+      else 
+      {
+         vg_warn( "No client world loaded\n" );
          return;
       }
+   }
 
-      char buf[76];
-      addon_alias_uid( &reg->alias, buf );
-      vg_info( "switching to: %s\n", buf );
-      skaterift_autosave(1);
+   world_static.load_state = k_world_loader_preload;
 
-      world_static.load_state = k_world_loader_preload;
+   if( world_static.active_instance != 0 )
+      skaterift.op = k_async_op_clientloading;
 
-      vg_linear_clear( vg_mem.scratch ); /* ?? */
-      vg_info( "unloading old worlds\n" );
+   char buf[76];
+   addon_alias_uid( &reg->alias, buf );
+   vg_info( "switching to: %s\n", buf );
+   skaterift_autosave(1);
 
-      world_instance *client_world = 
-         &world_static.instances[ k_world_purpose_client ];
+   vg_linear_clear( vg_mem.scratch ); /* ?? */
+   vg_info( "unloading old worlds\n" );
 
-      if( client_world->status == k_world_status_loaded ){
-         client_world->status = k_world_status_unloading;
-         world_fadeout_audio( client_world );
-      }
+   world_instance *client_world = 
+      &world_static.instances[ k_world_purpose_client ];
 
-      world_static.instance_addons[ k_world_purpose_client ] = reg;
-      network_send_item( k_netmsg_playeritem_world1 );
-      relink_all_remote_player_worlds();
-      world_unlink_nonlocal( &world_static.instances[k_world_purpose_hub] );
+   if( client_world->status == k_world_status_loaded )
+   {
+      client_world->status = k_world_status_unloading;
+      world_fadeout_audio( client_world );
    }
+
+   world_static.instance_addons[ k_world_purpose_client ] = reg;
+   network_send_item( k_netmsg_playeritem_world1 );
+   relink_all_remote_player_worlds();
+   world_unlink_nonlocal( &world_static.instances[k_world_purpose_hub] );
 }
 
 /* console command for the above function */
@@ -353,23 +386,34 @@ int skaterift_load_world_command( int argc, const char *argv[] )
       return 0;
    }
 
-   if( argc == 1 ){
+   if( argc == 1 )
+   {
+      if( !strcmp( argv[0], "reload" ) )
+      {
+         skaterift_change_world_start( NULL );
+         return 0;
+      }
+
       addon_alias q;
       addon_uid_to_alias( argv[0], &q );
 
       u32 reg_id = addon_match( &q );
-      if( reg_id != 0xffffffff ){
+      if( reg_id != 0xffffffff )
+      {
          addon_reg *reg = get_addon_from_index( k_addon_type_world, reg_id, 0 );
          skaterift_change_world_start( reg );
       }
-      else {
+      else 
+      {
          vg_error( "Addon '%s' is not installed or not found.\n", argv[0] );
       }
    }
-   else {
+   else 
+   {
       vg_info( "worlds availible to load:\n" );
          
-      for( int i=0; i<addon_count(k_addon_type_world,0); i ++ ){
+      for( int i=0; i<addon_count(k_addon_type_world,0); i ++ )
+      {
          addon_reg *w = get_addon_from_index( k_addon_type_world, i, 0);
 
          char buf[ADDON_UID_MAX];