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

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

player = get_closest_valid_player( self.origin, self.ignore_player );

like i just said, your looking for "nothing" anyway

they are not attracted to "player 1" they are attracted to "the closest player"

in the event the distance between 2 players is the same - then itll use the indexes, not "all the time"...

look its in the code you posted from source...

player = get_closest_valid_player( self.origin, self.ignore_player );

self.favoriteenemy

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;
}

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

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