ent_challenge extra features

diff --git a/blender_export.py b/blender_export.py
index 349dbe038b00040efc87d5eb9b71d576358d0671..8d202983d765851a3f14164de6ddefe3bd6656ab 100644 (file)
--- a/blender_export.py
+++ b/blender_export.py
@@ -462,14 +462,17 @@ class ent_ccmd(Structure):
 class ent_challenge(Structure):#{
    _fields_ = [("transform",mdl_transform),
                ("submesh_start",c_uint32), ("submesh_count",c_uint32),
+               ("flags",c_uint32),
                ("id_next",c_uint32),
-               ("filter",c_uint32),
+               ("filter",c_uint32),("filter2",c_uint32),
                ("id_win",c_uint32),
                ("win_event",c_uint32),
                ("time_limit",c_float)]
 
    sr_functions = { 0: 'trigger',
-                    1: 'start_challenge' }
+                    1: 'start_challenge',
+                    2: 'show',
+                    3: 'hide' }
 #}
 
 class ent_unlock(Structure):#{
@@ -1853,7 +1856,8 @@ def sr_compile( collection ):
             challenge.id_next = sr_entity_id( obj_data.proxima )
             challenge.id_win = sr_entity_id( obj_data.target )
             challenge.win_event = obj_data.target_event
-            challenge.filter = 0
+            challenge.filter = int(obj_data.filtrar)
+            challenge.filter2 = 0
             challenge.time_limit = obj_data.time_limit
 
             compile_obj_transform( obj, challenge.transform )
@@ -2869,9 +2873,7 @@ class SR_OBJECT_ENT_VOLUME(bpy.types.PropertyGroup):#{
 
    target: bpy.props.PointerProperty( \
            type=bpy.types.Object, name="Target", \
-           poll=lambda self,obj: sr_filter_ent_type(obj,\
-                                    ['ent_audio','ent_skateshop','ent_ccmd',\
-                                     'ent_challenge']))
+           poll=lambda self,obj: sr_filter_ent_type(obj,SR_TRIGGERABLE))
    target_event: bpy.props.IntProperty( name="Event/Method" )
 
    @staticmethod
@@ -3196,11 +3198,26 @@ class SR_OBJECT_ENT_CHALLENGE(bpy.types.PropertyGroup):#{
            poll=lambda self,obj: sr_filter_ent_type(obj,SR_TRIGGERABLE))
    target_event: bpy.props.IntProperty( name="Event/Method" )
    time_limit: bpy.props.FloatProperty( name="Time Limit", default=1.0 )
+   filtrar: bpy.props.EnumProperty( name='Filter',\
+      items=[('0','none',''),
+             (str(0x1),'trick_shuvit',''),
+             (str(0x2),'trick_kickflip',''),
+             (str(0x4),'trick_treflip',''),
+             (str(0x1|0x2|0x4),'trick_any',''),
+             (str(0x8),'flip_back',''),
+             (str(0x10),'flip_front',''),
+             (str(0x8|0x10),'flip_any',''),
+             (str(0x20),'grind_truck_any',''),
+             (str(0x40),'grind_board_any',''),
+             (str(0x20|0x40),'grind_any',''),
+             (str(0x80),'footplant','')
+             ])
 
    @staticmethod
    def sr_inspector( layout, data ):#{
       layout.prop( data[0], 'proxima' )
       layout.prop( data[0], 'time_limit' )
+      layout.prop( data[0], 'filtrar' )
       SR_OBJECT_ENT_VOLUME.inspect_target( layout, data, 'target' )
    #}
 #}

diff --git a/ent_challenge.c b/ent_challenge.c
index f01d335f52a50b16bffd98003e598f4ad21dc4c0..b01e4902e20b49b901ade4ebb51ada83da720d67 100644 (file)
--- a/ent_challenge.c
+++ b/ent_challenge.c
@@ -31,13 +31,49 @@ VG_STATIC void ent_challenge_pass( world_instance *world,
    }
 }
 
+VG_STATIC int ent_challenge_check_filter( ent_challenge *challenge ){
+   if( challenge->filter ){
+      struct player_skate_state *s = &localplayer._skate.state;
+      enum trick_type trick = s->trick_type;
+
+      u32 state = 0x00;
+
+      if( trick == k_trick_type_shuvit ) 
+         state |= k_ent_challenge_filter_trick_shuvit;
+      if( trick == k_trick_type_treflip )
+         state |= k_ent_challenge_filter_trick_treflip;
+      if( trick == k_trick_type_kickflip )
+         state |= k_ent_challenge_filter_trick_kickflip;
+      
+      if( s->flip_rate < -0.0001f ) state |= k_ent_challenge_filter_flip_back;
+      if( s->flip_rate >  0.0001f ) state |= k_ent_challenge_filter_flip_front;
+
+      if( s->activity == k_skate_activity_grind_5050 ||
+          s->activity == k_skate_activity_grind_back50 ||
+          s->activity == k_skate_activity_grind_front50 ) 
+         state |= k_ent_challenge_filter_grind_truck_any;
+
+      if( s->activity == k_skate_activity_grind_boardslide )
+         state |= k_ent_challenge_filter_grind_board_any;
+
+      return ((challenge->filter  & state) || !challenge->filter) && 
+             ((challenge->filter2 & state) || !challenge->filter2);
+   }
+   else {
+      return 1;
+   }
+}
+
 VG_STATIC void ent_challenge_call( world_instance *world, ent_call *call ){
    u32 index = mdl_entity_id_id( call->id );
    ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
 
    if( call->function == 0 ){
+      if( challenge->flags & k_ent_challenge_hidden ) return;
+
       if( world->challenge_target ){
-         if( world->challenge_target == challenge ){
+         if( (world->challenge_target == challenge) && 
+              ent_challenge_check_filter( challenge )){
             ent_challenge_pass( world, challenge );
          }
          else {
@@ -48,10 +84,18 @@ VG_STATIC void ent_challenge_call( world_instance *world, ent_call *call ){
       }
    }
    else if( call->function == 1 ){
+      if( challenge->flags & k_ent_challenge_hidden ) return;
+
       vg_info( "begin the challenge\n" );
       world->challenge_timer = 0.0f;
       ent_challenge_pass( world, challenge );
    }
+   else if( call->function == 2 ){
+      challenge->flags &= ~k_ent_challenge_hidden;
+   }
+   else if( call->function == 3 ){
+      challenge->flags |=  k_ent_challenge_hidden;
+   }
    else {
       vg_print_backtrace();
       vg_error( "Unhandled function id: %u\n", call->function );

diff --git a/entity.h b/entity.h
index 472ab36a34d9acc46156a891a5185346238d7c49..9e0424fc8704684d1abfde4bbc429e70bfca7593 100644 (file)
--- a/entity.h
+++ b/entity.h
@@ -401,12 +401,39 @@ struct ent_ccmd{
    u32 pstr_command;
 };
 
+enum ent_challenge_filter{
+   k_ent_challenge_filter_none            = 0x00000000,
+   k_ent_challenge_filter_trick_shuvit    = 0x00000001,
+   k_ent_challenge_filter_trick_kickflip  = 0x00000002,
+   k_ent_challenge_filter_trick_treflip   = 0x00000004,
+   k_ent_challenge_filter_trick_any       = 
+      k_ent_challenge_filter_trick_shuvit|
+      k_ent_challenge_filter_trick_treflip|
+      k_ent_challenge_filter_trick_kickflip,
+   k_ent_challenge_filter_flip_back       = 0x00000008,
+   k_ent_challenge_filter_flip_front      = 0x00000010,
+   k_ent_challenge_filter_flip_any        =
+      k_ent_challenge_filter_flip_back|
+      k_ent_challenge_filter_flip_front,
+   k_ent_challenge_filter_grind_truck_any = 0x00000020,
+   k_ent_challenge_filter_grind_board_any = 0x00000040,
+   k_ent_challenge_filter_grind_any       =
+      k_ent_challenge_filter_grind_truck_any|
+      k_ent_challenge_filter_grind_board_any,
+   k_ent_challenge_filter_footplant       = 0x00000080
+};
+
+enum ent_challenge_flag {
+   k_ent_challenge_hidden = 0x1
+};
+
 struct ent_challenge{
    mdl_transform transform;
    u32 submesh_start,
        submesh_count,
+       flags,
        id_next,
-       filter,
+       filter,filter2,
        id_win,
        win_event;
    f32 time_limit;

diff --git a/maps_src/mp_spawn/main.mdl b/maps_src/mp_spawn/main.mdl
index 56751a797f1a7c42b67d422f877fe556b74b7c4c..5adf5d29079a334679ed48a08df675e119ca9df9 100644 (file)
Binary files a/maps_src/mp_spawn/main.mdl and b/maps_src/mp_spawn/main.mdl differ

diff --git a/player_skate.c b/player_skate.c
index 3cd9a928194cbc677aa9741e3694b26773849040..a7899075d0525f5db0a62a92f74aaf230bc5f4ea 100644 (file)
--- a/player_skate.c
+++ b/player_skate.c
@@ -1119,27 +1119,29 @@ VG_STATIC void player__skate_pre_update( player_instance *player ){
       return;
    }
 
-   enum trick_type trick = k_trick_type_none;
-   if( (s->state.activity <= k_skate_activity_air_to_grind) && 
-       (trick = player_skate_trick_input( player )) )
-   {
-      if( (vg.time - s->state.jump_time) < 0.1f ){
-         v3_zero( s->state.trick_vel );
-         s->state.trick_time = 0.0f;
-
-         if( trick == k_trick_type_kickflip ){
-            s->state.trick_vel[0] = 3.0f;
-         }
-         else if( trick == k_trick_type_shuvit ){
-            s->state.trick_vel[2] = 3.0f;
-         }
-         else if( trick == k_trick_type_treflip ){
-            s->state.trick_vel[0] = 2.0f;
-            s->state.trick_vel[2] = 2.0f;
+   if( s->state.activity <= k_skate_activity_air_to_grind ){
+      enum trick_type trick = k_trick_type_none;
+      if( (trick = player_skate_trick_input( player )) ){
+         if( (vg.time - s->state.jump_time) < 0.1f ){
+            v3_zero( s->state.trick_vel );
+            s->state.trick_time = 0.0f;
+
+            if( trick == k_trick_type_kickflip ){
+               s->state.trick_vel[0] = 3.0f;
+            }
+            else if( trick == k_trick_type_shuvit ){
+               s->state.trick_vel[2] = 3.0f;
+            }
+            else if( trick == k_trick_type_treflip ){
+               s->state.trick_vel[0] = 2.0f;
+               s->state.trick_vel[2] = 2.0f;
+            }
+            s->state.trick_type = trick;
          }
-         s->state.trick_type = trick;
       }
    }
+   else
+      s->state.trick_type = k_trick_type_none;
 }
 
 VG_STATIC void player__skate_post_update( player_instance *player ){

diff --git a/save.c b/save.c
index ed869e67af7aa031f7b332fb063657a2cdd21171..a3990d981dbef4c66e45e2569af79ab5704e9781 100644 (file)
--- a/save.c
+++ b/save.c
@@ -130,10 +130,10 @@ static void skaterift_populate_main_savedata( savedata_file *file ){
       addon_reg *reg = world_static.addon_client;
       if( reg && (world_static.active_instance > 0) ){
          skaterift_write_addon_alias( &sav, "alias", &reg->alias );
-         vg_msg_wkvu32( &sav, "index", world_static.active_instance );
-         vg_msg_wkvnum( &sav, "position", k_vg_msg_float|k_vg_msg_32b, 3, 
-                        localplayer.rb.co );
       }
+      vg_msg_wkvu32( &sav, "index", world_static.active_instance );
+      vg_msg_wkvnum( &sav, "position", k_vg_msg_float|k_vg_msg_32b, 3, 
+                     localplayer.rb.co );
    }
    vg_msg_end_frame( &sav );
 

diff --git a/skaterift.c b/skaterift.c
index 3188fd9adee822628b7291a4d84788a5db364f39..e639d05eb0deade48ee1cab867f830fe6d903967 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -146,12 +146,14 @@ static void skaterift_restore_state(void){
          world_static.active_instance = vg_msg_seekkvu32( &world, "index", 0 );
          world_static.active_trigger_volume_count = 0;
          localplayer.viewable_world = world_current_instance();
+      }
+
+      vg_msg_cmd position = vg_msg_seekkv( &world, "position", 0 );
+      v3f pos;
+      vg_msg_convert_num( &position, k_vg_msg_float|k_vg_msg_32b, 3, pos );
 
-         vg_msg_cmd position = vg_msg_seekkv( &world, "position", 0 );
-         v3f pos;
-         vg_msg_convert_num( &position, k_vg_msg_float|k_vg_msg_32b, 3, pos );
+      if( v3_length2(pos) > 1.0f )
          player__setpos( &localplayer, pos );
-      }
    }
 }
 

diff --git a/world_render.c b/world_render.c
index 87f307ec8bdd1bc91e5a503697f53416a2f5913b..0b5b399303bf3039db9d70928c1631ed14509984 100644 (file)
--- a/world_render.c
+++ b/world_render.c
@@ -432,6 +432,7 @@ void world_render_challenges( world_instance *world, struct world_pass *pass,
       if( type != k_ent_challenge ) continue;
 
       ent_challenge *challenge = mdl_arritm(&world->ent_challenge,index);
+      if( challenge->flags & k_ent_challenge_hidden ) continue;
 
       f32 dist = v3_dist( challenge->transform.co, pos ) * (1.0f/radius),
           scale = vg_smoothstepf( vg_clampf( 10.0f-dist*10.0f, 0.0f,1.0f ) );