Checked _visionset_mgr.gsc

patch_zm/maps/mp/_visionset_mgr.gsc

@@ -1,7 +1,8 @@
+//checked includes matches beta dump
 #include maps/mp/_utility;
 #include common_scripts/utility;
 
-init()
+init() //checked matches beta dump
 {
 	if ( level.createfx_enabled )
 	{
@@ -17,15 +18,17 @@ init()
 	level thread onplayerconnect();
 }
 
-vsmgr_register_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread )
+vsmgr_register_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread ) //checked matches beta dump
 {
 	if ( level.createfx_enabled )
 	{
 		return;
 	}
+	/*
 /#
 	assert( level.vsmgr_initializing, "All info registration in the visionset_mgr system must occur during the first frame while the system is initializing" );
 #/
+	*/
 	lower_name = tolower( name );
 	validate_info( type, lower_name, priority );
 	add_sorted_name_key( type, lower_name );
@@ -38,7 +41,7 @@ vsmgr_register_info( type, name, version, priority, lerp_step_count, activate_pe
 	}
 }
 
-vsmgr_activate( type, name, player, opt_param_1, opt_param_2 )
+vsmgr_activate( type, name, player, opt_param_1, opt_param_2 ) //checked changed to match beta dump
 {
 	if ( level.vsmgr[ type ].info[ name ].state.activate_per_player )
 	{
@@ -49,7 +52,7 @@ vsmgr_activate( type, name, player, opt_param_1, opt_param_2 )
 	if ( state.ref_count_lerp_thread )
 	{
 		state.ref_count++;
-		if ( state.ref_count >= 1 )
+		if ( state.ref_count > 1 )
 		{
 			return;
 		}
@@ -61,16 +64,14 @@ vsmgr_activate( type, name, player, opt_param_1, opt_param_2 )
 	else
 	{
 		players = getplayers();
-		player_index = 0;
+		for( player_index = 0; player_index < players.size; player_index++ )
-		while ( player_index < players.size )
 		{
 			state vsmgr_set_state_active( players[ player_index ], 1 );
-			player_index++;
 		}
 	}
 }
 
-vsmgr_deactivate( type, name, player )
+vsmgr_deactivate( type, name, player ) //checked changed to match beta dump
 {
 	if ( level.vsmgr[ type ].info[ name ].state.activate_per_player )
 	{
@@ -82,22 +83,20 @@ vsmgr_deactivate( type, name, player )
 	{
 		state.ref_count--;
 
-		if ( state.ref_count >= 0 )
+		if ( state.ref_count > 0 )
 		{
 			return;
 		}
 	}
 	state notify( "deactivate" );
 	players = getplayers();
-	player_index = 0;
+	for( player_index = 0; player_index < players.size; player_index++ )
-	while ( player_index < players.size )
 	{
 		state vsmgr_set_state_inactive( players[ player_index ] );
-		player_index++;
 	}
 }
 
-vsmgr_set_state_active( player, lerp )
+vsmgr_set_state_active( player, lerp ) //checked matches cerberus output
 {
 	player_entnum = player getentitynumber();
 	if ( !isDefined( self.players[ player_entnum ] ) )
@@ -108,7 +107,7 @@ vsmgr_set_state_active( player, lerp )
 	self.players[ player_entnum ].lerp = lerp;
 }
 
-vsmgr_set_state_inactive( player )
+vsmgr_set_state_inactive( player ) //checked matches cerberus output
 {
 	player_entnum = player getentitynumber();
 	if ( !isDefined( self.players[ player_entnum ] ) )
@@ -119,27 +118,25 @@ vsmgr_set_state_inactive( player )
 	self.players[ player_entnum ].lerp = 0;
 }
 
-vsmgr_timeout_lerp_thread( timeout, opt_param_2 )
+vsmgr_timeout_lerp_thread( timeout, opt_param_2 ) //checked changed to match beta dump
 {
 	players = getplayers();
-	player_index = 0;
+	for( player_index = 0; player_index < players.size; player_index++ )
-	while ( player_index < players.size )
 	{
 		self vsmgr_set_state_active( players[ player_index ], 1 );
-		player_index++;
 	}
 	wait timeout;
 	vsmgr_deactivate( self.type, self.name );
 }
 
-vsmgr_timeout_lerp_thread_per_player( player, timeout, opt_param_2 )
+vsmgr_timeout_lerp_thread_per_player( player, timeout, opt_param_2 ) //checked matches beta dump
 {
 	self vsmgr_set_state_active( player, 1 );
 	wait timeout;
 	deactivate_per_player( self.type, self.name, player );
 }
 
-vsmgr_duration_lerp_thread( duration, max_duration )
+vsmgr_duration_lerp_thread( duration, max_duration ) //checked changed to match beta dump
 {
 	start_time = getTime();
 	end_time = start_time + int( duration * 1000 );
@@ -150,26 +147,21 @@ vsmgr_duration_lerp_thread( duration, max_duration )
 	while ( 1 )
 	{
 		lerp = calc_remaining_duration_lerp( start_time, end_time );
-		if ( lerp < 0 )
+		if ( lerp <= 0 )
 		{
 			break;
 		}
-		else
+		players = getplayers();
+		for( player_index = 0; player_index < players.size; player_index++ )
 		{
-			players = getplayers();
+			self vsmgr_set_state_active( players[ player_index ], lerp );
-			player_index = 0;
-			while ( player_index < players.size )
-			{
-				self vsmgr_set_state_active( players[ player_index ], lerp );
-				player_index++;
-			}
-			wait 0,05;
 		}
+		wait 0.05;
 	}
 	vsmgr_deactivate( self.type, self.name );
 }
 
-vsmgr_duration_lerp_thread_per_player( player, duration, max_duration )
+vsmgr_duration_lerp_thread_per_player( player, duration, max_duration ) //checked changed to match beta dump
 {
 	start_time = getTime();
 	end_time = start_time + int( duration * 1000 );
@@ -180,20 +172,17 @@ vsmgr_duration_lerp_thread_per_player( player, duration, max_duration )
 	while ( 1 )
 	{
 		lerp = calc_remaining_duration_lerp( start_time, end_time );
-		if ( lerp < 0 )
+		if ( lerp <= 0 )
 		{
 			break;
 		}
-		else
+		self vsmgr_set_state_active( player, lerp );
-		{
+		wait 0.05;
-			self vsmgr_set_state_active( player, lerp );
-			wait 0,05;
-		}
 	}
 	deactivate_per_player( self.type, self.name, player );
 }
 
-register_type( type )
+register_type( type ) //checked matches beta dump
 {
 	level.vsmgr[ type ] = spawnstruct();
 	level.vsmgr[ type ].type = type;
@@ -207,111 +196,94 @@ register_type( type )
 	vsmgr_register_info( type, level.vsmgr_default_info_name, 1, 0, 1, 0, undefined );
 }
 
-finalize_clientfields()
+finalize_clientfields() //checked changed to match beta dump
 {
 	typekeys = getarraykeys( level.vsmgr );
-	type_index = 0;
+	for ( type_index = 0; type_index < typeKeys.size; type_index++ )
-	while ( type_index < typekeys.size )
 	{
 		level.vsmgr[ typekeys[ type_index ] ] thread finalize_type_clientfields();
-		type_index++;
 	}
 	level.vsmgr_initializing = 0;
 }
 
-finalize_type_clientfields()
+finalize_type_clientfields() //checked changed to match beta dump
 {
-	if ( self.info.size < 1 )
+	if ( self.info.size <= 1 )
 	{
 		return;
 	}
 	self.in_use = 1;
 	self.cf_slot_bit_count = getminbitcountfornum( self.info.size - 1 );
 	self.cf_lerp_bit_count = self.info[ self.sorted_name_keys[ 0 ] ].lerp_bit_count;
-	i = 0;
+	for ( i = 0; i < self.sorted_name_keys.size; i++ )
-	while ( i < self.sorted_name_keys.size )
 	{
 		self.info[ self.sorted_name_keys[ i ] ].slot_index = i;
 		if ( self.info[ self.sorted_name_keys[ i ] ].lerp_bit_count > self.cf_lerp_bit_count )
 		{
 			self.cf_lerp_bit_count = self.info[ self.sorted_name_keys[ i ] ].lerp_bit_count;
 		}
-		i++;
 	}
 	registerclientfield( "toplayer", self.cf_slot_name, self.highest_version, self.cf_slot_bit_count, "int" );
-	if ( self.cf_lerp_bit_count >= 1 )
+	if ( self.cf_lerp_bit_count > 1 )
 	{
 		registerclientfield( "toplayer", self.cf_lerp_name, self.highest_version, self.cf_lerp_bit_count, "float" );
 	}
 }
 
-validate_info( type, name, priority )
+validate_info( type, name, priority ) //checked changed to match beta dump
 {
 	keys = getarraykeys( level.vsmgr );
-	i = 0;
+	for ( i = 0; i < keys.size; i++ )
-	while ( i < keys.size )
 	{
 		if ( type == keys[ i ] )
 		{
 			break;
 		}
-		else
-		{
-			i++;
-		}
 	}
+	/*
 /#
 	assert( i < keys.size, "In visionset_mgr, type '" + type + "'is unknown" );
 #/
+	*/
 	keys = getarraykeys( level.vsmgr[ type ].info );
-	i = 0;
+	for ( i = 0; i < keys.size; i++ )
-	while ( i < keys.size )
 	{
+	/*
 /#
 		assert( level.vsmgr[ type ].info[ keys[ i ] ].name != name, "In visionset_mgr of type '" + type + "': name '" + name + "' has previously been registered" );
 #/
 /#
 		assert( level.vsmgr[ type ].info[ keys[ i ] ].priority != priority, "In visionset_mgr of type '" + type + "': priority '" + priority + "' requested for name '" + name + "' has previously been registered under name '" + level.vsmgr[ type ].info[ keys[ i ] ].name + "'" );
 #/
-		i++;
+	*/
 	}
 }
 
-add_sorted_name_key( type, name )
+add_sorted_name_key( type, name ) //checked changed to match beta dump
 {
-	i = 0;
+	for ( i = 0; i < level.vsmgr[type].sorted_name_keys.size; i++ )
-	while ( i < level.vsmgr[ type ].sorted_name_keys.size )
 	{
 		if ( name < level.vsmgr[ type ].sorted_name_keys[ i ] )
 		{
 			break;
 		}
-		else
-		{
-			i++;
-		}
 	}
 	arrayinsert( level.vsmgr[ type ].sorted_name_keys, name, i );
 }
 
-add_sorted_priority_key( type, name, priority )
+add_sorted_priority_key( type, name, priority ) //checked changed to match beta dump
 {
-	i = 0;
+	for ( i = 0; i < level.vsmgr[type].sorted_prio_keys.size; i++ )
-	while ( i < level.vsmgr[ type ].sorted_prio_keys.size )
 	{
 		if ( priority > level.vsmgr[ type ].info[ level.vsmgr[ type ].sorted_prio_keys[ i ] ].priority )
 		{
 			break;
 		}
-		else
-		{
-			i++;
-		}
 	}
 	arrayinsert( level.vsmgr[ type ].sorted_prio_keys, name, i );
 }
 
-add_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread )
+add_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread ) //checked matches beta dump
 {
 	self.type = type;
 	self.name = name;
@@ -336,7 +308,7 @@ add_info( type, name, version, priority, lerp_step_count, activate_per_player, l
 	}
 }
 
-onplayerconnect()
+onplayerconnect() //checked matches beta dump
 {
 	for ( ;; )
 	{
@@ -345,23 +317,20 @@ onplayerconnect()
 	}
 }
 
-on_player_connect()
+on_player_connect() //checked partially changed to match beta dump
 {
 	self._player_entnum = self getentitynumber();
 	typekeys = getarraykeys( level.vsmgr );
-	type_index = 0;
+	for ( type_index = 0; type_index < typeKeys.size; type_index++ )
-	while ( type_index < typekeys.size )
 	{
 		type = typekeys[ type_index ];
 		if ( !level.vsmgr[ type ].in_use )
 		{
 			type_index++;
-			continue;
 		}
 		else
 		{
-			name_index = 0;
+			for ( name_index = 0; name_index < level.vsmgr[type].sorted_name_keys.size; name_index++ )
-			while ( name_index < level.vsmgr[ type ].sorted_name_keys.size )
 			{
 				name_key = level.vsmgr[ type ].sorted_name_keys[ name_index ];
 				level.vsmgr[ type ].info[ name_key ].state.players[ self._player_entnum ] = spawnstruct();
@@ -371,40 +340,36 @@ on_player_connect()
 				{
 					level.vsmgr[ type ].info[ name_key ].state.players[ self._player_entnum ].ref_count = 0;
 				}
-				name_index++;
 			}
 			level.vsmgr[ type ].info[ level.vsmgr_default_info_name ].state vsmgr_set_state_active( self, 1 );
 		}
-		type_index++;
 	}
 }
 
-monitor()
+monitor() //checked partially changed to match beta dump
 {
 	while ( level.vsmgr_initializing )
 	{
-		wait 0,05;
+		wait 0.05;
 	}
 	typekeys = getarraykeys( level.vsmgr );
 	while ( 1 )
 	{
-		wait 0,05;
+		wait 0.05;
 		waittillframeend;
 		players = get_players();
-		type_index = 0;
+		for ( type_index = 0; type_index < typeKeys.size; type_index++ )
-		while ( type_index < typekeys.size )
 		{
 			type = typekeys[ type_index ];
 			if ( !level.vsmgr[ type ].in_use )
 			{
 				type_index++;
-				continue;
 			}
 			else
 			{
-				player_index = 0;
+				for ( player_index = 0; player_index < players.size; player_index++ )
-				while ( player_index < players.size )
 				{
+					/*
 /#
 					if ( is_true( players[ player_index ].pers[ "isBot" ] ) )
 					{
@@ -412,52 +377,46 @@ monitor()
 						continue;
 #/
 					}
-					else
+					*/
-					{
+					update_clientfields( players[ player_index ], level.vsmgr[ type ] );
-						update_clientfields( players[ player_index ], level.vsmgr[ type ] );
-					}
-					player_index++;
 				}
 			}
-			type_index++;
 		}
 	}
 }
 
-get_first_active_name( type_struct )
+get_first_active_name( type_struct ) //checked partially changed to match beta dump
 {
 	size = type_struct.sorted_prio_keys.size;
-	prio_index = 0;
+	for ( prio_index = 0; prio_index < size; prio_index++ )
-	while ( prio_index < size )
 	{
 		prio_key = type_struct.sorted_prio_keys[ prio_index ];
 		if ( type_struct.info[ prio_key ].state.players[ self._player_entnum ].active )
 		{
 			return prio_key;
 		}
-		prio_index++;
 	}
 	return level.vsmgr_default_info_name;
 }
 
-update_clientfields( player, type_struct )
+update_clientfields( player, type_struct ) //checked changed to match beta dump
 {
 	name = player get_first_active_name( type_struct );
 	player setclientfieldtoplayer( type_struct.cf_slot_name, type_struct.info[ name ].slot_index );
-	if ( type_struct.cf_lerp_bit_count >= 1 )
+	if ( type_struct.cf_lerp_bit_count > 1 )
 	{
 		player setclientfieldtoplayer( type_struct.cf_lerp_name, type_struct.info[ name ].state.players[ player._player_entnum ].lerp );
 	}
 }
 
-lerp_thread_wrapper( func, opt_param_1, opt_param_2 )
+lerp_thread_wrapper( func, opt_param_1, opt_param_2 ) //checked matches beta dump
 {
 	self notify( "deactivate" );
 	self endon( "deactivate" );
 	self [[ func ]]( opt_param_1, opt_param_2 );
 }
 
-lerp_thread_per_player_wrapper( func, player, opt_param_1, opt_param_2 )
+lerp_thread_per_player_wrapper( func, player, opt_param_1, opt_param_2 ) //checked matches beta dump
 {
 	player_entnum = player getentitynumber();
 	self notify( "deactivate" );
@@ -468,14 +427,14 @@ lerp_thread_per_player_wrapper( func, player, opt_param_1, opt_param_2 )
 	self [[ func ]]( player, opt_param_1, opt_param_2 );
 }
 
-activate_per_player( type, name, player, opt_param_1, opt_param_2 )
+activate_per_player( type, name, player, opt_param_1, opt_param_2 ) //checked changed to match beta dump
 {
 	player_entnum = player getentitynumber();
 	state = level.vsmgr[ type ].info[ name ].state;
 	if ( state.ref_count_lerp_thread )
 	{
 		state.players[ player_entnum ].ref_count++;
-		if ( state.players[ player_entnum ].ref_count >= 1 )
+		if ( state.players[ player_entnum ].ref_count > 1 )
 		{
 			return;
 		}
@@ -490,7 +449,7 @@ activate_per_player( type, name, player, opt_param_1, opt_param_2 )
 	}
 }
 
-deactivate_per_player( type, name, player )
+deactivate_per_player( type, name, player ) //checked changed to match beta dump
 {
 	player_entnum = player getentitynumber();
 	state = level.vsmgr[ type ].info[ name ].state;
@@ -498,7 +457,7 @@ deactivate_per_player( type, name, player )
 	{
 		state.players[ player_entnum ].ref_count--;
 
-		if ( state.players[ player_entnum ].ref_count >= 0 )
+		if ( state.players[ player_entnum ].ref_count > 0 )
 		{
 			return;
 		}
@@ -507,7 +466,7 @@ deactivate_per_player( type, name, player )
 	state notify( "deactivate" );
 }
 
-calc_remaining_duration_lerp( start_time, end_time )
+calc_remaining_duration_lerp( start_time, end_time ) //checked matches beta dump
 {
 	now = getTime();
 	frac = float( end_time - now ) / float( end_time - start_time );

patch_zm/readme.md

@@ -79,6 +79,7 @@ patch_zm/maps/mp/zombies/_zm_traps.gsc
 patch_zm/maps/mp/zombies/_zm_turned.gsc
 patch_zm/maps/mp/zombies/_zm_unitrigger.gsc
 patch_zm/maps/mp/zombies/_zm_weap_cymbal_monkey.gsc
+patch_zm/maps/mp/_visionset_mgr.gsc
 ```
 ### The following scripts are not checked yet, uploaded to setup a baseline:
 ```
@@ -105,7 +106,6 @@ patch_zm/maps/mp/_script_gen.gsc
 patch_zm/maps/mp/serverfaceanim_mp.gsc
 patch_zm/maps/mp/_sticky_grenade.gsc
 patch_zm/maps/mp/_utility.gsc
-patch_zm/maps/mp/_visionset_mgr.gsc
 
 patch_zm/maps/mp/gametypes_zm/_gameobjects.gsc
 patch_zm/maps/mp/gametypes_zm/_globallogic_audio.gsc