#include maps/mp/zm_transit_cling;
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/animscripts/zm_run;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/animscripts/zm_shared;
#include maps/mp/animscripts/zm_utility;
#include maps/mp/zm_transit_bus;
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/zm_transit_utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/zombies/_zm_blockers;
#include maps/mp/_utility;
#include common_scripts/utility;

main()
{
	self _businittags();
	self _setupnumattachtable();
	self.openings = [];
	x = 1;
	while ( x <= 10 )
	{
		script_noteworthy = undefined;
		switch( x )
		{
			case 10:
				script_noteworthy = "front";
				break;
			case 11:
			case 12:
				script_noteworthy = "door";
				break;
		}
		self busaddopening( "tag_entry_point" + x, script_noteworthy );
		x++;
	}
	self bussetupladder();
	self bussetuproofopening();
	self businitmantle();
	self businitrightandleft();
}

busaddopening( tag_name, script_noteworthy )
{
	index = self.openings.size;
	self.openings[ index ] = spawnstruct();
	opening = self.openings[ index ];
	opening.name = script_noteworthy;
	opening.enabled = 1;
	opening.zombie = undefined;
	opening.boards = [];
	opening.boardsnum = 0;
	opening.blockertrigger = undefined;
	opening.zombietrigger = undefined;
	opening.rebuildtrigger = undefined;
	opening.tagname = tag_name;
	opening.bindtag = _busfindclosesttag( self gettagorigin( tag_name ) );
/#
	assert( isDefined( opening.bindtag ) );
#/
	opening.jumptag = _busgetjumptagfrombindtag( opening.bindtag );
	opening.jumpent = level.the_bus;
	opening.roofjoint = _busgetroofjointfrombindtag( opening.bindtag );
	opening.origin = level.the_bus gettagorigin( opening.bindtag );
	opening.angles = self gettagangles( opening.bindtag );
	targets = getentarray( tag_name, "targetname" );
	if ( !isDefined( targets ) )
	{
/#
		assert( 0 );
#/
		return;
	}
	if ( !is_classic() )
	{
		i = 0;
		while ( i < targets.size )
		{
			if ( targets[ i ] iszbarrier() )
			{
				targets[ i ] delete();
			}
			i++;
		}
		return;
	}
	i = 0;
	while ( i < targets.size )
	{
		target = targets[ i ];
		if ( target iszbarrier() )
		{
			hasbarriers = 1;
			if ( isDefined( script_noteworthy ) && script_noteworthy == "front" )
			{
				hasbarriers = 0;
			}
			opening.zbarrier = target;
			opening.zbarrier setmovingplatformenabled( 1 );
			while ( hasbarriers )
			{
				opening.zbarrier.chunk_health = [];
				opening.zbarrier setzbarriercolmodel( "p6_anim_zm_barricade_board_bus_collision" );
				maps/mp/zombies/_zm_powerups::register_carpenter_node( opening, ::post_carpenter_callback );
				j = 0;
				while ( j < opening.zbarrier getnumzbarrierpieces() )
				{
					opening.zbarrier.chunk_health[ j ] = 0;
					j++;
				}
			}
			target.origin = level.the_bus gettagorigin( opening.bindtag );
		}
		else if ( target.script_noteworthy == "blocker" )
		{
			target delete();
			i++;
			continue;
		}
		else if ( target.script_noteworthy == "rebuild" )
		{
			opening.rebuildtrigger = target;
			opening.rebuildtrigger enablelinkto();
			opening.rebuildtrigger linkto( self );
			opening.rebuildtrigger setcursorhint( "HINT_NOICON" );
			opening.rebuildtrigger set_hint_string( self, "default_reward_barrier_piece" );
			opening.rebuildtrigger triggerignoreteam();
			opening.rebuildtrigger setinvisibletoall();
			opening.rebuildtrigger setmovingplatformenabled( 1 );
			self thread busopeningrebuildthink( opening );
			i++;
			continue;
		}
		else if ( target.script_noteworthy == "zombie" )
		{
			opening.zombietrigger = target;
			opening.zombietrigger enablelinkto();
			opening.zombietrigger linkto( self );
			opening.zombietrigger setmovingplatformenabled( 1 );
			opening.zombietrigger setteamfortrigger( level.zombie_team );
			self thread busopeningzombiethink( opening );
		}
		target linkto( self, "", self worldtolocalcoords( target.origin ), target.angles - self.angles );
		i++;
	}
	if ( isDefined( opening.zbarrier ) )
	{
		opening blocker_attack_spots();
	}
	opening notify( "opening_init_complete" );
/#
	if ( opening.boardsnum != 0 )
	{
		assert( opening.boardsnum == opening.boards.size );
	}
#/
}

post_carpenter_callback()
{
	if ( isDefined( self.rebuildtrigger ) )
	{
		self.rebuildtrigger setinvisibletoall();
	}
}

businitmantle()
{
	mantlebrush = getentarray( "window_mantle", "targetname" );
	while ( isDefined( mantlebrush ) && mantlebrush.size > 0 )
	{
		i = 0;
		while ( i < mantlebrush.size )
		{
			mantlebrush[ i ] delete();
			i++;
		}
	}
}

busattachjumpent( ent, opening )
{
	jump_origin = self gettagorigin( opening.jumptag );
	jump_angles = self gettagangles( opening.jumptag );
	ent.origin = jump_origin;
	ent.angles = jump_angles;
	ent linkto( self, "", self worldtolocalcoords( ent.origin ), ent.angles - self.angles );
}

busopeningbyname( name )
{
	i = 0;
	while ( i < self.openings.size )
	{
		opening = self.openings[ i ];
		if ( isDefined( opening.name ) && opening.name == name )
		{
			return opening;
		}
		i++;
	}
	return undefined;
}

busopeningsetenabled( name, enabled )
{
	i = 0;
	while ( i < self.openings.size )
	{
		opening = self.openings[ i ];
		if ( isDefined( opening.name ) && opening.name == name )
		{
			opening.enabled = enabled;
		}
		i++;
	}
}

_businittags()
{
	self.openingtags = [];
	self.openingtags[ self.openingtags.size ] = "window_right_front_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_front_jnt";
	self.openingtags[ self.openingtags.size ] = "door_front_jnt";
	self.openingtags[ self.openingtags.size ] = "door_rear_jnt";
	self.openingtags[ self.openingtags.size ] = "window_right_1_jnt";
	self.openingtags[ self.openingtags.size ] = "window_right_2_jnt";
	self.openingtags[ self.openingtags.size ] = "window_right_3_jnt";
	self.openingtags[ self.openingtags.size ] = "window_right_4_jnt";
	self.openingtags[ self.openingtags.size ] = "window_right_rear_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_rear_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_1_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_2_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_3_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_4_jnt";
	self.openingtags[ self.openingtags.size ] = "window_left_5_jnt";
/#
	i = 0;
	while ( i < self.openingtags.size )
	{
		adddebugcommand( "devgui_cmd "Zombies:1/Bus:14/Window Openings:3/Select Tag:1/" + self.openingtags[ i ] + ":" + self.openingtags.size + "" "zombie_devgui attach_tag " + self.openingtags[ i ] + ""\n" );
		i++;
#/
	}
}

_busfindclosesttag( checkpos )
{
	closest = undefined;
	closestdist = -1;
/#
	assert( isDefined( self.openingtags ) );
#/
	i = 0;
	while ( i < self.openingtags.size )
	{
		tag = self.openingtags[ i ];
		pos = self gettagorigin( tag );
		dist2 = distancesquared( checkpos, pos );
		if ( !isDefined( closest ) || dist2 < closestdist )
		{
			closest = tag;
			closestdist = dist2;
		}
		i++;
	}
	return closest;
}

_busgetjumptagfrombindtag( tag )
{
	jump_tag = undefined;
	switch( tag )
	{
		case "window_right_1_jnt":
			jump_tag = "window_right_1_jmp_jnt";
			break;
		case "window_right_2_jnt":
			jump_tag = "window_right_2_jmp_jnt";
			break;
		case "window_right_3_jnt":
			jump_tag = "window_right_3_jmp_jnt";
			break;
		case "window_right_4_jnt":
			jump_tag = "window_right_4_jmp_jnt";
			break;
		case "window_left_1_jnt":
			jump_tag = "window_left_1_jmp_jnt";
			break;
		case "window_left_2_jnt":
			jump_tag = "window_left_2_jmp_jnt";
			break;
		case "window_left_3_jnt":
			jump_tag = "window_left_3_jmp_jnt";
			break;
		case "window_left_4_jnt":
			jump_tag = "window_left_4_jmp_jnt";
			break;
		case "window_left_5_jnt":
			jump_tag = "window_left_5_jmp_jnt";
			break;
		case "window_right_rear_jnt":
			jump_tag = "window_right_rear_jmp_jnt";
			break;
		case "window_left_rear_jnt":
			jump_tag = "window_left_rear_jmp_jnt";
			break;
		case "window_right_front_jnt":
			jump_tag = "window_right_front_jmp_jnt";
			break;
		case "window_left_front_jnt":
			jump_tag = "window_left_front_jmp_jnt";
			break;
		case "door_rear_jnt":
			jump_tag = "door_rear_jmp_jnt";
			break;
		case "door_front_jnt":
			jump_tag = "door_front_jmp_jnt";
			break;
		default:
		}
		return jump_tag;
	}
}

_busgetroofjointfrombindtag( tag )
{
	roofjoint = undefined;
	switch( tag )
	{
		case "window_left_1_jnt":
		case "window_left_front_jnt":
		case "window_right_1_jnt":
		case "window_right_front_jnt":
			roofjoint = "window_roof_1_jnt";
			break;
		case "window_left_2_jnt":
		case "window_left_3_jnt":
		case "window_left_4_jnt":
		case "window_left_5_jnt":
		case "window_left_rear_jnt":
		case "window_right_2_jnt":
		case "window_right_3_jnt":
		case "window_right_4_jnt":
		case "window_right_rear_jnt":
			roofjoint = "window_roof_2_jnt";
			default:
				break;
		}
		return roofjoint;
	}
}

_setupnumattachtable()
{
	level.numattachtable = [];
	level.numattachtable[ 0 ] = -1;
	level.numattachtable[ 1 ] = 6;
	level.numattachtable[ 2 ] = 8;
	level.numattachtable[ 3 ] = 10;
	level.numattachtable[ 4 ] = -1;
}

busgetopeningfortag( tagname )
{
	i = 0;
	while ( i < self.openings.size )
	{
		if ( self.openings[ i ].bindtag == tagname )
		{
			return self.openings[ i ];
		}
		i++;
	}
	return undefined;
}

zombieanimnotetrackthink( notifystring, chunk, node )
{
	self endon( "death" );
	while ( 1 )
	{
		self waittill( notifystring, notetrack );
		if ( notetrack == "end" )
		{
			return;
			continue;
		}
		else if ( notetrack == "board" || notetrack == "destroy_piece" )
		{
			node.zbarrier setzbarrierpiecestate( chunk, "opening" );
			if ( isDefined( node.rebuildtrigger ) )
			{
				node.rebuildtrigger setvisibletoall();
			}
			continue;
		}
		else
		{
			while ( notetrack == "fire" )
			{
				attackplayers = self zombiegetplayerstoattack();
				while ( attackplayers.size )
				{
					i = 0;
					while ( i < attackplayers.size )
					{
						attackplayers[ i ] dodamage( self.meleedamage, self.origin, self, self, "none", "MOD_MELEE" );
						i++;
					}
				}
			}
		}
	}
}

busopeningblockerthink( opening )
{
	self endon( "intermission" );
	while ( 1 )
	{
		opening.blockertrigger waittill( "trigger", player );
		while ( isDefined( opening.zombie ) )
		{
			continue;
		}
	}
	self notify( "OnBlockerPlaced" );
}

buswatchtriggervisibility( opening )
{
	self endon( "intermission" );
	opening waittill( "opening_init_complete" );
	if ( !isDefined( opening.zbarrier ) || opening.zbarrier getnumzbarrierpieces() < 1 )
	{
		return;
	}
	if ( !isDefined( level.buswatchtriggervisibility_spread ) )
	{
		level.buswatchtriggervisibility_spread = 0;
	}
	else
	{
		level.buswatchtriggervisibility_spread++;
		wait ( 0,05 * level.buswatchtriggervisibility_spread );
	}
	while ( 1 )
	{
		if ( no_valid_repairable_boards( opening ) )
		{
			opening.rebuildtrigger setinvisibletoall();
		}
		else
		{
			opening.rebuildtrigger setvisibletoall();
		}
		wait 1;
	}
}

busopeningrebuildthink( opening )
{
	self endon( "intermission" );
	self thread buswatchtriggervisibility( opening );
	cost = 10;
	if ( isDefined( opening.rebuildtrigger.zombie_cost ) )
	{
		cost = opening.rebuildtrigger.zombie_cost;
	}
	while ( 1 )
	{
		opening.rebuildtrigger waittill( "trigger", player );
		players = get_players();
		has_perk = player has_blocker_affecting_perk();
		while ( player_fails_blocker_repair_trigger_preamble( player, players, opening.rebuildtrigger, 0 ) )
		{
			continue;
		}
		while ( all_chunks_intact( opening ) )
		{
			continue;
		}
		while ( no_valid_repairable_boards( opening ) )
		{
			continue;
		}
		chunk = get_random_destroyed_chunk( opening );
		if ( isDefined( player.pers_upgrades_awarded[ "board" ] ) )
		{
			self thread replace_chunk( opening, chunk, has_perk, player.pers_upgrades_awarded[ "board" ] );
		}
		opening do_post_chunk_repair_delay( has_perk );
		while ( !is_player_valid( player ) )
		{
			if ( no_valid_repairable_boards( opening ) )
			{
				opening.rebuildtrigger setinvisibletoall();
			}
		}
		player handle_post_board_repair_rewards( cost );
		if ( no_valid_repairable_boards( opening ) )
		{
			opening.rebuildtrigger setinvisibletoall();
		}
	}
}

_determinejumpfromorigin( opening )
{
	return level.the_bus gettagorigin( opening.jumptag );
}

_getsideofbusopeningison( opening_tag )
{
	side = undefined;
	switch( opening_tag )
	{
		case "door_front_jnt":
		case "door_rear_jnt":
		case "window_right_1_jnt":
		case "window_right_2_jnt":
		case "window_right_3_jnt":
		case "window_right_4_jnt":
			side = "right";
			break;
		case "window_left_1_jnt":
		case "window_left_2_jnt":
		case "window_left_3_jnt":
		case "window_left_4_jnt":
		case "window_left_5_jnt":
			side = "left";
			break;
		case "window_left_front_jnt":
		case "window_right_front_jnt":
			side = "front";
			break;
		case "window_left_rear_jnt":
		case "window_right_rear_jnt":
			side = "back";
			break;
	}
	return side;
}

busopeningzombiethink( opening )
{
	self endon( "intermission" );
	if ( _isopeningdoor( opening.bindtag ) )
	{
		opening.enabled = 0;
		return;
	}
	while ( 1 )
	{
		opening.zombietrigger waittill( "trigger", zombie );
		while ( zombie.isdog )
		{
			continue;
		}
		if ( isDefined( zombie.isscreecher ) && zombie.isscreecher )
		{
			continue;
		}
		if ( isDefined( zombie.is_avogadro ) && zombie.is_avogadro )
		{
			continue;
		}
		while ( !isalive( zombie ) )
		{
			continue;
		}
		while ( !opening.enabled )
		{
			continue;
		}
		if ( _isopeningdoor( opening.bindtag ) && self.doorsclosed )
		{
			continue;
		}
		if ( isDefined( zombie.favoriteenemy ) )
		{
			enemy_on_roof = zombie.favoriteenemy.isonbusroof;
		}
		while ( self.ismoving && isDefined( self.disabled_by_emp ) && self.disabled_by_emp && !self.doorsclosed && !enemy_on_roof )
		{
			continue;
		}
		monkey = undefined;
		if ( isDefined( zombie.enemyoverride ) )
		{
			monkey = zombie.enemyoverride[ 1 ];
		}
		if ( isDefined( monkey ) && !monkey maps/mp/zm_transit_bus::entity_is_on_bus( 1 ) )
		{
			continue;
		}
		if ( !isDefined( zombie.favoriteenemy ) || !zombie.favoriteenemy.isonbus )
		{
			continue;
		}
		if ( isDefined( zombie.isonbus ) && zombie.isonbus )
		{
			continue;
		}
		while ( isDefined( zombie.opening ) )
		{
			continue;
		}
		while ( isDefined( opening.zombie ) )
		{
			continue;
		}
		if ( isDefined( zombie.is_inert ) && zombie.is_inert )
		{
			continue;
		}
		if ( isDefined( zombie.cannotattachtobus ) && zombie.cannotattachtobus )
		{
			continue;
		}
		while ( !level.the_bus.ismoving )
		{
			jump_origin = _determinejumpfromorigin( opening );
			distance_from_jump_origin2 = distance2dsquared( jump_origin, zombie.origin );
			while ( distance_from_jump_origin2 > 256 )
			{
				continue;
			}
		}
		if ( isDefined( zombie.dismount_start ) && zombie.dismount_start )
		{
			continue;
		}
		zombie thread zombieattachtobus( self, opening );
	}
}

_buscanzombieattach( zombie )
{
	currentlyattached = 0;
	i = 0;
	while ( i < self.openings.size )
	{
		if ( isDefined( self.openings[ i ].zombie ) )
		{
			currentlyattached++;
		}
		i++;
	}
	players = get_players();
	maxattach = level.numattachtable[ players.size ];
	if ( maxattach < 0 )
	{
		return currentlyattached < maxattach;
	}
}

zombieplayattachedanim( animname )
{
	self endon( "death" );
	anim_index = self getanimsubstatefromasd( "zm_bus_attached", animname );
	animationid = self getanimfromasd( "zm_bus_attached", anim_index );
	tag_origin = self.attachent gettagorigin( self.attachtag );
	tag_angles = self.attachent gettagangles( self.attachtag );
	start_origin = getstartorigin( tag_origin, tag_angles, animationid );
	start_angles = getstartangles( tag_origin, tag_angles, animationid );
	self animscripted( start_origin, start_angles, "zm_bus_attached", anim_index );
	self zombieanimnotetrackthink( "bus_attached_anim" );
}

debugline( frompoint, color, durationframes )
{
/#
	i = 0;
	while ( i < durationframes )
	{
		line( frompoint, ( frompoint[ 0 ], frompoint[ 1 ], frompoint[ 2 ] + 50 ), color );
		wait 0,05;
		i++;
#/
	}
}

debugbox( frompoint, color, durationframes )
{
/#
	i = 0;
	while ( i < durationframes )
	{
		box( frompoint, ( 0, -1, 0 ), ( 0, -1, 0 ), 0, color );
		wait 0,05;
		i++;
#/
	}
}

_isopeningdoor( opening_tag )
{
	is_door = 0;
	switch( opening_tag )
	{
		case "door_front_jnt":
		case "door_rear_jnt":
			is_door = 1;
			break;
		default:
		}
		return is_door;
	}
}

busexitthink( trigger )
{
	while ( 1 )
	{
		trigger waittill( "trigger", zombie );
		if ( isDefined( zombie.is_inert ) && zombie.is_inert )
		{
			continue;
		}
		if ( isDefined( zombie.walk_to_exit ) && !zombie.walk_to_exit )
		{
			continue;
		}
		if ( isDefined( zombie.exiting_window ) && zombie.exiting_window )
		{
			continue;
		}
		going_to_roof = 0;
		while ( isDefined( zombie.favoriteenemy ) && zombie.favoriteenemy.isonbusroof == 1 )
		{
			going_to_roof = 1;
			while ( trigger.substate == 2 )
			{
				continue;
			}
		}
		while ( !going_to_roof && isDefined( level.the_bus.doorsclosed ) && !level.the_bus.doorsclosed && zombie.ai_state != "zombieWindowToRoof" )
		{
			continue;
		}
		zombie thread zombieexitwindow( self, trigger, going_to_roof );
	}
}

zombieexitwindow( bus, trigger, going_to_roof )
{
	self endon( "death" );
	self.ai_state = "zombieExitWindow";
	self.inert_delay = ::zombieexitwindowdelay;
	self.exiting_window = 1;
	self linkto( bus, trigger.tag );
	tag_origin = bus gettagorigin( trigger.tag );
	tag_angles = bus gettagangles( trigger.tag );
	exit_anim = "zm_window_exit";
	if ( going_to_roof )
	{
		exit_anim = "zm_bus_window2roof";
	}
	animstate = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( exit_anim );
	self animscripted( tag_origin, tag_angles, animstate, trigger.substate );
	maps/mp/animscripts/zm_shared::donotetracks( "window_exit_anim" );
	self.exiting_window = undefined;
	self.walk_to_exit = undefined;
	self unlink();
	self setgoalpos( self.origin );
	self.inert_delay = undefined;
	if ( going_to_roof )
	{
		return;
	}
	self animmode( "normal" );
	self orientmode( "face enemy" );
	self.forcemovementscriptstate = 0;
	self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}

zombieexitwindowdelay()
{
	self endon( "death" );
	while ( isDefined( self.exiting_window ) && self.exiting_window )
	{
		wait 0,1;
	}
	while ( 1 )
	{
		if ( self.ai_state == "find_flesh" )
		{
			break;
		}
		else
		{
			wait 0,1;
		}
	}
	self notify( "stop_find_flesh" );
	self notify( "zombie_acquire_enemy" );
	self.inert_delay = undefined;
}

teleportthreadex( verticaloffset, delay, frames )
{
	amount = verticaloffset / frames;
	if ( amount > 10 )
	{
		amount = 10;
	}
	else
	{
		if ( amount < -10 )
		{
			amount = -10;
		}
	}
	offset = ( 0, 0, amount );
	i = 0;
	while ( i < frames )
	{
		self teleport( self.origin + offset );
		wait 0,05;
		i++;
	}
}

zombieopeningdelay()
{
	self endon( "death" );
	self maps/mp/zombies/_zm_spawner::zombie_history( "opening delay detach " + getTime() );
	while ( isDefined( self.jumpingtowindow ) && self.jumpingtowindow )
	{
		while ( 1 )
		{
			if ( isDefined( self.jumpingtowindow ) && !self.jumpingtowindow )
			{
				break;
			}
			else
			{
				wait 0,1;
			}
		}
	}
	self zombiedetachfrombus( self.left_or_right );
	while ( 1 )
	{
		if ( self.ai_state == "find_flesh" )
		{
			break;
		}
		else
		{
			wait 0,1;
		}
	}
	self notify( "stop_find_flesh" );
	self notify( "zombie_acquire_enemy" );
	self.inert_delay = undefined;
}

zombieattachtobus( thebus, opening, removeafterdone )
{
	self endon( "death" );
	self endon( "removed" );
	self endon( "sonicBoom" );
	level endon( "intermission" );
	self notify( "stop_find_flesh" );
	self notify( "zombie_acquire_enemy" );
	self endon( "detach_on_window" );
	self endon( "exploding" );
	self.ai_state = "zombieAttachToBus";
	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieAttachToBus " + getTime() );
	opening.zombie = self;
	self.dont_throw_gib = 1;
	self.forcemovementscriptstate = 1;
	self.opening = opening;
	self.left_or_right = self zombieattachleftorright( thebus );
	self.attachent = level.the_bus;
	self.attachtag = self.opening.bindtag;
	self linkto( self.attachent, self.attachtag );
	from_front = 0;
	from_rear = 0;
	self.inert_delay = ::zombieopeningdelay;
	if ( _isopeningdoor( opening.bindtag ) )
	{
		self animscripted( self.origin, self.angles, "zm_jump_on_bus", 0 );
		if ( opening.bindtag == "door_front_jnt" )
		{
			from_front = 1;
		}
		else
		{
			from_rear = 1;
		}
	}
	else
	{
		self.jumpingtowindow = 1;
		asd_name = "zm_zbarrier_jump_on_bus";
		side = _getsideofbusopeningison( opening.bindtag );
		if ( isDefined( side ) && side == "front" )
		{
			asd_name = "zm_zbarrier_jump_on_bus_front";
		}
		animstate = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( asd_name );
		tag_origin = self.attachent gettagorigin( self.attachtag );
		tag_angles = self.attachent gettagangles( self.attachtag );
		self animmode( "noclip" );
		self animscripted( tag_origin, tag_angles, animstate, "jump_window" + self.left_or_right );
	}
	self zombieanimnotetrackthink( "jump_on_bus_anim" );
	self animmode( "gravity" );
	self.jumpingtowindow = 0;
	if ( isDefined( self.a.gib_ref ) || self.a.gib_ref == "left_arm" && self.a.gib_ref == "right_arm" )
	{
		self dodamage( self.health + 666, self.origin );
		self startragdoll();
		self launchragdoll( ( 0, -1, 0 ) );
		opening.zombie = undefined;
	}
	if ( 1 )
	{
		hitpos = self.attachent gettagorigin( self.attachtag );
		hitposinbus = pointonsegmentnearesttopoint( thebus.frontworld, thebus.backworld, hitpos );
		hitdir = vectornormalize( hitposinbus - hitpos );
		hitforce = vectorScale( hitdir, 100 );
		hitpos += vectorScale( ( 0, -1, 0 ), 50 );
		earthquake( randomfloatrange( 0,3, 0,4 ), randomfloatrange( 0,2, 0,4 ), hitpos, 150 );
		play_sound_at_pos( "grab_metal_bar", hitpos );
	}
	if ( self zombiecanjumponroof( opening ) )
	{
		self zombiejumponroof( thebus, opening, removeafterdone, self.left_or_right );
		self zombiesetnexttimetojumponroof();
		self maps/mp/animscripts/zm_run::needsupdate();
		if ( !self.isdog )
		{
			self maps/mp/animscripts/zm_run::moverun();
		}
	}
	else
	{
		for ( ;; )
		{
			while ( 1 )
			{
				if ( !isDefined( opening.zbarrier ) || maps/mp/zombies/_zm_spawner::get_attack_spot( opening ) )
				{
					break;
				}
				else
				{
/#
					println( "Zombie failed to get bus attack spot" );
#/
					wait 0,5;
				}
			}
		}
		while ( !all_chunks_destroyed( opening ) )
		{
			if ( zombieshoulddetachfromwindow() )
			{
				zombiedetachfrombus( self.left_or_right );
				return;
			}
			self.onbuswindow = 1;
			chunk = get_closest_non_destroyed_chunk( self.origin, opening );
			waited = 0;
			if ( isDefined( chunk ) )
			{
				waited = 1;
				opening.zbarrier setzbarrierpiecestate( chunk, "targetted_by_zombie" );
				opening thread check_zbarrier_piece_for_zombie_death( chunk, opening.zbarrier, self );
				self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "teardown", self.animname );
				animstatebase = opening.zbarrier getzbarrierpieceanimstate( chunk );
				animsubstate = "spot_" + self.attacking_spot_index + self.left_or_right + "_piece_" + opening.zbarrier getzbarrierpieceanimsubstate( chunk );
				anim_sub_index = self getanimsubstatefromasd( animstatebase + "_in", animsubstate );
				tag_origin = self.attachent gettagorigin( self.attachtag );
				tag_angles = self.attachent gettagangles( self.attachtag );
				self animscripted( tag_origin, tag_angles, maps/mp/animscripts/zm_utility::append_missing_legs_suffix( animstatebase + "_in" ), anim_sub_index );
				self zombieanimnotetrackthink( "board_tear_bus_anim", chunk, opening );
				while ( opening.zbarrier.chunk_health[ chunk ] >= 0 )
				{
					tag_origin = self.attachent gettagorigin( self.attachtag );
					tag_angles = self.attachent gettagangles( self.attachtag );
					self animscripted( tag_origin, tag_angles, maps/mp/animscripts/zm_utility::append_missing_legs_suffix( animstatebase + "_loop" ), anim_sub_index );
					self zombieanimnotetrackthink( "board_tear_bus_anim", chunk, opening );
					opening.zbarrier.chunk_health[ chunk ]--;

				}
				tag_origin = self.attachent gettagorigin( self.attachtag );
				tag_angles = self.attachent gettagangles( self.attachtag );
				self animscripted( tag_origin, tag_angles, maps/mp/animscripts/zm_utility::append_missing_legs_suffix( animstatebase + "_out" ), anim_sub_index );
				self zombieanimnotetrackthink( "board_tear_bus_anim", chunk, opening );
			}
			tried_attack = self zombietryattackthroughwindow( 1, self.left_or_right );
			if ( !tried_attack && !waited )
			{
				wait 0,1;
			}
		}
		self.onbuswindow = undefined;
		if ( !_isopeningdoor( opening.bindtag ) )
		{
			self zombiekeepattackingthroughwindow( self.left_or_right );
			side = _getsideofbusopeningison( opening.bindtag );
			if ( side == "front" )
			{
				from_front = 1;
			}
			anim_state = "window_climbin";
			if ( from_front )
			{
				anim_state += "_front";
				anim_state += self.left_or_right;
			}
			else if ( from_rear )
			{
				anim_state += "_back";
			}
			else
			{
				anim_state += self.left_or_right;
			}
			min_chance_at_round = 5;
			max_chance_at_round = 12;
			if ( level.round_number >= min_chance_at_round )
			{
				round = min( level.round_number, max_chance_at_round );
				range = max_chance_at_round - min_chance_at_round;
				chance = ( 100 / range ) * ( round - min_chance_at_round );
				if ( randomintrange( 0, 100 ) <= chance )
				{
					anim_state += "_fast";
				}
			}
			anim_index = self getanimsubstatefromasd( "zm_zbarrier_climbin_bus", anim_state );
			enter_anim = self getanimfromasd( "zm_zbarrier_climbin_bus", anim_index );
			tag_origin = self.attachent gettagorigin( self.attachtag );
			tag_angles = self.attachent gettagangles( self.attachtag );
			self.climbing_into_bus = 1;
			self.entering_bus = 1;
			self animmode( "noclip" );
			self animscripted( tag_origin, tag_angles, "zm_zbarrier_climbin_bus", anim_index );
			self zombieanimnotetrackthink( "climbin_bus_anim" );
			self animmode( "gravity" );
			self maps/mp/animscripts/zm_run::needsupdate();
			if ( !self.isdog )
			{
				self maps/mp/animscripts/zm_run::moverun();
			}
		}
		opening.zombie = undefined;
		self.opening = undefined;
		self unlink();
		self setgoalpos( self.origin );
	}
	self reset_attack_spot();
	self.climbing_into_bus = 0;
	if ( isDefined( removeafterdone ) && removeafterdone )
	{
		self delete();
		return;
	}
	self.inert_delay = undefined;
}

zombieattachleftorright( bus )
{
	tag = self.opening.bindtag;
	if ( isDefined( bus.doorsclosed ) && !bus.doorsclosed )
	{
		if ( tag != "window_right_1_jnt" || tag == "window_right_2_jnt" && tag == "window_right_3_jnt" )
		{
			return "_r";
		}
		else
		{
			if ( tag == "window_right_4_jnt" )
			{
				return "_l";
			}
		}
	}
	side = getopeningside( tag );
	while ( isDefined( side ) )
	{
		if ( side == "right" )
		{
			openings = bus.openingright;
		}
		else
		{
			if ( side == "left" )
			{
				openings = bus.openingleft;
			}
		}
		_a1332 = openings;
		_k1332 = getFirstArrayKey( _a1332 );
		while ( isDefined( _k1332 ) )
		{
			opening = _a1332[ _k1332 ];
			if ( opening == self.opening )
			{
			}
			else
			{
				if ( isDefined( opening.zombie ) )
				{
					return opening.zombie.left_or_right;
				}
			}
			_k1332 = getNextArrayKey( _a1332, _k1332 );
		}
	}
	left_or_right = "_l";
	if ( randomint( 10 ) > 5 )
	{
		left_or_right = "_r";
	}
	return left_or_right;
}

businitrightandleft()
{
	self.openingright = [];
	self.openingleft = [];
	_a1367 = self.openings;
	_k1367 = getFirstArrayKey( _a1367 );
	while ( isDefined( _k1367 ) )
	{
		opening = _a1367[ _k1367 ];
		side = getopeningside( opening.bindtag );
		if ( isDefined( side ) )
		{
			if ( side == "right" )
			{
				self.openingright[ self.openingright.size ] = opening;
				break;
			}
			else
			{
				if ( side == "left" )
				{
					self.openingleft[ self.openingleft.size ] = opening;
				}
			}
		}
		_k1367 = getNextArrayKey( _a1367, _k1367 );
	}
}

getopeningside( tag )
{
	i = 1;
	while ( i <= 4 )
	{
		window_tag = "window_right_" + i + "_jnt";
		if ( tag == window_tag )
		{
			return "right";
		}
		i++;
	}
	i = 1;
	while ( i <= 5 )
	{
		window_tag = "window_left_" + i + "_jnt";
		if ( tag == window_tag )
		{
			return "left";
		}
		i++;
	}
	return undefined;
}

zombiegetwindowanimrate()
{
	animrate = 1;
	animrateroundscalar = 0;
	players = get_players();
	if ( players.size > 1 )
	{
		target_rate = 1,5;
		target_round = 25;
		target_num_players = 4;
		rate = ( target_rate - 1 ) / target_round / target_num_players;
		animrateroundscalar = rate * players.size;
		animrate = 1 + ( animrateroundscalar * level.round_number );
		if ( animrate > target_rate )
		{
			animrate = target_rate;
		}
	}
	return animrate;
}

zombiedetachfrombus( postfix )
{
	if ( !isDefined( self.opening ) )
	{
		return;
	}
	if ( isDefined( self.opening.zombie ) && self.opening.zombie == self )
	{
		self.opening.zombie = undefined;
	}
	is_right = 0;
	if ( postfix == "_r" )
	{
		is_right = 1;
	}
	bindtag = self.opening.bindtag;
	side = _getsideofbusopeningison( bindtag );
	tag_origin = level.the_bus gettagorigin( bindtag );
	tag_angles = level.the_bus gettagangles( bindtag );
	self.opening = undefined;
	self.isonbusroof = 0;
	self.onbuswindow = undefined;
	self.ai_state = "zombieDetachFromBus";
	self.entering_bus = 0;
	self.isonbus = 0;
	asd_name = "zm_window_dismount";
	if ( isDefined( side ) && side == "front" )
	{
		asd_name = "zm_front_window_dismount";
	}
	animstate = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( asd_name );
	self animscripted( tag_origin, tag_angles, animstate, is_right );
	self.dismount_start = 1;
	self thread dismount_timer();
	maps/mp/animscripts/zm_shared::donotetracks( "window_dismount_anim" );
	self unlink();
	self reset_attack_spot();
	self.dismount_start = 0;
	self.forcemovementscriptstate = 0;
	self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
	self.dont_throw_gib = undefined;
	self notify( "detach_on_window" );
}

dismount_timer()
{
	self endon( "death" );
	wait 1,5;
	self.dismount_start = 0;
}

zombiegetcymbalmonkey()
{
	if ( isDefined( self.monkey_time ) && getTime() < self.monkey_time )
	{
		return self.monkey;
	}
	poi = undefined;
	if ( level.cymbal_monkeys.size > 0 )
	{
		poi = self get_zombie_point_of_interest( self.origin, level.cymbal_monkeys );
	}
	if ( isDefined( poi ) )
	{
		self.monkey = poi[ 1 ];
		self.monkey_time = getTime() + 250;
		return poi[ 1 ];
	}
	return undefined;
}

zombieshoulddetachfromwindow()
{
	monkey = self zombiegetcymbalmonkey();
	if ( isDefined( monkey ) )
	{
		if ( monkey maps/mp/zm_transit_bus::entity_is_on_bus( 1 ) )
		{
			return 0;
		}
		else
		{
			return 1;
		}
	}
	enemy = self.favoriteenemy;
	if ( isDefined( enemy ) && !self.favoriteenemy.isonbus )
	{
		return 1;
	}
	return 0;
}

zombiecanjumponroof( opening )
{
	if ( level.the_bus.numplayersonroof == 0 )
	{
		if ( all_chunks_destroyed( opening ) )
		{
			return 0;
		}
		if ( isDefined( level.bus_zombie_on_roof ) )
		{
			return 0;
		}
		if ( level.bus_roof_next_time > getTime() )
		{
			return 0;
		}
	}
	percentchance = 0;
	if ( level.round_number <= 5 )
	{
		percentchance = 5;
	}
	else if ( level.round_number <= 10 )
	{
		percentchance = 20;
	}
	else if ( level.round_number <= 20 )
	{
		percentchance = 30;
	}
	else if ( level.round_number <= 25 )
	{
		percentchance = 40;
	}
	else
	{
		percentchance = 50;
	}
	percentofplayersonroof = 1;
	if ( level.the_bus.numplayersnear > 0 )
	{
		percentofplayersonroof = level.the_bus.numplayersonroof / level.the_bus.numplayersnear;
	}
	percentofplayersonroof *= 100;
	if ( percentchance < percentofplayersonroof )
	{
		percentchance = percentofplayersonroof;
	}
	if ( randomint( 100 ) < percentchance )
	{
		return 1;
	}
	return 0;
}

zombiesetnexttimetojumponroof()
{
	level.bus_roof_next_time = getTime() + level.bus_roof_min_interval_time + randomint( level.bus_roof_max_interval_time - level.bus_roof_min_interval_time );
}

zombiejumponroof( thebus, opening, removeafterdone, postfix )
{
	level.bus_zombie_on_roof = self;
	self.climbing_onto_bus = 1;
	self.entering_bus = 1;
	self animscripted( self.opening.zbarrier.origin, self.opening.zbarrier.angles, "zm_zbarrier_window_climbup", "window_climbup" + postfix );
	self zombieanimnotetrackthink( "bus_window_climbup" );
	play_sound_at_pos( "grab_metal_bar", self.origin );
	opening.zombie = undefined;
	self.opening = undefined;
	self unlink();
	self setgoalpos( self.origin );
	self.climbing_onto_bus = 0;
	if ( level.the_bus.numplayersonroof > 0 )
	{
		level.bus_zombie_on_roof = undefined;
	}
}

bussetupladder()
{
	trigger = getent( "bus_ladder_trigger", "targetname" );
	if ( !isDefined( trigger ) )
	{
		return;
	}
	trigger enablelinkto();
	trigger linkto( level.the_bus );
	trigger setmovingplatformenabled( 1 );
	trigger setinvisibletoall();
	mantlebrush = getentarray( "ladder_mantle", "targetname" );
	while ( isDefined( mantlebrush ) && mantlebrush.size > 0 )
	{
		i = 0;
		while ( i < mantlebrush.size )
		{
			self thread busdeferredinitladdermantle( mantlebrush[ i ] );
			i++;
		}
	}
	thread busladderthink();
}

busdeferredinitladdermantle( mantle )
{
	origin = self worldtolocalcoords( mantle.origin );
	mantle linkto( self, "", origin, ( 0, -1, 0 ) );
	mantle setmovingplatformenabled( 1 );
	wait_for_buildable( "busladder" );
	mantle delete();
}

busladderthink()
{
	origin = level.the_bus gettagorigin( "tag_ladder_attach" );
	origin += ( 10, 3, -30 );
	angles = level.the_bus gettagangles( "tag_ladder_attach" );
	angles += vectorScale( ( 0, -1, 0 ), 90 );
	level.the_bus.ladder = spawn( "script_model", origin );
	level.the_bus.ladder.angles = angles;
	level.the_bus.ladder setmodel( "com_stepladder_large_closed" );
	level.the_bus.ladder notsolid();
	level.the_bus.ladder linkto( level.the_bus, "tag_ladder_attach" );
	level.the_bus.ladder setmovingplatformenabled( 1 );
	level.the_bus.ladder hide();
	player = wait_for_buildable( "busladder" );
	flag_set( "ladder_attached" );
	level.the_bus.ladder show();
	player maps/mp/zombies/_zm_buildables::track_placed_buildables( "busladder" );
}

bussetuproofopening()
{
	level.bus_roof_open = 0;
	level.bus_zombie_on_roof = undefined;
	level.bus_roof_next_time = 0;
	level.bus_roof_min_interval_time = 10000;
	level.bus_roof_max_interval_time = 20000;
	trigger = getent( "bus_hatch_bottom_trigger", "targetname" );
	if ( !isDefined( trigger ) )
	{
		return;
	}
	trigger enablelinkto();
	trigger linkto( level.the_bus );
	trigger setmovingplatformenabled( 1 );
	self thread bus_hatch_wait();
	self thread bus_hatch_tearin_wait();
	clipbrush = getentarray( "hatch_clip", "targetname" );
	while ( isDefined( clipbrush ) && clipbrush.size > 0 )
	{
		i = 0;
		while ( i < clipbrush.size )
		{
			self thread businithatchclip( clipbrush[ i ] );
			i++;
		}
	}
	mantlebrush = getentarray( "hatch_mantle", "targetname" );
	while ( isDefined( mantlebrush ) && mantlebrush.size > 0 )
	{
		i = 0;
		while ( i < mantlebrush.size )
		{
			self thread busdeferredinithatchmantle( mantlebrush[ i ] );
			i++;
		}
	}
	hatch_location = spawn( "script_origin", level.the_bus localtoworldcoords( ( 227, -1,7, 48 ) ) );
	hatch_location enablelinkto();
	hatch_location linkto( level.the_bus );
	hatch_location setmovingplatformenabled( 1 );
	level.the_bus.hatch_location = hatch_location;
/#
	adddebugcommand( "devgui_cmd "Zombies:1/Bus:14/Hatch:4/Allow Traverse:1" "zombie_devgui hatch_available"\n" );
	self thread wait_open_sesame();
#/
}

wait_open_sesame()
{
	level waittill( "open_sesame" );
	self notify( "hatch_mantle_allowed" );
	if ( isDefined( level.bus_tearin_roof ) )
	{
		level.bus_tearin_roof hide();
	}
	level.the_bus showpart( "tag_hatch_attach_ladder" );
	level.the_bus hidepart( "tag_hatch_pristine" );
	level.the_bus hidepart( "tag_hatch_damaged" );
	level.bus_roof_open = 1;
	level.bus_roof_tearing = 0;
}

bus_hatch_wait()
{
	level.the_bus hidepart( "tag_hatch_attach_ladder" );
	player = wait_for_buildable( "bushatch" );
	flag_set( "hatch_attached" );
	level.the_bus showpart( "tag_hatch_attach_ladder" );
	level.the_bus hidepart( "tag_hatch_pristine" );
	level.the_bus hidepart( "tag_hatch_damaged" );
	level.bus_roof_open = 1;
	level.bus_roof_tearing = 0;
	self notify( "hatch_mantle_allowed" );
	player maps/mp/zombies/_zm_buildables::track_placed_buildables( "bushatch" );
}

bus_hatch_tearin_wait()
{
	self endon( "hatch_mantle_allowed" );
	level.the_bus hidepart( "tag_hatch_damaged" );
	self waittill( "hatch_ripped_open" );
	level.the_bus hidepart( "tag_hatch_pristine" );
	level.the_bus showpart( "tag_hatch_damaged" );
	self notify( "hatch_drop_allowed" );
	playfxontag( level._effect[ "bus_hatch_bust" ], self, "tag_headlights" );
}

businithatchclip( clip )
{
	origin = self worldtolocalcoords( clip.origin );
	clip linkto( self, "", origin, ( 0, -1, 0 ) );
	clip setmovingplatformenabled( 1 );
	self waittill_any( "hatch_mantle_allowed", "hatch_drop_allowed" );
	clip delete();
}

busdeferredinithatchmantle( mantle )
{
	origin = self worldtolocalcoords( mantle.origin );
	mantle.origin = vectorScale( ( 0, -1, 0 ), 100 );
	self waittill( "hatch_mantle_allowed" );
	mantle linkto( self, "", origin, ( 0, -1, 0 ) );
	mantle setmovingplatformenabled( 1 );
}

zombieonbusenemy()
{
	new_enemy = undefined;
	if ( isDefined( level.the_bus.bus_riders_alive ) && level.the_bus.bus_riders_alive.size > 0 )
	{
		new_enemy = getclosest( self.origin, level.the_bus.bus_riders_alive );
	}
	if ( isDefined( new_enemy ) && isDefined( self.favoriteenemy ) && isDefined( new_enemy ) && self.favoriteenemy != new_enemy )
	{
		if ( isDefined( self.favoriteenemy.isonbus ) && !self.favoriteenemy.isonbus )
		{
			self.favoriteenemy = new_enemy;
			return;
		}
		else
		{
			if ( self.isonbusroof == new_enemy.isonbusroof )
			{
				self.favoriteenemy = new_enemy;
			}
		}
	}
}

zombiemoveonbus()
{
	self endon( "death" );
	self endon( "removed" );
	level endon( "intermission" );
	self notify( "endOnBus" );
	self endon( "endOnBus" );
	self notify( "stop_find_flesh" );
	self notify( "zombie_acquire_enemy" );
	wait 0,05;
	self orientmode( "face enemy" );
	self.goalradius = 32;
	self.forcemovementscriptstate = 1;
	self.ai_state = "zombieMoveOnBus";
	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieMoveOnBus " + getTime() );
	bus_nodes = getnodearray( "the_bus", "target" );
	while ( 1 )
	{
		self zombieonbusenemy();
		if ( !isDefined( self.favoriteenemy ) )
		{
			break;
		}
		else if ( isDefined( self.isonbus ) )
		{
			self_on_bus = self.isonbus;
		}
		if ( isDefined( self.isonbusroof ) )
		{
			self_is_on_bus_roof = self.isonbusroof;
		}
		if ( !self_on_bus )
		{
			break;
		}
		else
		{
			if ( isDefined( self.is_inert ) && self.is_inert )
			{
				self.ignoreall = 1;
				while ( isDefined( self.is_inert ) && self.is_inert )
				{
					wait 0,1;
				}
				self.ignoreall = 0;
			}
			poi_override = 0;
			if ( self.forcemovementscriptstate )
			{
				monkey = self zombiegetcymbalmonkey();
				if ( isDefined( monkey ) )
				{
					poi_override = 1;
					self.ignoreall = 1;
					self animmode( "normal" );
					self orientmode( "face motion" );
					if ( !level.the_bus maps/mp/zm_transit_bus::busispointinside( monkey.origin ) )
					{
						self zombiewalktoexit();
					}
					else
					{
						self setgoalpos( monkey.origin );
					}
					break;
				}
				else
				{
					self.ignoreall = 0;
					self animmode( "gravity" );
					self orientmode( "face enemy" );
					while ( isDefined( level.the_bus.doorsclosed ) && !level.the_bus.doorsclosed )
					{
						doorstrigger = getentarray( "bus_door_trigger", "targetname" );
						_a1984 = doorstrigger;
						_k1984 = getFirstArrayKey( _a1984 );
						while ( isDefined( _k1984 ) )
						{
							trigger = _a1984[ _k1984 ];
							if ( self istouching( trigger ) )
							{
								self orientmode( "face motion" );
								break;
							}
							else
							{
								_k1984 = getNextArrayKey( _a1984, _k1984 );
							}
						}
					}
					dist_sq = distancesquared( self.favoriteenemy.origin, bus_nodes[ 0 ].origin );
					goal_node = bus_nodes[ 0 ];
					i = 1;
					while ( i < bus_nodes.size )
					{
						bus_sq = distancesquared( self.favoriteenemy.origin, bus_nodes[ i ].origin );
						if ( bus_sq < dist_sq )
						{
							dist_sq = bus_sq;
							goal_node = bus_nodes[ i ];
						}
						i++;
					}
					if ( self_is_on_bus_roof )
					{
						self.goalradius = 16;
					}
					else
					{
						self.goalradius = 32;
					}
					self setgoalnode( goal_node );
				}
			}
			enemy = self.favoriteenemy;
			if ( isDefined( enemy ) )
			{
				enemy_on_bus = enemy.isonbus;
			}
			if ( enemy_on_bus && isDefined( enemy.isonbusroof ) )
			{
				enemy_on_roof = enemy.isonbusroof;
			}
			if ( !enemy_on_bus && !self_is_on_bus_roof )
			{
				monkey = self zombiegetcymbalmonkey();
				if ( !isDefined( monkey ) || !monkey maps/mp/zm_transit_bus::entity_is_on_bus( 1 ) )
				{
					self thread zombieexitbus();
					return;
				}
			}
			else
			{
				if ( enemy_on_bus && self_is_on_bus_roof != enemy_on_roof )
				{
					self thread zombieheighttraverse();
					return;
					break;
				}
				else
				{
					if ( self_is_on_bus_roof && !enemy_on_bus )
					{
						self thread zombiejumpoffroof();
						return;
						break;
					}
					else
					{
						if ( isDefined( poi_override ) && !poi_override )
						{
							disttoenemy = distance2d( self.origin, self.favoriteenemy.origin );
							shouldbeinforcemovement = disttoenemy > 32;
							if ( !shouldbeinforcemovement && self.forcemovementscriptstate )
							{
								self.forcemovementscriptstate = 0;
								self animmode( "normal" );
								self orientmode( "face enemy" );
							}
							if ( shouldbeinforcemovement && !self.forcemovementscriptstate )
							{
								self.forcemovementscriptstate = 1;
								self animmode( "gravity" );
								self orientmode( "face enemy" );
							}
						}
					}
				}
			}
			wait 0,1;
		}
	}
	self animmode( "normal" );
	self orientmode( "face enemy" );
	self.forcemovementscriptstate = 0;
	self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}

zombiewalktoexit()
{
	self endon( "death" );
	bus = level.the_bus;
	self.walk_to_exit = 1;
	check_pos = self.origin;
	enemy = self.favoriteenemy;
	if ( isDefined( enemy ) )
	{
		check_pos = enemy.origin;
	}
	if ( !level.the_bus.doorsclosed )
	{
		front_dist = distance2dsquared( check_pos, level.the_bus.front_door.origin );
		back_dist = distance2dsquared( check_pos, level.the_bus.back_door.origin );
		link_one = undefined;
		link_two = undefined;
		door_node = undefined;
		door_dist = undefined;
		if ( front_dist < back_dist )
		{
			door_dist = distance2dsquared( self.origin, level.the_bus.front_door.origin );
			if ( door_dist < 256 )
			{
				door_node = level.the_bus.front_door;
			}
		}
		else
		{
			door_dist = distance2dsquared( self.origin, level.the_bus.back_door.origin );
			if ( door_dist < 256 )
			{
				door_node = level.the_bus.back_door;
			}
		}
		if ( isDefined( door_node ) )
		{
			if ( isDefined( door_node.links ) )
			{
				if ( isDefined( door_node.links[ 0 ] ) )
				{
					link_one = door_node.links[ 0 ];
				}
				if ( isDefined( door_node.links[ 1 ] ) )
				{
					link_two = door_node.links[ 1 ];
				}
			}
			link_goal = undefined;
			if ( isDefined( link_one ) )
			{
				link_goal = link_one;
			}
			if ( isDefined( link_one ) && isDefined( link_two ) )
			{
				link_one_dist = distance2dsquared( check_pos, link_one.origin );
				link_two_dist = distance2dsquared( check_pos, link_two.origin );
				link_goal = link_one;
				if ( link_two_dist < link_one_dist )
				{
					link_goal = link_two;
				}
			}
			if ( isDefined( link_goal ) )
			{
				self setgoalnode( link_goal );
				return;
			}
		}
		door_goal = level.the_bus.front_door;
		if ( back_dist < front_dist )
		{
			door_goal = level.the_bus.back_door;
		}
		self setgoalnode( door_goal );
	}
	else
	{
		dist_f = distancesquared( check_pos, bus.front_door_inside.origin );
		dist_bl = distancesquared( check_pos, bus.exit_back_l.origin );
		dist_br = distancesquared( check_pos, bus.exit_back_r.origin );
		goal_node = bus.front_door_inside;
		if ( dist_bl < dist_br )
		{
			if ( dist_bl < dist_f )
			{
				goal_node = bus.exit_back_l;
			}
		}
		else
		{
			if ( dist_br < dist_f )
			{
				goal_node = bus.exit_back_r;
			}
		}
		self setgoalnode( goal_node );
	}
}

zombiewindowtoroof()
{
	self endon( "death" );
	self animmode( "normal" );
	self orientmode( "face motion" );
	self.ai_state = "zombieWindowToRoof";
	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieWindowToRoof " + getTime() );
	while ( 1 )
	{
		self zombiewalktowindow();
		if ( isDefined( self.exiting_window ) && self.exiting_window )
		{
			break;
		}
		else
		{
			if ( isDefined( self.isonbus ) || !self.isonbus && isDefined( self.ai_state == "find_flesh" ) && self.ai_state == "find_flesh" )
			{
				return;
			}
			wait 0,1;
		}
	}
	while ( isDefined( self.exiting_window ) && self.exiting_window )
	{
		wait 0,1;
	}
}

zombiewalktowindow()
{
	self endon( "death" );
	bus = level.the_bus;
	self.walk_to_exit = 1;
	check_pos = self.origin;
	dist_f = distancesquared( check_pos, bus.front_door_inside.origin );
	dist_bl = distancesquared( check_pos, bus.exit_back_l.origin );
	goal_node = bus.front_door_inside;
	if ( dist_bl < dist_f )
	{
		goal_node = bus.exit_back_l;
	}
	self setgoalnode( goal_node );
}

zombieattackplayerclinging( player )
{
	self endon( "death" );
	level endon( "intermission" );
	self.goalradius = 15;
	enemy_clinging = 1;
	while ( enemy_clinging )
	{
		best_attack_pos = maps/mp/zm_transit_cling::_getbusattackposition( player );
		dist_from_pos2 = distance2dsquared( best_attack_pos, self.origin );
		enemy_origin = player _playergetorigin();
		direction = enemy_origin - self.origin;
		direction_angles = vectorToAngle( direction );
		direction_angles = ( direction_angles[ 0 ], direction_angles[ 1 ], 0 );
		if ( dist_from_pos2 > 400 )
		{
			self orientmode( "face point", best_attack_pos );
			self setgoalpos( best_attack_pos );
		}
		else
		{
			self zombiescriptedattack( player, direction_angles, ::zombiedamageplayercling );
		}
		enemy_clinging = player maps/mp/zm_transit_cling::playerisclingingtobus();
		wait 0,1;
	}
	self.goalradius = 32;
}

zombieattackplayeronturret( player )
{
	self endon( "death" );
	level endon( "intermission" );
	enemy_on_turret = 1;
	while ( enemy_on_turret )
	{
		enemy_origin = self.favoriteenemy _playergetorigin();
		dist_from_turret2 = distance2dsquared( enemy_origin, self.origin );
		direction = enemy_origin - self.origin;
		direction_angles = vectorToAngle( direction );
		direction_angles = ( direction_angles[ 0 ], direction_angles[ 1 ], 0 );
		if ( dist_from_turret2 > 1024 )
		{
			self setgoalpos( enemy_origin, direction_angles );
		}
		else
		{
			self zombiescriptedattack( player, direction_angles, ::zombiedamageplayerturret );
		}
		wait 0,1;
		if ( isDefined( self.favoriteenemy.onbusturret ) && isDefined( self.favoriteenemy.busturret ) )
		{
			enemy_on_turret = self.favoriteenemy.onbusturret;
		}
	}
}

zombiescriptedattack( player, direction_angles, damage_func )
{
	self orientmode( "face angle", direction_angles[ 1 ] );
	zombie_attack_anim = self zombiepickunmovingattackanim();
	self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "attack", self.animname );
	while ( 1 )
	{
		self waittill( "meleeanim", note );
		if ( note == "end" || note == "stop" )
		{
			return;
		}
		else if ( note == "fire" )
		{
			if ( isDefined( damage_func ) )
			{
				[[ damage_func ]]( player );
			}
		}
	}
}

zombiedamageplayerturret( player )
{
	if ( player.onbusturret )
	{
		player dodamage( self.meleedamage, self.origin, self );
	}
}

zombiedamageplayercling( player )
{
	if ( player maps/mp/zm_transit_cling::playerisclingingtobus() )
	{
		player dodamage( self.meleedamage, self.origin, self );
	}
}

_playergetorigin()
{
	if ( isDefined( self.onbusturret ) && isDefined( self.busturret ) && self.onbusturret )
	{
		turret = self.busturret;
		turret_exit = getent( turret.target, "targetname" );
		return turret_exit.origin;
	}
	return self.origin;
}

zombiepickunmovingattackanim()
{
	melee_anim = undefined;
	if ( self.has_legs )
	{
		rand_num = randomint( 4 );
		melee_anim = level._zombie_melee[ self.animname ][ rand_num ];
	}
	else if ( self.a.gib_ref == "no_legs" )
	{
		melee_anim = random( level._zombie_stumpy_melee[ self.animname ] );
	}
	else
	{
		melee_anim = level._zombie_melee_crawl[ self.animname ][ 0 ];
	}
	return melee_anim;
}

zombieexitbus()
{
	self endon( "death" );
	self endon( "stop_zombieExitBus" );
	level endon( "intermission" );
	self animmode( "normal" );
	self orientmode( "face motion" );
	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieExitBus " + getTime() );
	while ( 1 )
	{
		if ( isDefined( self.exiting_window ) && self.exiting_window )
		{
			break;
		}
		else
		{
			if ( isDefined( self.isonbus ) && !self.isonbus )
			{
				self.walk_to_exit = 0;
				return;
			}
			if ( isDefined( self.solo_revive_exit ) && !self.solo_revive_exit )
			{
				monkey = undefined;
				if ( isDefined( self.enemyoverride ) )
				{
					monkey = self.enemyoverride[ 1 ];
				}
				ignore_enemy = 0;
				if ( isDefined( monkey ) && !monkey maps/mp/zm_transit_bus::entity_is_on_bus( 1 ) )
				{
					ignore_enemy = 1;
				}
				if ( !ignore_enemy )
				{
					enemy = self.favoriteenemy;
					if ( isDefined( enemy ) )
					{
						if ( enemy.isonbus )
						{
							self.walk_to_exit = 0;
							self thread zombiemoveonbus();
							return;
						}
					}
				}
			}
			self zombiewalktoexit();
			wait 0,1;
		}
	}
	while ( isDefined( self.exiting_window ) && self.exiting_window )
	{
		wait 0,1;
	}
	self.dont_throw_gib = undefined;
	self orientmode( "face enemy" );
	self.forcemovementscriptstate = 0;
	self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}

zombiejumpoffroof()
{
	self endon( "death" );
	self endon( "removed" );
	level endon( "intermission" );
	self animmode( "gravity" );
	self orientmode( "face goal" );
	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieJumpOffRoof " + getTime() );
	while ( 1 )
	{
		enemy = self.favoriteenemy;
		if ( isDefined( enemy ) )
		{
			enemy_on_bus = enemy.isonbus;
		}
		enemiesonbus = level.the_bus.numaliveplayersridingbus > 0;
		if ( isDefined( self.isonbus ) )
		{
			selfisonbus = self.isonbus;
		}
		if ( enemy_on_bus )
		{
			self thread zombiemoveonbus();
			return;
		}
		if ( !selfisonbus )
		{
			return;
		}
		else closest_jump_tag = self zombiegetclosestroofjumptag();
		goal_pos = level.the_bus gettagorigin( closest_jump_tag );
		if ( distance2dsquared( self.origin, goal_pos ) <= 1024 )
		{
			self.attachent = level.the_bus;
			self.attachtag = closest_jump_tag;
			self linkto( self.attachent, self.attachtag, ( 0, -1, 0 ), ( 0, -1, 0 ) );
			wait 0,1;
			self zombieplayattachedanim( "jump_down_127" );
			self setgoalpos( self.origin );
			self unlink();
			return;
		}
		else
		{
			self setgoalpos( goal_pos );
			self orientmode( "face point", goal_pos );
			wait 0,1;
		}
	}
}

zombieheighttraverse()
{
	level endon( "intermission" );
	self endon( "death" );
	self endon( "removed" );
	self endon( "zombieHeightTraverseStop" );
	self animmode( "gravity" );
	self orientmode( "face goal" );
	self.zombie_ladder_stage = 1;
	self.goal_local_offset = level.the_bus.ladder_local_offset;
	self.goal_local_offset = ( self.goal_local_offset[ 0 ], self.goal_local_offset[ 1 ], level.the_bus.floor );
	self.goal_local_angles = vectorScale( ( 0, -1, 0 ), 90 );
	self maps/mp/zombies/_zm_spawner::zombie_history( "zombieHeightTraverse " + getTime() );
	if ( !isDefined( self.isonbusroof ) || !self.isonbusroof )
	{
		bus = level.the_bus;
		hatch_dist = distancesquared( self.origin, bus.hatch_location.origin );
		front_dist = distancesquared( self.origin, bus.front_door_inside.origin );
		back_dist = distancesquared( self.origin, bus.exit_back_l.origin );
		closer_to_hatch = 1;
		if ( front_dist < hatch_dist || back_dist < hatch_dist )
		{
			closer_to_hatch = 0;
		}
		if ( isDefined( level.bus_roof_open ) && level.bus_roof_open && isDefined( level.bus_roof_tearing ) || level.bus_roof_tearing && !closer_to_hatch )
		{
			self zombiewindowtoroof();
		}
		else
		{
			if ( self zombiepathtoladder() )
			{
				self zombieclimbtoroof();
			}
		}
	}
	else
	{
		if ( self zombiepathtoroofopening() )
		{
			self zombiejumpdownhatch();
		}
		else
		{
			enemy = self.favoriteenemy;
			if ( isDefined( enemy ) && isDefined( enemy.isonbus ) && !enemy.isonbus )
			{
				self thread zombiejumpoffroof();
				return;
			}
		}
	}
	if ( isDefined( self.isonbus ) && self.isonbus )
	{
		self thread zombiemoveonbus();
	}
}

zombiepathtoladder()
{
	self.goalradius = 2;
	while ( isDefined( self.enemy ) && self.enemy.isonbusroof )
	{
		if ( !self.isonbus )
		{
			self.goalradius = 32;
			return 0;
		}
		goal_dir = anglesToForward( level.the_bus.angles + self.goal_local_angles );
		goal_pos = level.the_bus.hatch_location.origin;
		if ( distancesquared( self.origin, goal_pos ) <= 1600 )
		{
			self.goalradius = 32;
			self.ladder_pos = goal_pos;
			return 1;
		}
		self setgoalpos( goal_pos );
		self orientmode( "face point", goal_pos );
		wait 0,1;
	}
	self.goalradius = 32;
	return 0;
}

zombiepathtoroofopening()
{
	self.goalradius = 2;
	goal_tag = self zombiegetclosestroofopeningjumptag();
	while ( 1 )
	{
		self zombieonbusenemy();
		enemy = self.favoriteenemy;
		if ( isDefined( enemy ) && isDefined( enemy.isonbusroof ) && enemy.isonbusroof )
		{
			break;
		}
		else
		{
			if ( isDefined( enemy ) && isDefined( enemy.isonbus ) && !enemy.isonbus )
			{
				break;
			}
			else
			{
				if ( !self.isonbus )
				{
					break;
				}
				else
				{
					goal_dir = level.the_bus gettagangles( goal_tag );
					goal_pos = level.the_bus gettagorigin( goal_tag );
					if ( distance2d( self.origin, goal_pos ) <= 32 )
					{
						self.goalradius = 32;
						return 1;
					}
					self setgoalpos( goal_pos );
					self orientmode( "face point", goal_pos );
					wait 0,1;
				}
			}
		}
	}
	self.goalradius = 32;
	return 0;
}

zombiejumpdownhatch()
{
	self endon( "death" );
	self thread zombiejumpdownhatchkilled();
	enemy = self.favoriteenemy;
	if ( isDefined( enemy ) && isDefined( enemy.isonbusroof ) && enemy.isonbusroof )
	{
		self unlink();
		return;
	}
	while ( isDefined( level.bus_roof_tearing ) && level.bus_roof_tearing )
	{
		wait 0,1;
	}
	roof_tag = self zombiegetclosestroofopeningjumptag();
	if ( !level.bus_roof_open )
	{
		self.inert_delay = ::zombieroofteardelay;
		level.bus_roof_open = 1;
		level.bus_roof_tearing = 1;
		self linkto( level.the_bus, roof_tag );
		tag_origin = level.the_bus gettagorigin( roof_tag );
		tag_angles = level.the_bus gettagangles( roof_tag );
		substate = 1;
		if ( roof_tag == "window_roof_2_jnt" )
		{
			substate = 2;
		}
		animstate = "zm_bus_attached";
		self animscripted( tag_origin, tag_angles, animstate, substate );
		maps/mp/animscripts/zm_shared::donotetracks( "bus_attached_anim" );
		self.inert_delay = undefined;
		level.bus_roof_tearing = 0;
		level.the_bus notify( "hatch_ripped_open" );
	}
	self.hatch_jump = 1;
	self.inert_delay = ::zombiehatchjumpdelay;
	hatch_tag = "tag_hatch_attach_ladder";
	self linkto( level.the_bus, hatch_tag );
	tag_origin = level.the_bus gettagorigin( hatch_tag );
	tag_angles = level.the_bus gettagangles( hatch_tag );
	substate = 0;
	if ( roof_tag == "window_roof_1_jnt" )
	{
		substate = 1;
	}
	animstate = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "zm_bus_hatch_jump_down" );
	self animscripted( tag_origin, tag_angles, animstate, substate );
	maps/mp/animscripts/zm_shared::donotetracks( "bus_hatch_jump_anim" );
	self unlink();
	self.hatch_jump = 0;
	self.inert_delay = undefined;
	self setgoalpos( self.origin );
	level.bus_zombie_on_roof = undefined;
}

zombiehatchjumpdelay()
{
/#
	iprintln( "hatch delay" );
#/
	while ( isDefined( self.hatch_jump ) && self.hatch_jump )
	{
		wait 0,1;
	}
}

zombieroofteardelay()
{
	self endon( "death" );
	self notify( "zombieHeightTraverseStop" );
	self unlink();
	level.bus_roof_open = 0;
	level.bus_roof_tearing = 0;
	self.inert_wakeup_override = ::zombierooftearwakeup;
}

zombierooftearwakeup()
{
	self endon( "death" );
	self.inert_wakeup_override = undefined;
	self thread zombieheighttraverse();
}

zombiejumpdownhatchkilled()
{
	while ( isDefined( level.bus_roof_tearing ) && level.bus_roof_tearing )
	{
		if ( !isDefined( self ) )
		{
			level.bus_roof_tearing = 0;
			return;
		}
		else
		{
			wait 0,1;
		}
	}
}

zombieclimbtoroof()
{
	self endon( "death" );
	hatch_tag = "tag_hatch_attach_ladder";
	self linkto( level.the_bus, hatch_tag );
	tag_origin = level.the_bus gettagorigin( hatch_tag );
	tag_angles = level.the_bus gettagangles( hatch_tag );
	hatch_vec = vectornormalize( anglesToForward( tag_angles ) );
	player = self.favoriteenemy;
	player_vec = vectornormalize( player.origin - tag_origin );
	substate = 0;
	dot = vectordot( hatch_vec, player_vec );
	if ( dot > 0 )
	{
		substate = 1;
	}
	animstate = maps/mp/animscripts/zm_utility::append_missing_legs_suffix( "zm_bus_hatch_jump_up" );
	self animscripted( tag_origin, tag_angles, animstate, substate );
	maps/mp/animscripts/zm_shared::donotetracks( "bus_hatch_jump_anim" );
	self unlink();
	self setgoalpos( self.origin );
}

zombiegetclosestroofjumptag()
{
	root = "tag_roof_jump_off";
	best = root + "1";
	best_pos = level.the_bus gettagorigin( best );
	best_pos_dist2 = distance2dsquared( self.origin, best_pos );
	i = 1;
	while ( i <= 4 )
	{
		next_pos = level.the_bus gettagorigin( root + i );
		next_pos_dist2 = distance2dsquared( self.origin, next_pos );
		if ( next_pos_dist2 < best_pos_dist2 )
		{
			best = root + i;
			best_pos = next_pos;
			best_pos_dist2 = next_pos_dist2;
		}
		i++;
	}
	return best;
}

zombiegetclosestroofopeningjumptag()
{
	pos1 = level.the_bus gettagorigin( "window_roof_1_jnt" );
	pos2 = level.the_bus gettagorigin( "window_roof_2_jnt" );
	closest = "window_roof_1_jnt";
	pos1_dist2 = distance2dsquared( self.origin, pos1 );
	pos2_dist2 = distance2dsquared( self.origin, pos2 );
	if ( pos2_dist2 < pos1_dist2 )
	{
		closest = "window_roof_2_jnt";
	}
	return closest;
}

zombiegetclosestdoortag()
{
	pos1 = level.the_bus gettagorigin( "door_rear_jnt" );
	pos2 = level.the_bus gettagorigin( "door_front_jnt" );
	closest = "door_rear_jnt";
	pos1_dist2 = distance2dsquared( self.origin, pos1 );
	pos2_dist2 = distance2dsquared( self.origin, pos2 );
	if ( pos2_dist2 < pos1_dist2 )
	{
		closest = "door_front_jnt";
	}
	return closest;
}

zombiekeepattackingthroughwindow( left_or_right )
{
	while ( self zombietryattackthroughwindow( 0, left_or_right ) )
	{
		tag_origin = self.attachent gettagorigin( self.attachtag );
		tag_angles = self.attachent gettagangles( self.attachtag );
		asd_name = "zm_zbarrier_window_idle";
		side = _getsideofbusopeningison( self.attachtag );
		if ( side == "front" )
		{
			asd_name = "zm_zbarrier_front_window_idle";
		}
		self animscripted( tag_origin, tag_angles, asd_name, "window_idle" + left_or_right );
		self zombieanimnotetrackthink( "bus_window_idle" );
	}
}

zombietryattackthroughwindow( is_random, postfix )
{
	attackplayers = self zombiegetplayerstoattack();
	if ( attackplayers.size == 0 )
	{
		return 0;
	}
	should_attack = 1;
	if ( is_random )
	{
		rand = randomint( 100 );
		should_attack = rand < 80;
	}
	if ( should_attack )
	{
		self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "attack", self.animname );
		tag_origin = self.attachent gettagorigin( self.attachtag );
		tag_angles = self.attachent gettagangles( self.attachtag );
		asd_name = "zm_zbarrier_window_attack";
		side = _getsideofbusopeningison( self.attachtag );
		if ( isDefined( side ) && side == "front" )
		{
			asd_name = "zm_zbarrier_front_window_attack";
		}
		self animscripted( tag_origin, tag_angles, asd_name, "window_attack" + postfix );
		self zombieanimnotetrackthink( "bus_window_attack" );
		return 1;
	}
	return 0;
}

zombiegetplayerstoattack()
{
	playerstoattack = [];
	players = get_players();
	attackrange = 72;
	attackrange *= attackrange;
	attackheight = 37;
	attackheight *= attackheight;
	i = 0;
	while ( i < players.size )
	{
		if ( isDefined( self.opening ) && isDefined( self.opening.rebuildtrigger ) )
		{
			if ( players[ i ] istouching( self.opening.rebuildtrigger ) )
			{
				playerstoattack[ playerstoattack.size ] = players[ i ];
			}
			i++;
			continue;
		}
		else
		{
			xydist = distance2dsquared( self.origin, players[ i ].origin );
			zdist = self.origin[ 2 ] - players[ i ].origin[ 2 ];
			zdist2 = zdist * zdist;
			if ( xydist <= attackrange && zdist2 <= attackheight )
			{
				playerstoattack[ playerstoattack.size ] = players[ i ];
			}
		}
		i++;
	}
	return playerstoattack;
}