BO2-Reimagined/scripts/zm/replaced/zm_highrise_elevators.gsc

#include maps\mp\zm_highrise_elevators;
#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\gametypes_zm\_hostmigration;
#include maps\mp\zm_highrise_utility;
#include maps\mp\zm_highrise_distance_tracking;
#include maps\mp\animscripts\zm_shared;
#include maps\mp\zombies\_zm_ai_basic;
#include maps\mp\zombies\_zm_ai_leaper;

init_elevator_perks()
{
    level.elevator_perks = [];
    level.elevator_perks_building = [];
    level.elevator_perks_building["green"] = [];
    level.elevator_perks_building["blue"] = [];

    level.elevator_perks_building["green"][0] = spawnstruct();
    level.elevator_perks_building["green"][0].model = "zombie_vending_revive";
    level.elevator_perks_building["green"][0].script_noteworthy = "specialty_quickrevive";
    level.elevator_perks_building["green"][0].turn_on_notify = "revive_on";
    level.elevator_perks_building["green"][1] = spawnstruct();
    level.elevator_perks_building["green"][1].model = "p6_zm_vending_chugabud";
    level.elevator_perks_building["green"][1].script_noteworthy = "specialty_finalstand";
    level.elevator_perks_building["green"][1].turn_on_notify = "chugabud_on";
    level.elevator_perks_building["green"][2] = spawnstruct();
    level.elevator_perks_building["green"][2].model = "zombie_vending_sleight";
    level.elevator_perks_building["green"][2].script_noteworthy = "specialty_fastreload";
    level.elevator_perks_building["green"][2].turn_on_notify = "sleight_on";
    level.elevator_perks_building["blue"][0] = spawnstruct();
    level.elevator_perks_building["blue"][0].model = "zombie_vending_three_gun";
    level.elevator_perks_building["blue"][0].script_noteworthy = "specialty_additionalprimaryweapon";
    level.elevator_perks_building["blue"][0].turn_on_notify = "specialty_additionalprimaryweapon_power_on";
    level.elevator_perks_building["blue"][1] = spawnstruct();
    level.elevator_perks_building["blue"][1].model = "zombie_vending_jugg";
    level.elevator_perks_building["blue"][1].script_noteworthy = "specialty_armorvest";
    level.elevator_perks_building["blue"][1].turn_on_notify = "juggernog_on";
    level.elevator_perks_building["blue"][2] = spawnstruct();
    level.elevator_perks_building["blue"][2].model = "zombie_vending_doubletap2";
    level.elevator_perks_building["blue"][2].script_noteworthy = "specialty_rof";
    level.elevator_perks_building["blue"][2].turn_on_notify = "doubletap_on";
    level.elevator_perks_building["blue"][3] = spawnstruct();
    level.elevator_perks_building["blue"][3].model = "p6_anim_zm_buildable_pap";
    level.elevator_perks_building["blue"][3].script_noteworthy = "specialty_weapupgrade";
    level.elevator_perks_building["blue"][3].turn_on_notify = "Pack_A_Punch_on";
    players_expected = getnumexpectedplayers();
    level.override_perk_targetname = "zm_perk_machine_override";
    level.elevator_perks_building["green"] = array_randomize( level.elevator_perks_building["green"] );
    level.elevator_perks_building["blue"] = array_randomize( level.elevator_perks_building["blue"] );
    level.elevator_perks = arraycombine( level.elevator_perks_building["green"], level.elevator_perks_building["blue"], 0, 0 );
    random_perk_structs = [];
    perk_structs = getstructarray( "zm_random_machine", "script_noteworthy" );

    for ( i = 0; i < perk_structs.size; i++ )
    {
        random_perk_structs[i] = getstruct( perk_structs[i].target, "targetname" );
        random_perk_structs[i].script_parameters = perk_structs[i].script_parameters;
        random_perk_structs[i].script_linkent = getent( "elevator_" + perk_structs[i].script_parameters + "_body", "targetname" );
    }

    green_structs = [];
    blue_structs = [];

    foreach ( perk_struct in random_perk_structs )
    {
        if ( isdefined( perk_struct.script_parameters ) )
        {
            if ( issubstr( perk_struct.script_parameters, "bldg1" ) )
            {
                green_structs[green_structs.size] = perk_struct;
                continue;
            }

            blue_structs[blue_structs.size] = perk_struct;
        }
    }

    green_structs = array_randomize( green_structs );
    blue_structs = array_randomize( blue_structs );
    level.random_perk_structs = green_structs;
    level.random_perk_structs = arraycombine( level.random_perk_structs, blue_structs, 0, 0 );

    for ( i = 0; i < level.elevator_perks.size; i++ )
    {
        if ( !isdefined( level.random_perk_structs[i] ) )
            continue;

        level.random_perk_structs[i].targetname = "zm_perk_machine_override";
        level.random_perk_structs[i].model = level.elevator_perks[i].model;
        level.random_perk_structs[i].script_noteworthy = level.elevator_perks[i].script_noteworthy;
        level.random_perk_structs[i].turn_on_notify = level.elevator_perks[i].turn_on_notify;

        if ( !isdefined( level.struct_class_names["targetname"]["zm_perk_machine_override"] ) )
            level.struct_class_names["targetname"]["zm_perk_machine_override"] = [];

        level.struct_class_names["targetname"]["zm_perk_machine_override"][level.struct_class_names["targetname"]["zm_perk_machine_override"].size] = level.random_perk_structs[i];
    }
}

elevator_think( elevator )
{
    current_floor = elevator.body.current_location;
    delaybeforeleaving = 5;
    skipinitialwait = 0;
    speed = 100;
    minwait = 5;
    maxwait = 20;
    flag_wait( "perks_ready" );

    if ( isdefined( elevator.body.force_starting_floor ) )
    {
        elevator.body.current_level = "" + elevator.body.force_starting_floor;
        elevator.body.origin = elevator.floors[elevator.body.current_level].origin;

        if ( isdefined( elevator.body.force_starting_origin_offset ) )
            elevator.body.origin += ( 0, 0, elevator.body.force_starting_origin_offset );
    }

    elevator.body.can_move = 1;
    elevator elevator_set_moving( 0 );
    elevator elevator_enable_paths( elevator.body.current_level );

    flag_wait( "power_on" );

    elevator.body perkelevatordoor( 1 );
    next = undefined;

    while ( true )
    {
        start_location = 0;

        if ( isdefined( elevator.body.force_starting_floor ) )
            skipinitialwait = 1;

        elevator.body.departing = 1;

        if ( !is_true( elevator.body.lock_doors ) )
            elevator.body setanim( level.perk_elevators_anims[elevator.body.perk_type][1] );

        predict_floor( elevator, next, speed );

        if ( !is_true( skipinitialwait ) )
        {
            elevator_initial_wait( elevator, minwait, maxwait, delaybeforeleaving );

            if ( !is_true( elevator.body.lock_doors ) )
                elevator.body setanim( level.perk_elevators_anims[elevator.body.perk_type][1] );
        }

        if ( isdefined( elevator.body.force_starting_floor ) )
            skipinitialwait = 1;

        next = elevator_next_floor( elevator, next, 0 );

        if ( isdefined( elevator.floors["" + ( next + 1 )] ) )
            elevator.body.next_level = "" + ( next + 1 );
        else
        {
            start_location = 1;
            elevator.body.next_level = "0";
        }

        floor_stop = elevator.floors[elevator.body.next_level];
        floor_goal = undefined;
        cur_level_start_pos = elevator.floors[elevator.body.next_level].starting_position;
        start_level_start_pos = elevator.floors[elevator.body.starting_floor].starting_position;

        if ( elevator.body.next_level == elevator.body.starting_floor || isdefined( cur_level_start_pos ) && isdefined( start_level_start_pos ) && cur_level_start_pos == start_level_start_pos )
            floor_goal = cur_level_start_pos;
        else
            floor_goal = floor_stop.origin;

        dist = distance( elevator.body.origin, floor_goal );
        time = dist / speed;

        if ( dist > 0 )
        {
            if ( elevator.body.origin[2] > floor_goal[2] )
            {
                elevator.dir = "_d";
            }
            else
            {
                elevator.dir = "_u";
            }

            clientnotify( elevator.name + elevator.dir );
        }

        if ( is_true( start_location ) )
        {
            elevator.body thread squashed_death_alarm();

            if ( !skipinitialwait )
            {
                elevator.body.start_location_wait = 1;

                elevator.body notify( "startwait" );
                event = elevator.body waittill_any_timeout( 3, "forcego" );

                elevator.body.start_location_wait = 0;

                if ( event == "forcego" )
                {
                    next = elevator_next_floor( elevator, next, 0 );

                    if ( isdefined( elevator.floors["" + ( next + 1 )] ) )
                        elevator.body.next_level = "" + ( next + 1 );
                    else
                    {
                        start_location = 1;
                        elevator.body.next_level = "0";
                    }

                    floor_stop = elevator.floors[elevator.body.next_level];
                    floor_goal = undefined;
                    cur_level_start_pos = elevator.floors[elevator.body.next_level].starting_position;
                    start_level_start_pos = elevator.floors[elevator.body.starting_floor].starting_position;

                    if ( elevator.body.next_level == elevator.body.starting_floor || isdefined( cur_level_start_pos ) && isdefined( start_level_start_pos ) && cur_level_start_pos == start_level_start_pos )
                        floor_goal = cur_level_start_pos;
                    else
                        floor_goal = floor_stop.origin;

                    dist = distance( elevator.body.origin, floor_goal );
                    time = dist / speed;

                    if ( dist > 0 )
                    {
                        if ( elevator.body.origin[2] > floor_goal[2] )
                        {
                            elevator.dir = "_d";
                        }
                        else
                        {
                            elevator.dir = "_u";
                        }

                        clientnotify( elevator.name + elevator.dir );
                    }
                }
            }
        }

        skipinitialwait = 0;
        elevator.body.current_level = elevator.body.next_level;
        elevator notify( "floor_changed" );
        elevator elevator_disable_paths( elevator.body.current_level );
        elevator.body.departing = 0;
        elevator elevator_set_moving( 1 );

        if ( dist > 0 )
        {
            elevator.body moveto( floor_goal, time, time * 0.25, time * 0.25 );

            if ( isdefined( elevator.body.trig ) )
                elevator.body thread elev_clean_up_corpses();

            elevator.body thread elevator_move_sound();
            elevator.body waittill_any( "movedone", "forcego" );
        }

        elevator elevator_set_moving( 0 );
        elevator elevator_enable_paths( elevator.body.current_level );
    }
}

predict_floor( elevator, next, speed )
{
    next = elevator_next_floor( elevator, next, 1 );

    if ( isdefined( elevator.floors["" + ( next + 1 )] ) )
        elevator.body.next_level = "" + ( next + 1 );
    else
    {
        start_location = 1;
        elevator.body.next_level = "0";
    }

    floor_stop = elevator.floors[elevator.body.next_level];
    floor_goal = undefined;
    cur_level_start_pos = elevator.floors[elevator.body.next_level].starting_position;
    start_level_start_pos = elevator.floors[elevator.body.starting_floor].starting_position;

    if ( elevator.body.next_level == elevator.body.starting_floor || isdefined( cur_level_start_pos ) && isdefined( start_level_start_pos ) && cur_level_start_pos == start_level_start_pos )
        floor_goal = cur_level_start_pos;
    else
        floor_goal = floor_stop.origin;

    dist = distance( elevator.body.origin, floor_goal );
    time = dist / speed;

    if ( dist > 0 )
    {
        if ( elevator.body.origin[2] > floor_goal[2] )
        {
            elevator.dir = "_d";
        }
        else
        {
            elevator.dir = "_u";
        }

        clientnotify( elevator.name + elevator.dir );
    }
}

elevator_initial_wait( elevator, minwait, maxwait, delaybeforeleaving )
{
    elevator.body endon( "forcego" );
    elevator.body waittill_any_or_timeout( randomintrange( minwait, maxwait ), "depart_early" );

    if ( !is_true( elevator.body.lock_doors ) && !is_true( elevator.body.elevator_stop ) )
        elevator.body setanim( level.perk_elevators_anims[elevator.body.perk_type][0] );

    if ( !is_true( elevator.body.departing_early ) )
        wait( delaybeforeleaving );

    if ( elevator.body.perk_type == "specialty_weapupgrade" )
    {
        while ( flag( "pack_machine_in_use" ) )
            wait 0.5;

        wait( randomintrange( 1, 3 ) );
    }

    while ( isdefined( level.elevators_stop ) && level.elevators_stop || isdefined( elevator.body.elevator_stop ) && elevator.body.elevator_stop )
        wait 0.05;
}

elevator_move_sound()
{
    self playsound( "zmb_elevator_ding" );

    wait 0.4;

    if ( !is_true( self.is_moving ) )
    {
        return;
    }

    self playsound( "zmb_elevator_ding" );
    self playsound( "zmb_elevator_run_start" );
    self playloopsound( "zmb_elevator_run", 0.5 );

    self waittill( "movedone" );

    self stoploopsound( 0.5 );
    self playsound( "zmb_elevator_run_stop" );
    self playsound( "zmb_elevator_ding" );
}

elevator_roof_watcher()
{
    level endon( "end_game" );

    while ( true )
    {
        self.trig waittill( "trigger", who );

        if ( isdefined( who ) && isplayer( who ) )
        {
            while ( isdefined( who ) && who istouching( self.trig ) )
            {
                if ( self.is_moving )
                    self waittill_any( "movedone", "forcego" );

                if ( self.current_level == 0 )
                {
                    break; // don't make climber at top level
                }

                zombies = getaiarray( level.zombie_team );

                if ( isdefined( zombies ) && zombies.size > 0 )
                {
                    foreach ( zombie in zombies )
                    {
                        climber = zombie zombie_for_elevator_unseen();

                        if ( isdefined( climber ) )
                            continue;
                    }

                    if ( isdefined( climber ) )
                    {
                        zombie zombie_climb_elevator( self );
                        wait( randomint( 30 ) );
                    }
                }

                wait 0.5;
            }
        }

        wait 0.5;
    }
}

faller_location_logic()
{
    wait 1;
    faller_spawn_points = getstructarray( "faller_location", "script_noteworthy" );
    leaper_spawn_points = getstructarray( "leaper_location", "script_noteworthy" );
    spawn_points = arraycombine( faller_spawn_points, leaper_spawn_points, 1, 0 );
    dist_check = 16384;
    elevator_names = getarraykeys( level.elevators );
    elevators = [];

    for ( i = 0; i < elevator_names.size; i++ )
        elevators[i] = getent( "elevator_" + elevator_names[i] + "_body", "targetname" );

    elevator_volumes = [];
    elevator_volumes[elevator_volumes.size] = getent( "elevator_1b", "targetname" );
    elevator_volumes[elevator_volumes.size] = getent( "elevator_1c", "targetname" );
    elevator_volumes[elevator_volumes.size] = getent( "elevator_1d", "targetname" );
    elevator_volumes[elevator_volumes.size] = getent( "elevator_3a", "targetname" );
    elevator_volumes[elevator_volumes.size] = getent( "elevator_3b", "targetname" );
    elevator_volumes[elevator_volumes.size] = getent( "elevator_3c", "targetname" );
    elevator_volumes[elevator_volumes.size] = getent( "elevator_3d", "targetname" );
    level.elevator_volumes = elevator_volumes;

    while ( true )
    {
        foreach ( point in spawn_points )
        {
            should_block = 0;

            foreach ( elevator in elevators )
            {
                if ( distancesquared( elevator getCentroid(), point.origin ) <= dist_check )
                    should_block = 1;
            }

            if ( should_block )
            {
                point.is_enabled = 0;
                point.is_blocked = 1;
                continue;
            }

            if ( isdefined( point.is_blocked ) && point.is_blocked )
                point.is_blocked = 0;

            if ( !isdefined( point.zone_name ) )
                continue;

            zone = level.zones[point.zone_name];

            if ( zone.is_enabled && zone.is_active && zone.is_spawning_allowed )
                point.is_enabled = 1;
        }

        players = get_players();

        foreach ( volume in elevator_volumes )
        {
            should_disable = 0;

            foreach ( player in players )
            {
                if ( is_player_valid( player ) )
                {
                    if ( player istouching( volume ) )
                        should_disable = 1;
                }
            }

            if ( should_disable )
                disable_elevator_spawners( volume, spawn_points );
        }

        wait 0.05;
    }
}

watch_for_elevator_during_faller_spawn()
{
    self endon( "death" );
    self endon( "risen" );
    self endon( "spawn_anim" );

    flag_wait( "power_on" );

    elevator_bodies = [];
    foreach ( elevator in level.elevators )
    {
        elevator_bodies[elevator_bodies.size] = elevator.body;
    }

    elevator_body = get_closest_2d( self.zombie_faller_location.origin, elevator_bodies );

    while ( true )
    {
        should_gib = 0;

        if ( is_true( elevator_body.is_moving ) )
        {
            if ( self istouching( elevator_body ) )
            {
                should_gib = 1;
            }
        }
        else
        {
            if ( is_true( self.zombie_faller_location.is_blocked ) )
            {
                should_gib = 1;
            }
        }

        if ( should_gib )
        {
            playfx( level._effect["zomb_gib"], self.origin );

            if ( isdefined( self.is_leaper ) && self.is_leaper )
            {
                self maps\mp\zombies\_zm_ai_leaper::leaper_cleanup();
                self dodamage( self.health + 100, self.origin );
            }
            else
                self delete();

            break;
        }

        wait 0.05;
    }
}