You can do it in literally any corner... They are not in any actual glitch..

As you can see, if white player stands in a corner and another player crouches in front of them, the zombies will only try to go towards white player even though the other players are closer. This proves that white player has priority. And this glitch still works they never patched it.

But there is lol, have you never seen any high round BO1 gameplay? Everyone uses the fact that zombies are more attracted to white player to their advantage. It is a known fact.

and that was what someone told you to change In a comment ( don't coz it's irrelevent )

The point is still there. Read the code "you" just posted. It gets the closest player - determined by how long the path is to each player - it is "not" weighted and I'm yet to experience this issue "in game"

Think your mistaken due to misinfo - I've seen people say this but I assure you it - is - wrong

There has got to be some hidden code somewhere that makes it weighted though. I know that it for sure is.

There is only one line of code under if(players.size == 1)

if( players.size == 1 )
{
	self.ignore_player = [];
}

All I know is that the upmost player on the scoreboard gets favorited over the others (and then the 2nd upmost player is favorited towards the players below him and so on).

Here is the code for get_closest_valid_player():

get_closest_valid_player( origin, ignore_player )
{
	valid_player_found = false; 
 
	players = get_players();	
	if( is_true( level._zombie_using_humangun ) )
	{
		players = array_merge( players, level._zombie_human_array );
	}
 
	if( IsDefined( ignore_player ) )
	{
 
		for(i = 0; i < ignore_player.size; i++ )
		{
			players = array_remove( players, ignore_player[i] );
		}
 
	}
	while( !valid_player_found )
	{
 
		if( is_true(level.calc_closest_player_using_paths) )
		{
			player = get_closest_player_using_paths( origin, players );
		}
		else
		{
			player = GetClosest( origin, players );
		} 
		if( !isdefined( player ) )
		{
			return undefined; 
		}
 
		if( is_true( level._zombie_using_humangun ) && IsAI( player ) )
		{
			return player;
		}
 
 
		if( !is_player_valid( player, true ) )
		{
			players = array_remove( players, player ); 
			continue; 
		}
		return player; 
	}
}

get_closest_player_using_paths( origin, players )
{
 
 
	min_length_to_player = 9999999;
	player_to_return = undefined;
	for(i = 0; i < players.size; i++ )
	{
		player = players[i];
		length_to_player = get_path_length_to_enemy( player );
 
 
		if( length_to_player < min_length_to_player )
		{
			min_length_to_player = length_to_player;
			player_to_return = player;
		}
	}
 
	return player_to_return;
}

get_path_length_to_enemy( enemy )
{
 
 
 
 
	path_length = self CalcPathLength( enemy.origin );
 
	return path_length;
}

I made a function that makes the zombies never ignore any players for as long as they are live, but it didn't change anything, so I don't think self.ignore_player has anything to do with zombies being more attracted towards certain players

after comparing bo1 _zombiemode_spawner script to the waw version it looks like you pretty much just need to comment out/change  these few sections of code from find_flesh in zombiemode_spawner.gsc
comment out this section of code

               near_zombies = getaiarray("axis");
		same_enemy_count = 0;
		for (i = 0; i < near_zombies.size; i++)
		{
			if ( isdefined( near_zombies[i] ) && isalive( near_zombies[i] ) )
			{
				if ( isdefined( near_zombies[i].favoriteenemy ) && isdefined( self.favoriteenemy ) 
				&&	near_zombies[i].favoriteenemy == self.favoriteenemy )
				{
					if ( distancesquared( near_zombies[i].origin, self.favoriteenemy.origin ) < 225 * 225 
					&&	 distancesquared( near_zombies[i].origin, self.origin ) > 525 * 525)
					{
						same_enemy_count++;
					}
				}
			}
		}
 
		if (same_enemy_count > 12)
		{
			self.ignore_player[self.ignore_player.size] = self.favoriteenemy;
		}

and change this section

if( players.size == 1 )
		{
			self.ignore_player = [];
		}
 
		else
		{
			for(i = 0; i < self.ignore_player.size; i++)
			{
				if( IsDefined( self.ignore_player[i] ) && IsDefined( self.ignore_player[i].ignore_counter ) && self.ignore_player[i].ignore_counter > 3 )
				{
					self.ignore_player[i].ignore_counter = 0;
					self.ignore_player = array_remove( self.ignore_player, self.ignore_player[i] );
				}
			}
		}
 
		player = get_closest_valid_player( self.origin, self.ignore_player );
		if( !isDefined( player ) && !isDefined( zombie_poi ) )
		{
			self zombie_history( "find flesh -> can't find player, continue" );
			if( IsDefined( self.ignore_player ) )
			{
				self.ignore_player = [];
			}
			wait( 1 ); 
			continue; 
		}
 
 
 
		if ( !isDefined( level.check_for_alternate_poi ) || ![[level.check_for_alternate_poi]]() )
		{
			self.enemyoverride = zombie_poi;
			self.favoriteenemy = player;
		}

to this

		// If playing single player, never ignore the player
		if( players.size == 1 )
		{
			self.ignore_player = undefined;
		}
 
		player = get_closest_valid_player( self.origin, self.ignore_player ); 
 
		if( !isDefined( player ) && !isDefined( zombie_poi ) )
		{
			self zombie_history( "find flesh -> can't find player, continue" );
			if( IsDefined( self.ignore_player ) )
			{
				self.ignore_player = undefined;
				self.ignore_player = [];
			}

			wait( 1 ); 
			continue; 
		}
 
		self.ignore_player = undefined;

		self.enemyoverride = zombie_poi;
		self.favoriteenemy = player;

by removing the section that trys to decide which player they should prefer over the other players it should revert to selecting the player based only on the distance from the zombie to the player
i havent tested this, ive just looked at the difference between the different the two scripts and thats the largest differences

Didn't work. Made the game lag horribly bad every 2-3 seconds in co-op

I know I've posted this before, but I still haven't figured it out.

How do you remove zombies being more attracted towards certain players in Black Ops 1? I want zombies to be equally attracted to all players.

Depending on where you put it, you might need to use a while function.

end_at_round(round)
{
	while(1)
	{
		if(level.round_number == round)
		{
			level notify( "end_game" );
			break;
		}
		wait(.05);
	}
}

At the top of the script, under main(), put:

level thread end_at_round(2);

Make sure to change the round from the function call to the round number you want the game to end at

Some new changes:

Turrets will not attack the player who activates them, and turrets will attack zombies if no enemy player is nearby
Punishment points now take 100-2500 points instead of 25% of the players points
Players will no longer get damaged by their own claymores and will no longer have shellshock effect
Clip unload now shows red text hud
Turrets are now 10 points on a fire sale
Removed deadshot double headshot damage (for now)
Multiple players can now buy the same perk at the same time
The wait time between griefs is now correctly working

The latest version is now out! The mod now works on Moon and tons of fixes that make the mod feel much better. Download the file from the first post.

This mod is going to be completely re-done as I was using outdated versions of the scripts when I made this and have started running into several big problems, such as Moon not working.

I will post my progress on this thread.

Whenever a player spawns in my mod, it makes all the other alive players stop moving. They have to let go of their move key and press it again to move again. It is very annoying, why is this happening?

Please somebody help me

i think it is networking related, as the white player is always the host if i am not mistaken

White player is only always host on PC. On consoles, white player may not be host sometimes and it is still the white player the zombies are most attracted to.

---

Double Post Merge: December 24, 2015, 04:36:21 am

---

i feel like this is because in every check in an array of players, player 0 ( white ) is always first. if there are checks that just go through who ever passes first, white player will always be checked first so he might always pass first. idk just a thought

Is there a way I could get the zombies to truly go after which player is closest to them?