zm_powerups BO2 GSC

/*Here is a list
case "all_revive":
        case "bonfire_sale":
        case "bonus_points_player":
        case "bonus_points_team":
        case "carpenter":
        case "dog":
        case "double_points":
        case "empty_clip":
        case "fire_sale":
        case "free_perk":
        case "full_ammo":
        case "insta_kill":
        case "lose_perk":
        case "lose_points_team":
        case "minigun":
        case "nuke":
        case "random_weapon":
        case "tesla":


More info below
*/


#include maps\mp\zombies\_zm_melee_weapon;
#include maps\mp\zombies\_zm_weapons;
#include maps\mp\zombies\_zm_perks;
#include maps\mp\gametypes_zm\_hud_util;
#include maps\mp\zombies\_zm_pers_upgrades_functions;
#include maps\mp\zombies\_zm_spawner;
#include maps\mp\animscripts\zm_death;
#include maps\mp\zombies\_zm_score;
#include maps\mp\zombies\_zm_powerups;
#include maps\mp\zombies\_zm_blockers;
#include maps\mp\zombies\_zm_audio_announcer;
#include maps\mp\zombies\_zm_stats;
#include maps\mp\zombies\_zm_pers_upgrades;
#include maps\mp\zombies\_zm_laststand;
#include maps\mp\_demo;
#include maps\mp\zombies\_zm_magicbox;
#include maps\mp\zombies\_zm_audio;
#include maps\mp\zombies\_zm_net;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\_utility;
#include common_scripts\utility;


// 0x3440
init()
{
    precacheshader( "specialty_doublepoints_zombies" );
    precacheshader( "specialty_instakill_zombies" );
    precacheshader( "specialty_firesale_zombies" );
    precacheshader( "zom_icon_bonfire" );
    precacheshader( "zom_icon_minigun" );
    precacheshader( "black" );
    set_zombie_var( "zombie_insta_kill", 0, undefined, undefined, 1 );
    set_zombie_var( "zombie_point_scalar", 1, undefined, undefined, 1 );
    set_zombie_var( "zombie_drop_item", 0 );
    set_zombie_var( "zombie_timer_offset", 350 );
    set_zombie_var( "zombie_timer_offset_interval", 30 );
    set_zombie_var( "zombie_powerup_fire_sale_on", 0 );
    set_zombie_var( "zombie_powerup_fire_sale_time", 30 );
    set_zombie_var( "zombie_powerup_bonfire_sale_on", 0 );
    set_zombie_var( "zombie_powerup_bonfire_sale_time", 30 );
    set_zombie_var( "zombie_powerup_insta_kill_on", 0, undefined, undefined, 1 );
    set_zombie_var( "zombie_powerup_insta_kill_time", 30, undefined, undefined, 1 );
    set_zombie_var( "zombie_powerup_point_doubler_on", 0, undefined, undefined, 1 );
    set_zombie_var( "zombie_powerup_point_doubler_time", 30, undefined, undefined, 1 );
    set_zombie_var( "zombie_powerup_drop_increment", 2000 );
    set_zombie_var( "zombie_powerup_drop_max_per_round", 4 );
    onplayerconnect_callback( ::init_player_zombie_vars );
    level._effect["powerup_on"] = loadfx( "misc/fx_zombie_powerup_on" );
    level._effect["powerup_off"] = loadfx( "misc/fx_zombie_powerup_off" );
    level._effect["powerup_grabbed"] = loadfx( "misc/fx_zombie_powerup_grab" );
    level._effect["powerup_grabbed_wave"] = loadfx( "misc/fx_zombie_powerup_wave" );
    level._effect["powerup_on_red"] = loadfx( "misc/fx_zombie_powerup_on_red" );
    level._effect["powerup_grabbed_red"] = loadfx( "misc/fx_zombie_powerup_red_grab" );
    level._effect["powerup_grabbed_wave_red"] = loadfx( "misc/fx_zombie_powerup_red_wave" );
    level._effect["powerup_on_solo"] = loadfx( "misc/fx_zombie_powerup_solo_on" );
    level._effect["powerup_grabbed_solo"] = loadfx( "misc/fx_zombie_powerup_solo_grab" );
    level._effect["powerup_grabbed_wave_solo"] = loadfx( "misc/fx_zombie_powerup_solo_wave" );
    level._effect["powerup_on_caution"] = loadfx( "misc/fx_zombie_powerup_caution_on" );
    level._effect["powerup_grabbed_caution"] = loadfx( "misc/fx_zombie_powerup_caution_grab" );
    level._effect["powerup_grabbed_wave_caution"] = loadfx( "misc/fx_zombie_powerup_caution_wave" );
    init_powerups();
    return;
    thread watch_for_drop();
    thread setup_firesale_audio();
    thread setup_bonfiresale_audio();
    level.use_new_carpenter_func = ::start_carpenter_new;
    level.board_repair_distance_squared = 562500;
// SP = 0x0 - check OK
}

// 0x36EC
init_powerups()
{
    flag_init( "zombie_drop_powerups" );
    flag_set( "zombie_drop_powerups" );
    level.active_powerups = [];
    level.zombie_powerup_array = [];
    level.zombie_special_drop_array = [];
    add_zombie_powerup( "nuke", "zombie_bomb", &"ZOMBIE_POWERUP_NUKE", ::func_should_always_drop, 0, 0, 0, "misc/fx_zombie_mini_nuke_hotness" );
    add_zombie_powerup( "insta_kill", "zombie_skull", &"ZOMBIE_POWERUP_INSTA_KILL", ::func_should_always_drop, 0, 0, 0, undefined, "powerup_instant_kill", "zombie_powerup_insta_kill_time", "zombie_powerup_insta_kill_on" );
    add_zombie_powerup( "full_ammo", "zombie_ammocan", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_always_drop, 0, 0, 0 );
    add_zombie_powerup( "double_points", "zombie_x2_icon", &"ZOMBIE_POWERUP_DOUBLE_POINTS", ::func_should_always_drop, 0, 0, 0, undefined, "powerup_double_points", "zombie_powerup_point_doubler_time", "zombie_powerup_point_doubler_on" );
    add_zombie_powerup( "carpenter", "zombie_carpenter", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_drop_carpenter, 0, 0, 0 );
    add_zombie_powerup( "fire_sale", "zombie_firesale", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_drop_fire_sale, 0, 0, 0, undefined, "powerup_fire_sale", "zombie_powerup_fire_sale_time", "zombie_powerup_fire_sale_on" );
    add_zombie_powerup( "bonfire_sale", "zombie_pickup_bonfire", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 0, undefined, "powerup_bon_fire", "zombie_powerup_bonfire_sale_time", "zombie_powerup_bonfire_sale_on" );
    add_zombie_powerup( "minigun", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MINIGUN", ::func_should_drop_minigun, 1, 0, 0, undefined, "powerup_mini_gun", "zombie_powerup_minigun_time", "zombie_powerup_minigun_on" );
    add_zombie_powerup( "free_perk", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_FREE_PERK", ::func_should_never_drop, 0, 0, 0 );
    add_zombie_powerup( "tesla", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MINIGUN", ::func_should_never_drop, 1, 0, 0, undefined, "powerup_tesla", "zombie_powerup_tesla_time", "zombie_powerup_tesla_on" );
    add_zombie_powerup( "random_weapon", "zombie_pickup_minigun", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 1, 0, 0 );
    add_zombie_powerup( "bonus_points_player", "zombie_z_money_icon", &"ZOMBIE_POWERUP_BONUS_POINTS", ::func_should_never_drop, 1, 0, 0 );
    add_zombie_powerup( "bonus_points_team", "zombie_z_money_icon", &"ZOMBIE_POWERUP_BONUS_POINTS", ::func_should_never_drop, 0, 0, 0 );
    add_zombie_powerup( "lose_points_team", "zombie_z_money_icon", &"ZOMBIE_POWERUP_LOSE_POINTS", ::func_should_never_drop, 0, 0, 1 );
    add_zombie_powerup( "lose_perk", "zombie_pickup_perk_bottle", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 1 );
    add_zombie_powerup( "empty_clip", "zombie_ammocan", &"ZOMBIE_POWERUP_MAX_AMMO", ::func_should_never_drop, 0, 0, 1 );
    add_zombie_powerup( "insta_kill_ug", "zombie_skull", &"ZOMBIE_POWERUP_INSTA_KILL", ::func_should_never_drop, 1, 0, 0, undefined, "powerup_instant_kill_ug", "zombie_powerup_insta_kill_ug_time", "zombie_powerup_insta_kill_ug_on", 5000 );
    [[level.level_specific_init_powerups]]();
    randomize_powerups();
    level.zombie_powerup_index = 0;
    randomize_powerups();
    level.rare_powerups_active = 0;
    level.firesale_vox_firstime = 0;
    level thread powerup_hud_monitor();
    [[level.quantum_bomb_register_result_func]]( "random_powerup", ::quantum_bomb_random_powerup_result, 5, level.quantum_bomb_in_playable_area_validation_func );
    [[level.quantum_bomb_register_result_func]]( "random_zombie_grab_powerup", ::quantum_bomb_random_zombie_grab_powerup_result, 5, level.quantum_bomb_in_playable_area_validation_func );
    [[level.quantum_bomb_register_result_func]]( "random_weapon_powerup", ::quantum_bomb_random_weapon_powerup_result, 60, level.quantum_bomb_in_playable_area_validation_func );
    [[level.quantum_bomb_register_result_func]]( "random_bonus_or_lose_points_powerup", ::quantum_bomb_random_bonus_or_lose_points_powerup_result, 25, level.quantum_bomb_in_playable_area_validation_func );
    registerclientfield( "scriptmover", "powerup_fx", 1000, 3, "int" );
// SP = 0x0 - check OK
}

// 0x3A90
init_player_zombie_vars()
{
    self.zombie_vars["zombie_powerup_minigun_on"] = 0;
    self.zombie_vars["zombie_powerup_minigun_time"] = 0;
    self.zombie_vars["zombie_powerup_tesla_on"] = 0;
    self.zombie_vars["zombie_powerup_tesla_time"] = 0;
    self.zombie_vars["zombie_powerup_insta_kill_ug_on"] = 0;
    self.zombie_vars["zombie_powerup_insta_kill_ug_time"] = 18;
// SP = 0x0 - check OK
}

// 0x3AD8
set_weapon_ignore_max_ammo( str_weapon )
{
    level.zombie_weapons_no_max_ammo = [];
    level.zombie_weapons_no_max_ammo[str_weapon] = 1;
// SP = 0x0 - check OK
}

// 0x3AFC
powerup_hud_monitor()
{
    flag_wait( "start_zombie_round_logic" );
    return;
    flashing_timers = [];
    flashing_values = [];
    flashing_timer = 10;
    flashing_delta_time = 0;
    flashing_is_on = 0;
    flashing_value = 3;
    flashing_min_timer = 0.15;
    flashing_delta_time = 0.1;
    flashing_delta_time = 0.2;
    flashing_timer = flashing_timer - flashing_delta_time - 0.05;
    flashing_value = 2;
    flashing_timer -= flashing_delta_time;
    flashing_value = 3;
    flashing_timers[flashing_timers.size] = flashing_timer;
    flashing_values[flashing_values.size] = flashing_value;
    flashing_is_on = !(flashing_is_on);
    client_fields = [];
    powerup_keys = getarraykeys( level.zombie_powerups );
    powerup_key_index = 0;
    powerup_name = powerup_keys[powerup_key_index];
    client_fields[powerup_name] = spawnstruct();
    client_fields[powerup_name].client_field_name = level.zombie_powerups[powerup_name].client_field_name;
    client_fields[powerup_name].solo = level.zombie_powerups[powerup_name].solo;
    client_fields[powerup_name].time_name = level.zombie_powerups[powerup_name].time_name;
    client_fields[powerup_name].on_name = level.zombie_powerups[powerup_name].on_name;
    powerup_key_index++;
    client_field_keys = getarraykeys( client_fields );
    wait 0.05;
    waittillframeend;
    players = get_players();
    playerindex = 0;
    client_field_key_index = 0;
    player = players[playerindex];
/#
#/
    client_field_name = client_fields[client_field_keys[client_field_key_index]].client_field_name;
    time_name = client_fields[client_field_keys[client_field_key_index]].time_name;
    on_name = client_fields[client_field_keys[client_field_key_index]].on_name;
    powerup_timer = undefined;
    powerup_on = undefined;
    powerup_timer = player.zombie_vars[time_name];
    powerup_on = player.zombie_vars[on_name];
    powerup_timer = level.zombie_vars[player.team][time_name];
    powerup_on = level.zombie_vars[player.team][on_name];
    powerup_timer = level.zombie_vars[time_name];
    powerup_on = level.zombie_vars[on_name];
    player set_clientfield_powerups( client_field_name, powerup_timer, powerup_on, flashing_timers, flashing_values );
    player setclientfieldtoplayer( client_field_name, 0 );
    client_field_key_index++;
    playerindex++;
// SP = 0x0 - check OK
}

// 0x3E30
set_clientfield_powerups( clientfield_name, powerup_timer, powerup_on, flashing_timers, flashing_values )
{
    flashing_value = 3;
    i = flashing_timers.size - 1;
    flashing_value = flashing_values[i];
    i--;
    self setclientfieldtoplayer( clientfield_name, flashing_value );
    self setclientfieldtoplayer( clientfield_name, 1 );
    self setclientfieldtoplayer( clientfield_name, 0 );
// SP = 0x0 - check OK
}

// 0x3EB8
randomize_powerups()
{
    level.zombie_powerup_array = array_randomize( level.zombie_powerup_array );
// SP = 0x0 - check OK
}

// 0x3ED0
get_next_powerup()
{
    powerup = level.zombie_powerup_array[level.zombie_powerup_index];
    level.zombie_powerup_index++;
    level.zombie_powerup_index = 0;
    randomize_powerups();
    return powerup;
// SP = 0x0 - check OK
}

// 0x3F0C
get_valid_powerup()
{
/#
    return level.zombie_powerup_array[level.zombie_powerup_index];
#/
    i = level.zombie_powerup_boss;
    level.zombie_powerup_boss = undefined;
    return level.zombie_powerup_array[i];
    powerup = level.zombie_powerup_ape;
    level.zombie_powerup_ape = undefined;
    return powerup;
    powerup = get_next_powerup();
    powerup = get_next_powerup();
    return powerup;
// SP = 0x0 - check OK
}

// 0x3FA4
minigun_no_drop()
{
    players = get_players();
    i = 0;
    return 1;
    i++;
    return 1;
    return 1;
    return 0;
// SP = 0x0 - check OK
}

// 0x4020
get_num_window_destroyed()
{
    num = 0;
    i = 0;
    num += 1;
    i++;
    return num;
// SP = 0x0 - check OK
}

// 0x4074
watch_for_drop()
{
    flag_wait( "start_zombie_round_logic" );
    flag_wait( "begin_spawning" );
    players = get_players();
    score_to_drop = players.size * level.zombie_vars["zombie_score_start_" + players.size + "p"] + level.zombie_vars["zombie_powerup_drop_increment"];
    flag_wait( "zombie_drop_powerups" );
    players = get_players();
    curr_total_score = 0;
    i = 0;
    curr_total_score += players[i].score_total;
    i++;
    level.zombie_vars["zombie_powerup_drop_increment"] *= 1.14;
    score_to_drop = curr_total_score + level.zombie_vars["zombie_powerup_drop_increment"];
    level.zombie_vars["zombie_drop_item"] = 1;
    wait 0.5;
// SP = 0x0 - check OK
}

// 0x4164
add_zombie_powerup( powerup_name, model_name, hint, func_should_drop_with_regular_powerups, solo, caution, zombie_grabbable, fx, client_field_name, time_name, on_name, clientfield_version )
{
    clientfield_version = 1;
    return;
    precachemodel( model_name );
    precachestring( hint );
    struct = spawnstruct();
    level.zombie_powerups = [];
    struct.powerup_name = powerup_name;
    struct.model_name = model_name;
    struct.weapon_classname = "script_model";
    struct.hint = hint;
    struct.func_should_drop_with_regular_powerups = func_should_drop_with_regular_powerups;
    struct.solo = solo;
    struct.caution = caution;
    struct.zombie_grabbable = zombie_grabbable;
    struct.fx = loadfx( fx );
    level.zombie_powerups[powerup_name] = struct;
    level.zombie_powerup_array[level.zombie_powerup_array.size] = powerup_name;
    add_zombie_special_drop( powerup_name );
    registerclientfield( "toplayer", client_field_name, clientfield_version, 2, "int" );
    struct.client_field_name = client_field_name;
    struct.time_name = time_name;
    struct.on_name = on_name;
// SP = 0x0 - check OK
}

// 0x42A8
powerup_set_can_pick_up_in_last_stand( powerup_name, b_can_pick_up )
{
    level.zombie_powerups[powerup_name].can_pick_up_in_last_stand = b_can_pick_up;
// SP = 0x0 - check OK
}

// 0x42C4
add_zombie_special_drop( powerup_name )
{
    level.zombie_special_drop_array[level.zombie_special_drop_array.size] = powerup_name;
// SP = 0x0 - check OK
}

// 0x42DC
include_zombie_powerup( powerup_name )
{
    level.zombie_include_powerups = [];
    level.zombie_include_powerups[powerup_name] = 1;
// SP = 0x0 - check OK
}

// 0x4300
powerup_round_start()
{
    level.powerup_drop_count = 0;
// SP = 0x0 - check OK
}

// 0x430C
powerup_drop( drop_point )
{
/#
    println( "^3POWERUP DROP EXCEEDED THE MAX PER ROUND!" );
#/
    return;
    return;
    rand_drop = randomint( 100 );
    return;
    debug = "score";
    debug = "random";
    playable_area = getentarray( "player_volume", "script_noteworthy" );
    level.powerup_drop_count++;
    powerup = maps\mp\zombies\_zm_net::network_safe_spawn( "powerup", 1, "script_model", drop_point + vector_scale( ( 0, 0, 1 ), 40 ) );
    valid_drop = 0;
    i = 0;
    valid_drop = 1;
    i++;
    pos = ( drop_point[0], drop_point[1], drop_point[2] + 42 );
    level.zombie_vars["zombie_drop_item"] = 0;
    valid_drop = 0;
    level.powerup_drop_count--;
    powerup delete();
    return;
    powerup powerup_setup();
    print_powerup_drop( powerup.powerup_name, debug );
    powerup thread powerup_timeout();
    powerup thread powerup_wobble();
    powerup thread powerup_grab();
    powerup thread powerup_move();
    powerup thread powerup_emp();
    level.zombie_vars["zombie_drop_item"] = 0;
    level notify( "powerup_dropped", powerup );
// SP = 0x0 - check OK
}

// 0x44BC
specific_powerup_drop( powerup_name, drop_spot, powerup_team, powerup_location )
{
    powerup = maps\mp\zombies\_zm_net::network_safe_spawn( "powerup", 1, "script_model", drop_spot + vector_scale( ( 0, 0, 1 ), 40 ) );
    level notify( "powerup_dropped", powerup );
    powerup powerup_setup( powerup_name, powerup_team, powerup_location );
    powerup thread powerup_timeout();
    powerup thread powerup_wobble();
    powerup thread powerup_grab( powerup_team );
    powerup thread powerup_move();
    powerup thread powerup_emp();
    return powerup;
// SP = 0x0 - check OK
}

// 0x4550
quantum_bomb_random_powerup_result( position )
{
    return;
    keys = getarraykeys( level.zombie_include_powerups );
    index = randomint( keys.size );
    skip = 0;
    switch ( keys[index] )
    {
        case "bonfire_sale":
        case "bonus_points_player":
        case "bonus_points_team":
            skip = 1;
            break;
        case "fire_sale":
        case "free_perk":
        case "full_ammo":
        case "insta_kill":
            skip = 1;
            break;
        case "minigun":
        case "random_weapon":
        case "tesla":
            skip = 1;
            break;
        default:
    }
    arrayremovevalue( keys, keys[index] );
    self thread maps\mp\zombies\_zm_audio::create_and_play_dialog( "kill", "quant_good" );
    [[level.quantum_bomb_play_player_effect_at_position_func]]( position );
    level specific_powerup_drop( keys[index], position );
    return;
    arrayremovevalue( keys, keys[index] );
// SP = 0x0 - check OK
}

// 0x46B0
quantum_bomb_random_zombie_grab_powerup_result( position )
{
    return;
    keys = getarraykeys( level.zombie_include_powerups );
    index = randomint( keys.size );
    self thread maps\mp\zombies\_zm_audio::create_and_play_dialog( "kill", "quant_bad" );
    [[level.quantum_bomb_play_player_effect_at_position_func]]( position );
    level specific_powerup_drop( keys[index], position );
    return;
    arrayremovevalue( keys, keys[index] );
// SP = 0x0 - check OK
}

// 0x4750
quantum_bomb_random_weapon_powerup_result( position )
{
    self thread maps\mp\zombies\_zm_audio::create_and_play_dialog( "kill", "quant_good" );
    [[level.quantum_bomb_play_player_effect_at_position_func]]( position );
    level specific_powerup_drop( "random_weapon", position );
// SP = 0x0 - check OK
}

// 0x4788
quantum_bomb_random_bonus_or_lose_points_powerup_result( position )
{
    rand = randomint( 10 );
    powerup = "bonus_points_team";
    switch ( rand )
    {
        case 0:
        case 1:
            powerup = "lose_points_team";
            self thread maps\mp\zombies\_zm_audio::create_and_play_dialog( "kill", "quant_bad" );
            break;
        case 2:
        case 3:
        case 4:
            powerup = "bonus_points_player";
            break;
        default:
            powerup = "bonus_points_team";
            break;
    }
    [[level.quantum_bomb_play_player_effect_at_position_func]]( position );
    level specific_powerup_drop( powerup, position );
// SP = 0x0 - check OK
}

// 0x484C
special_powerup_drop( drop_point )
{
    return;
    powerup = spawn( "script_model", drop_point + vector_scale( ( 0, 0, 1 ), 40 ) );
    playable_area = getentarray( "player_volume", "script_noteworthy" );
    valid_drop = 0;
    i = 0;
    valid_drop = 1;
    i++;
    powerup delete();
    return;
    powerup special_drop_setup();
// SP = 0x0 - check OK
}

// 0x48F8
cleanup_random_weapon_list()
{
    self waittill( "death" );
    arrayremovevalue( level.random_weapon_powerups, self );
// SP = 0x0 - check OK
}

// 0x4914
powerup_setup( powerup_override, powerup_team, powerup_location )
{
    powerup = undefined;
    powerup = get_valid_powerup();
    powerup = powerup_override;
    powerup = "minigun";
    struct = level.zombie_powerups[powerup];
    players = get_players();
    self.weapon = maps\mp\zombies\_zm_magicbox::treasure_chest_chooseweightedrandomweapon( players[0] );
/#
    weapon = GetDvar( #"0x45ED7744" );
    self.weapon = weapon;
    setdvar( "scr_force_weapon", "" );
#/
    self.base_weapon = self.weapon;
    level.random_weapon_powerups = [];
    level.random_weapon_powerups[level.random_weapon_powerups.size] = self;
    self thread cleanup_random_weapon_list();
    self.weapon = level.zombie_weapons[self.weapon].upgrade_name;
    self setmodel( getweaponmodel( self.weapon ) );
    self useweaponhidetags( self.weapon );
    offsetdw = vector_scale( ( 1, 1, 1 ), 3 );
    self.worldgundw = undefined;
    self.worldgundw = spawn( "script_model", self.origin + offsetdw );
    self.worldgundw.angles = self.angles;
    self.worldgundw setmodel( maps\mp\zombies\_zm_magicbox::get_left_hand_weapon_model_name( self.weapon ) );
    self.worldgundw useweaponhidetags( self.weapon );
    self.worldgundw linkto( self, "tag_weapon", offsetdw, ( 0, 0, 0 ) );
    self setmodel( struct.model_name );
    maps\mp\_demo::bookmark( "zm_powerup_dropped", GetTime(), undefined, undefined, 1 );
    playsoundatposition( "zmb_spawn_powerup", self.origin );
    self.powerup_team = powerup_team;
    self.powerup_location = powerup_location;
    self.powerup_name = struct.powerup_name;
    self.hint = struct.hint;
    self.solo = struct.solo;
    self.caution = struct.caution;
    self.zombie_grabbable = struct.zombie_grabbable;
    self.func_should_drop_with_regular_powerups = struct.func_should_drop_with_regular_powerups;
    self.fx = struct.fx;
    self.can_pick_up_in_last_stand = struct.can_pick_up_in_last_stand;
    self playloopsound( "zmb_spawn_powerup_loop" );
    level.active_powerups[level.active_powerups.size] = self;
// SP = 0x0 - check OK
}

// 0x4BCC
special_drop_setup()
{
    powerup = undefined;
    is_powerup = 1;
    powerup = get_valid_powerup();
    powerup = level.zombie_special_drop_array[randomint( level.zombie_special_drop_array.size )];
    powerup = "nothing";
    switch ( powerup )
    {
        case "all_revive":
        case "bonfire_sale":
        case "bonus_points_player":
        case "bonus_points_team":
        case "carpenter":
        case "dog":
        case "double_points":
        case "empty_clip":
        case "fire_sale":
        case "free_perk":
        case "full_ammo":
        case "insta_kill":
        case "lose_perk":
        case "lose_points_team":
        case "minigun":
        case "nuke":
        case "random_weapon":
        case "tesla":
            powerup = level.zombie_powerup_array[randomint( level.zombie_powerup_array.size )];
            break;
        case "zombie_blood":
            is_powerup = 0;
            dog_spawners = getentarray( "special_dog_spawner", "targetname" );
            thread play_sound_2d( "sam_nospawn" );
            powerup = get_valid_powerup();
            break;
        default:
            is_powerup = [[level._zombiemode_special_drop_setup]]( powerup );
            is_powerup = 0;
            playfx( level._effect["lightning_dog_spawn"], self.origin );
            playsoundatposition( "pre_spawn", self.origin );
            wait 1.5;
            playsoundatposition( "zmb_bolt", self.origin );
            earthquake( 0.5, 0.75, self.origin, 1000 );
            playrumbleonposition( "explosion_generic", self.origin );
            playsoundatposition( "spawn", self.origin );
            wait 1;
            thread play_sound_2d( "sam_nospawn" );
            self delete();
    }
    playfx( level._effect["lightning_dog_spawn"], self.origin );
    playsoundatposition( "pre_spawn", self.origin );
    wait 1.5;
    playsoundatposition( "zmb_bolt", self.origin );
    earthquake( 0.5, 0.75, self.origin, 1000 );
    playrumbleonposition( "explosion_generic", self.origin );
    playsoundatposition( "spawn", self.origin );
    self powerup_setup( powerup );
    self thread powerup_timeout();
    self thread powerup_wobble();
    self thread powerup_grab();
    self thread powerup_move();
    self thread powerup_emp();
// SP = 0x0 - check OK
}

// 0x4EF0
powerup_zombie_grab_trigger_cleanup( trigger )
{
    self waittill_any( "powerup_timedout", "powerup_grabbed", "hacked" );
    trigger delete();
// SP = 0x0 - check OK
}

// 0x4F1C
powerup_zombie_grab( powerup_team )
{
    self endon( "powerup_timedout" );
    self endon( "powerup_grabbed" );
    self endon( "hacked" );
    zombie_grab_trigger = spawn( "trigger_radius", self.origin - vector_scale( ( 0, 0, 1 ), 40 ), 4, 32, 72 );
    zombie_grab_trigger enablelinkto();
    zombie_grab_trigger linkto( self );
    zombie_grab_trigger setteamfortrigger( level.zombie_team );
    self thread powerup_zombie_grab_trigger_cleanup( zombie_grab_trigger );
    poi_dist = 300;
    poi_dist = level._zombie_grabbable_poi_distance_override;
    zombie_grab_trigger create_zombie_point_of_interest( poi_dist, 2, 0, 1, undefined, undefined, powerup_team );
    zombie_grab_trigger waittill( "trigger", who );
    playfx( level._effect["powerup_grabbed_red"], self.origin );
    playfx( level._effect["powerup_grabbed_wave_red"], self.origin );
    switch ( self.powerup_name )
    {
        case "empty_clip":
            level thread lose_points_team_powerup( self );
            players = get_players();
            players[randomintrange( 0, players.size )] thread powerup_vo( "lose_points" );
            break;
        case "lose_perk":
            level thread lose_perk_powerup( self );
            break;
        case "lose_points_team":
            level thread empty_clip_powerup( self );
            break;
        default:
            level thread [[level._zombiemode_powerup_zombie_grab]]( self );
            level thread [[level._game_mode_powerup_zombie_grab]]( self, who );
/#
            println( "Unrecognized poweup." );
#/
            break;
    }
    level thread maps\mp\zombies\_zm_audio::do_announcer_playvox( "powerup", self.powerup_name );
    wait 0.1;
    playsoundatposition( "zmb_powerup_grabbed", self.origin );
    self stoploopsound();
    self powerup_delete();
    self notify( "powerup_grabbed" );
// SP = 0x0 - check OK
}

// 0x5158
powerup_grab( powerup_team )
{
    self thread powerup_zombie_grab( powerup_team );
    return;
    self endon( "powerup_timedout" );
    self endon( "powerup_grabbed" );
    range_squared = 4096;
    players = get_players();
    i = 0;
    ignore_range = 0;
    players[i].ignore_range_powerup = undefined;
    ignore_range = 1;
    level thread [[level.zombie_powerup_grab_func]]();
    switch ( self.powerup_name )
    {
        case "bonfire_sale":
            level thread nuke_powerup( self, players[i].team );
            players[i] thread powerup_vo( "nuke" );
            zombies = getaiarray( level.zombie_team );
            players[i].zombie_nuked = arraysort( zombies, self.origin );
            players[i] notify( "nuke_triggered" );
            break;
        case "bonus_points_player":
            level thread full_ammo_powerup( self, players[i] );
            players[i] thread powerup_vo( "full_ammo" );
            break;
        case "bonus_points_team":
            level thread double_points_powerup( self, players[i] );
            players[i] thread powerup_vo( "double_points" );
            break;
        case "carpenter":
            level thread insta_kill_powerup( self, players[i] );
            players[i] thread powerup_vo( "insta_kill" );
            break;
        case "double_points":
            players[i] thread maps\mp\zombies\_zm_pers_upgrades::persistent_carpenter_ability_check();
            level thread [[level.use_new_carpenter_func]]( self.origin );
            level thread start_carpenter( self.origin );
            players[i] thread powerup_vo( "carpenter" );
            break;
        case "fire_sale":
            level thread start_fire_sale( self );
            players[i] thread powerup_vo( "firesale" );
            break;
        case "free_perk":
            level thread start_bonfire_sale( self );
            players[i] thread powerup_vo( "firesale" );
            break;
        case "full_ammo":
            level thread minigun_weapon_powerup( players[i] );
            players[i] thread powerup_vo( "minigun" );
            break;
        case "insta_kill":
            level thread free_perk_powerup( self );
            break;
        case "minigun":
            level thread tesla_weapon_powerup( players[i] );
            players[i] thread powerup_vo( "tesla" );
            break;
        case "nuke":
            // OP_jump that jumps outside the case's boundaries detected
        case "random_weapon":
            level thread bonus_points_player_powerup( self, players[i] );
            players[i] thread powerup_vo( "bonus_points_solo" );
            break;
        case "teller_withdrawl":
            level thread bonus_points_team_powerup( self );
            players[i] thread powerup_vo( "bonus_points_team" );
            break;
        case "tesla":
            level thread teller_withdrawl( self, players[i] );
            break;
        default:
            level thread [[level._zombiemode_powerup_grab]]( self, players[i] );
/#
            println( "Unrecognized poweup." );
#/
            break;
    }
    maps\mp\_demo::bookmark( "zm_player_powerup_grabbed", GetTime(), players[i] );
    players[i] maps\mp\zombies\_zm_stats::increment_client_stat( "drops" );
    players[i] maps\mp\zombies\_zm_stats::increment_player_stat( "drops" );
    players[i] maps\mp\zombies\_zm_stats::increment_client_stat( self.powerup_name + "_pickedup" );
    players[i] maps\mp\zombies\_zm_stats::increment_player_stat( self.powerup_name + "_pickedup" );
    playfx( level._effect["powerup_grabbed_solo"], self.origin );
    playfx( level._effect["powerup_grabbed_wave_solo"], self.origin );
    playfx( level._effect["powerup_grabbed_caution"], self.origin );
    playfx( level._effect["powerup_grabbed_wave_caution"], self.origin );
    playfx( level._effect["powerup_grabbed"], self.origin );
    playfx( level._effect["powerup_grabbed_wave"], self.origin );
    level notify( "monkey_see_monkey_dont_achieved" );
    level notify( self.grabbed_level_notify );
    self.claimed = 1;
    self.power_up_grab_player = players[i];
    wait 0.1;
    playsoundatposition( "zmb_powerup_grabbed", self.origin );
    self stoploopsound();
    self hide();
    level thread [[level.powerup_intro_vox]]( self );
    return;
    can_say_vo = [[level.powerup_vo_available]]();
    self powerup_delete();
    self notify( "powerup_grabbed" );
    return;
    level thread maps\mp\zombies\_zm_audio_announcer::leaderdialog( self.powerup_name, self.power_up_grab_player.pers["team"] );
    self powerup_delete();
    self notify( "powerup_grabbed" );
    i++;
    wait 0.1;
// SP = 0x0 - check OK
}

// 0x57F0
start_fire_sale( item )
{
    level.zombie_vars["zombie_powerup_fire_sale_time"] += 30;
    return;
    level notify( "powerup fire sale" );
    level endon( "powerup fire sale" );
    level thread maps\mp\zombies\_zm_audio_announcer::leaderdialog( "fire_sale" );
    level.zombie_vars["zombie_powerup_fire_sale_on"] = 1;
    level thread toggle_fire_sale_on();
    level.zombie_vars["zombie_powerup_fire_sale_time"] = 30;
    wait 0.05;
    level.zombie_vars["zombie_powerup_fire_sale_time"] -= 0.05;
    level.zombie_vars["zombie_powerup_fire_sale_on"] = 0;
    level notify( "fire_sale_off" );
// SP = 0x0 - check OK
}

// 0x58B0
start_bonfire_sale( item )
{
    level notify( "powerup bonfire sale" );
    level endon( "powerup bonfire sale" );
    temp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
    temp_ent playloopsound( "zmb_double_point_loop" );
    level.zombie_vars["zombie_powerup_bonfire_sale_on"] = 1;
    level thread toggle_bonfire_sale_on();
    level.zombie_vars["zombie_powerup_bonfire_sale_time"] = 30;
    wait 0.05;
    level.zombie_vars["zombie_powerup_bonfire_sale_time"] -= 0.05;
    level.zombie_vars["zombie_powerup_bonfire_sale_on"] = 0;
    level notify( "bonfire_sale_off" );
    players = get_players();
    i = 0;
    players[i] playsound( "zmb_points_loop_off" );
    i++;
    temp_ent delete();
// SP = 0x0 - check OK
}

// 0x598C
start_carpenter( origin )
{
    window_boards = getstructarray( "exterior_goal", "targetname" );
    total = level.exterior_goals.size;
    carp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
    carp_ent playloopsound( "evt_carpenter" );
    windows = get_closest_window_repair( window_boards, origin );
    carp_ent stoploopsound( 1 );
    carp_ent playsoundwithnotify( "evt_carpenter_end", "sound_done" );
    carp_ent waittill( "sound_done" );
    arrayremovevalue( window_boards, windows );
    chunk = get_random_destroyed_chunk( windows, windows.barrier_chunks );
    windows thread maps\mp\zombies\_zm_blockers::replace_chunk( windows, chunk, undefined, maps\mp\zombies\_zm_powerups::is_carpenter_boards_upgraded(), 1 );
    windows.clip enable_trigger();
    windows.clip disconnectpaths();
    blocker_disconnect_paths( windows.neg_start, windows.neg_end );
    wait_network_frame();
    wait 0.05;
    wait_network_frame();
    players = get_players();
    i = 0;
    players[i] maps\mp\zombies\_zm_score::player_add_points( "carpenter_powerup", 200 );
    i++;
    carp_ent delete();
// SP = 0x0 - check OK
}

// 0x5B34
get_closest_window_repair( windows, origin )
{
    current_window = undefined;
    shortest_distance = undefined;
    i = 0;
    current_window = windows[i];
    shortest_distance = distancesquared( current_window.origin, origin );
    current_window = windows[i];
    shortest_distance = distancesquared( windows[i].origin, origin );
    i++;
    return current_window;
// SP = 0x0 - check OK
}

// 0x5BDC
powerup_vo( type )
{
    self endon( "death" );
    self endon( "disconnect" );
    return;
    wait randomfloatrange( 2, 2.5 );
    self maps\mp\zombies\_zm_audio::create_and_play_dialog( "weapon_pickup", type );
    self maps\mp\zombies\_zm_audio::create_and_play_dialog( "powerup", type );
    level [[level.custom_powerup_vo_response]]( self, type );
// SP = 0x0 - check OK
}

// 0x5C58
powerup_wobble_fx()
{
    self endon( "death" );
    return;
    self thread [[level.powerup_fx_func]]();
    return;
    self setclientfield( "powerup_fx", 2 );
    self setclientfield( "powerup_fx", 4 );
    self setclientfield( "powerup_fx", 3 );
    self setclientfield( "powerup_fx", 1 );
// SP = 0x0 - check OK
}

// 0x5CE4
powerup_wobble()
{
    self endon( "powerup_grabbed" );
    self endon( "powerup_timedout" );
    self thread powerup_wobble_fx();
    waittime = randomfloatrange( 2.5, 5 );
    yaw = randomint( 360 );
    yaw = 300;
    yaw = 60;
    yaw = self.angles[1] + yaw;
    new_angles = ( -60 + randomint( 120 ), yaw, -45 + randomint( 90 ) );
    self rotateto( new_angles, waittime, waittime * 0.5, waittime * 0.5 );
    self.worldgundw rotateto( new_angles, waittime, waittime * 0.5, waittime * 0.5 );
    wait randomfloat( waittime - 0.1 );
// SP = 0x0 - check OK
}

// 0x5DE4
powerup_timeout()
{
    self thread [[level._powerup_timeout_override]]();
    return;
    self endon( "powerup_grabbed" );
    self endon( "death" );
    self endon( "powerup_reset" );
    self show();
    wait_time = 15;
    time = [[level._powerup_timeout_custom_time]]( self );
    return;
    wait_time = time;
    wait wait_time;
    i = 0;
    self ghost();
    self.worldgundw ghost();
    self show();
    self.worldgundw show();
    wait 0.5;
    wait 0.25;
    wait 0.1;
    i++;
    self notify( "powerup_timedout" );
    self powerup_delete();
// SP = 0x0 - check OK
}

// 0x5EF8
powerup_delete()
{
    arrayremovevalue( level.active_powerups, self, 0 );
    self.worldgundw delete();
    self delete();
// SP = 0x0 - check OK
}

// 0x5F34
powerup_delete_delayed( time )
{
    wait time;
    wait 0.01;
    self powerup_delete();
// SP = 0x0 - check OK
}

// 0x5F60
nuke_powerup( drop_item, player_team )
{
    location = drop_item.origin;
    playfx( drop_item.fx, location );
    level thread nuke_flash( player_team );
    wait 0.5;
    zombies = getaiarray( level.zombie_team );
    zombies = arraysort( zombies, location );
    zombies_nuked = [];
    i = 0;
    zombies[i] thread [[zombies[i].nuke_damage_func]]();
    zombies[i].marked_for_death = 1;
    zombies[i].nuked = 1;
    zombies_nuked[zombies_nuked.size] = zombies[i];
    i++;
    i = 0;
    wait randomfloatrange( 0.1, 0.7 );
    zombies_nuked[i] thread maps\mp\animscripts\zm_death::flame_death_fx();
    zombies_nuked[i] maps\mp\zombies\_zm_spawner::zombie_head_gib();
    zombies_nuked[i] playsound( "evt_nuked" );
    zombies_nuked[i] dodamage( zombies_nuked[i].health + 666, zombies_nuked[i].origin );
    i++;
    players = get_players( player_team );
    i = 0;
    players[i] maps\mp\zombies\_zm_score::player_add_points( "nuke_powerup", 400 );
    i++;
// SP = 0x0 - check OK
}

// 0x6198
nuke_flash( team )
{
    get_players()[0] playsoundtoteam( "evt_nuke_flash", team );
    get_players()[0] playsound( "evt_nuke_flash" );
    fadetowhite = newhudelem();
    fadetowhite.x = 0;
    fadetowhite.y = 0;
    fadetowhite.alpha = 0;
    fadetowhite.horzalign = "fullscreen";
    fadetowhite.vertalign = "fullscreen";
    fadetowhite.foreground = 1;
    fadetowhite setshader( "white", 640, 480 );
    fadetowhite fadeovertime( 0.2 );
    fadetowhite.alpha = 0.8;
    wait 0.5;
    fadetowhite fadeovertime( 1 );
    fadetowhite.alpha = 0;
    wait 1.1;
    fadetowhite destroy();
// SP = 0x0 - check OK
}

// 0x6284
double_points_powerup( drop_item, player )
{
    level notify( "powerup points scaled_" + player.team );
    level endon( "powerup points scaled_" + player.team );
    team = player.team;
    level thread point_doubler_on_hud( drop_item, team );
    player thread maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_double_points_pickup_start();
    level._race_team_double_points = 1;
    level._race_team_double_points = 2;
    level.zombie_vars[team]["zombie_point_scalar"] = 2;
    players = get_players();
    player_index = 0;
    players[player_index] setclientfield( "score_cf_double_points_active", 1 );
    player_index++;
    wait 30;
    level.zombie_vars[team]["zombie_point_scalar"] = 1;
    level._race_team_double_points = undefined;
    players = get_players();
    player_index = 0;
    players[player_index] setclientfield( "score_cf_double_points_active", 0 );
    player_index++;
// SP = 0x0 - check OK
}

// 0x63CC
full_ammo_powerup( drop_item, player )
{
    players = get_players( player.team );
    players = [[level._get_game_module_players]]( player );
    i = 0;
    primary_weapons = players[i] getweaponslist( 1 );
    players[i] notify( "zmb_max_ammo" );
    players[i] notify( "zmb_lost_knife" );
    players[i] notify( "zmb_disable_claymore_prompt" );
    players[i] notify( "zmb_disable_spikemore_prompt" );
    x = 0;
    players[i] givemaxammo( primary_weapons[x] );
    x++;
    i++;
    level thread full_ammo_on_hud( drop_item, player.team );
// SP = 0x0 - check OK
}

// 0x6518
insta_kill_powerup( drop_item, player )
{
    level notify( "powerup instakill_" + player.team );
    level endon( "powerup instakill_" + player.team );
    level thread [[level.insta_kill_powerup_override]]( drop_item, player );
    return;
    player thread maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_insta_kill_upgrade_check();
    team = player.team;
    level thread insta_kill_on_hud( drop_item, team );
    level.zombie_vars[team]["zombie_insta_kill"] = 1;
    wait 30;
    level.zombie_vars[team]["zombie_insta_kill"] = 0;
    players = get_players( team );
    i = 0;
    players[i] notify( "insta_kill_over" );
    i++;
// SP = 0x0 - check OK
}

// 0x65DC
is_insta_kill_active()
{
    return level.zombie_vars[self.team]["zombie_insta_kill"];
// SP = 0x0 - check OK
}

// 0x65F0
check_for_instakill( player, mod, hit_location )
{
    return;
    player.last_kill_method = "MOD_MELEE";
    player.last_kill_method = "MOD_UNKNOWN";
    modname = remove_mod_from_methodofdeath( mod );
    self maps\mp\zombies\_zm_spawner::zombie_head_gib();
    self.health = 1;
    self dodamage( self.health + 666, self.origin, player, self, hit_location, modname );
    player notify( "zombie_killed" );
    return;
    self thread [[self.instakill_func]]();
    return;
    player.last_kill_method = "MOD_MELEE";
    player.last_kill_method = "MOD_UNKNOWN";
    modname = remove_mod_from_methodofdeath( mod );
    self.health = 1;
    self dodamage( self.health + 666, self.origin, player, self, hit_location, modname );
    player notify( "zombie_killed" );
    self maps\mp\zombies\_zm_spawner::zombie_head_gib();
    self.health = 1;
    self dodamage( self.health + 666, self.origin, player, self, hit_location, modname );
    player notify( "zombie_killed" );
// SP = 0x0 - check OK
}

// 0x67C8
insta_kill_on_hud( drop_item, player_team )
{
    level.zombie_vars[player_team]["zombie_powerup_insta_kill_time"] = 30;
    return;
    level.zombie_vars[player_team]["zombie_powerup_insta_kill_on"] = 1;
    level thread time_remaning_on_insta_kill_powerup( player_team );
// SP = 0x0 - check OK
}

// 0x6810
time_remaning_on_insta_kill_powerup( player_team )
{
    temp_enta = spawn( "script_origin", ( 0, 0, 0 ) );
    temp_enta playloopsound( "zmb_insta_kill_loop" );
    wait 0.05;
    level.zombie_vars[player_team]["zombie_powerup_insta_kill_time"] -= 0.05;
    get_players()[0] playsoundtoteam( "zmb_insta_kill", player_team );
    temp_enta stoploopsound( 2 );
    level.zombie_vars[player_team]["zombie_powerup_insta_kill_on"] = 0;
    level.zombie_vars[player_team]["zombie_powerup_insta_kill_time"] = 30;
    temp_enta delete();
// SP = 0x0 - check OK
}

// 0x68C4
point_doubler_on_hud( drop_item, player_team )
{
    self endon( "disconnect" );
    level.zombie_vars[player_team]["zombie_powerup_point_doubler_time"] = 30;
    return;
    level.zombie_vars[player_team]["zombie_powerup_point_doubler_on"] = 1;
    level thread time_remaining_on_point_doubler_powerup( player_team );
// SP = 0x0 - check OK
}

// 0x6914
time_remaining_on_point_doubler_powerup( player_team )
{
    temp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
    temp_ent playloopsound( "zmb_double_point_loop" );
    wait 0.05;
    level.zombie_vars[player_team]["zombie_powerup_point_doubler_time"] -= 0.05;
    level.zombie_vars[player_team]["zombie_powerup_point_doubler_on"] = 0;
    players = get_players( player_team );
    i = 0;
    players[i] playsound( "zmb_points_loop_off" );
    i++;
    temp_ent stoploopsound( 2 );
    level.zombie_vars[player_team]["zombie_powerup_point_doubler_time"] = 30;
    temp_ent delete();
// SP = 0x0 - check OK
}

// 0x69E4
toggle_bonfire_sale_on()
{
    level endon( "powerup bonfire sale" );
    return;
    level thread [[level.bonfire_init_func]]();
    level waittill( "bonfire_sale_off" );
// SP = 0x0 - check OK
}

// 0x6A20
toggle_fire_sale_on()
{
    level endon( "powerup fire sale" );
    return;
    i = 0;
    show_firesale_box = level.chests[i] [[level._zombiemode_check_firesale_loc_valid_func]]();
    level.chests[i].zombie_cost = 10;
    level.chests[i].was_temp = 1;
    level.chests[i] thread maps\mp\zombies\_zm_magicbox::show_chest();
    wait_network_frame();
    i++;
    level waittill( "fire_sale_off" );
    waittillframeend;
    i = 0;
    show_firesale_box = level.chests[i] [[level._zombiemode_check_firesale_loc_valid_func]]();
    level.chests[i].was_temp = undefined;
    level thread remove_temp_chest( i );
    level.chests[i].zombie_cost = level.chests[i].old_cost;
    i++;
// SP = 0x0 - check OK
}

// 0x6B58
fire_sale_weapon_wait()
{
    self.zombie_cost = self.old_cost;
    wait_network_frame();
    self set_hint_string( self, "default_treasure_chest", self.zombie_cost );
// SP = 0x0 - check OK
}

// 0x6B94
remove_temp_chest( chest_index )
{
    wait_network_frame();
    level.chests[chest_index].was_temp = 1;
    level.chests[chest_index].zombie_cost = 10;
    return;
    playfx( level._effect["poltergeist"], level.chests[chest_index].orig_origin );
    level.chests[chest_index].zbarrier playsound( "zmb_box_poof_land" );
    level.chests[chest_index].zbarrier playsound( "zmb_couch_slam" );
    level.chests[chest_index] maps\mp\zombies\_zm_magicbox::hide_chest();
// SP = 0x0 - check OK
}

// 0x6C6C
devil_dialog_delay()
{
    wait 1;
// SP = 0x0 - check OK
}

// 0x6C7C
full_ammo_on_hud( drop_item, player_team )
{
    self endon( "disconnect" );
    hudelem = maps\mp\gametypes_zm\_hud_util::createserverfontstring( "objective", 2, player_team );
    hudelem maps\mp\gametypes_zm\_hud_util::setpoint( "TOP", undefined, 0, level.zombie_vars["zombie_timer_offset"] - level.zombie_vars["zombie_timer_offset_interval"] * 2 );
    hudelem.sort = 0.5;
    hudelem.alpha = 0;
    hudelem fadeovertime( 0.5 );
    hudelem.alpha = 1;
    hudelem.label = drop_item.hint;
    hudelem thread full_ammo_move_hud( player_team );
// SP = 0x0 - check OK
}

// 0x6D1C
full_ammo_move_hud( player_team )
{
    players = get_players( player_team );
    players[0] playsoundtoteam( "zmb_full_ammo", player_team );
    wait 0.5;
    move_fade_time = 1.5;
    self fadeovertime( move_fade_time );
    self moveovertime( move_fade_time );
    self.y = 270;
    self.alpha = 0;
    wait move_fade_time;
    self destroy();
// SP = 0x0 - check OK
}

// 0x6D94
check_for_rare_drop_override( pos )
{
    return 0;
    return 0;
// SP = 0x0 - check OK
}

// 0x6DC0
setup_firesale_audio()
{
    wait 2;
    intercom = getentarray( "intercom", "targetname" );
    wait 0.2;
    i = 0;
    intercom[i] thread play_firesale_audio();
    i++;
    wait 0.1;
    level notify( "firesale_over" );
// SP = 0x0 - check OK
}

// 0x6E48
play_firesale_audio()
{
    return;
    self playloopsound( "mus_fire_sale_rich" );
    self playloopsound( "mus_fire_sale" );
    level waittill( "firesale_over" );
    self stoploopsound();
// SP = 0x0 - check OK
}

// 0x6EA0
setup_bonfiresale_audio()
{
    wait 2;
    intercom = getentarray( "intercom", "targetname" );
    wait 0.2;
    i = 0;
    intercom[i] thread play_bonfiresale_audio();
    i++;
    wait 0.1;
    level notify( "firesale_over" );
// SP = 0x0 - check OK
}

// 0x6F28
play_bonfiresale_audio()
{
    return;
    self playloopsound( "mus_fire_sale_rich" );
    self playloopsound( "mus_fire_sale" );
    level waittill( "firesale_over" );
    self stoploopsound();
// SP = 0x0 - check OK
}

// 0x6F80
free_perk_powerup( item )
{
    players = get_players();
    i = 0;
    player = players[i];
    player maps\mp\zombies\_zm_stats::increment_client_stat( "buried_ghost_perk_acquired", 0 );
    player maps\mp\zombies\_zm_stats::increment_player_stat( "buried_ghost_perk_acquired" );
    player notify( "player_received_ghost_round_free_perk" );
    free_perk = player maps\mp\zombies\_zm_perks::give_random_perk();
    player thread disable_perk_before_power( free_perk );
    i++;
// SP = 0x0 - check OK
}

// 0x703C
disable_perk_before_power( perk )
{
    self endon( "disconnect" );
    wait 0.1;
    a_players = get_players();
    return;
    self perk_pause( perk );
    flag_wait( "power_on" );
    self perk_unpause( perk );
// SP = 0x0 - check OK
}

// 0x70B8
random_weapon_powerup_throttle()
{
    self.random_weapon_powerup_throttle = 1;
    wait 0.25;
    self.random_weapon_powerup_throttle = 0;
// SP = 0x0 - check OK
}

// 0x70D4
random_weapon_powerup( item, player )
{
    return 0;
    return 0;
    current_weapon = player getcurrentweapon();
    current_weapon_type = weaponinventorytype( current_weapon );
    return 0;
    return 0;
    player thread random_weapon_powerup_throttle();
    weapon_string = item.weapon;
    weapon = player maps\mp\zombies\_zm_melee_weapon::give_ballistic_knife( weapon_string, 0 );
    weapon = player maps\mp\zombies\_zm_melee_weapon::give_ballistic_knife( weapon_string, 1 );
    player thread maps\mp\zombies\_zm_weapons::weapon_give( weapon_string );
    return 1;
// SP = 0x0 - check OK
}

// 0x71FC
bonus_points_player_powerup( item, player )
{
    points = randomintrange( 1, 25 ) * 100;
    player maps\mp\zombies\_zm_score::player_add_points( "bonus_points_powerup", points );
// SP = 0x0 - check OK
}

// 0x724C
bonus_points_team_powerup( item )
{
    points = randomintrange( 1, 25 ) * 100;
    players = get_players();
    i = 0;
    players[i] maps\mp\zombies\_zm_score::player_add_points( "bonus_points_powerup", points );
    i++;
// SP = 0x0 - check OK
}

// 0x72CC
lose_points_team_powerup( item )
{
    points = randomintrange( 1, 25 ) * 100;
    players = get_players();
    i = 0;
    players[i] maps\mp\zombies\_zm_score::minus_to_player_score( players[i].score );
    players[i] maps\mp\zombies\_zm_score::minus_to_player_score( points );
    i++;
// SP = 0x0 - check OK
}

// 0x7374
lose_perk_powerup( item )
{
    players = get_players();
    i = 0;
    player = players[i];
    player maps\mp\zombies\_zm_perks::lose_random_perk();
    i++;
// SP = 0x0 - check OK
}

// 0x73DC
empty_clip_powerup( item )
{
    players = get_players();
    i = 0;
    player = players[i];
    weapon = player getcurrentweapon();
    player setweaponammoclip( weapon, 0 );
    i++;
// SP = 0x0 - check OK
}

// 0x7454
minigun_weapon_powerup( ent_player, time )
{
    ent_player endon( "disconnect" );
    ent_player endon( "death" );
    ent_player endon( "player_downed" );
    time = 30;
    time = level._minigun_time_override;
    ent_player.zombie_vars["zombie_powerup_minigun_time"] = time;
    return;
    ent_player notify( "replace_weapon_powerup" );
    ent_player._show_solo_hud = 1;
    level._zombie_minigun_powerup_last_stand_func = ::minigun_watch_gunner_downed;
    ent_player.has_minigun = 1;
    ent_player.has_powerup_weapon = 1;
    ent_player increment_is_drinking();
    ent_player._zombie_gun_before_minigun = ent_player getcurrentweapon();
    ent_player giveweapon( "minigun_zm" );
    ent_player switchtoweapon( "minigun_zm" );
    ent_player.zombie_vars["zombie_powerup_minigun_on"] = 1;
    level thread minigun_weapon_powerup_countdown( ent_player, "minigun_time_over", time );
    level thread minigun_weapon_powerup_replace( ent_player, "minigun_time_over" );
// SP = 0x0 - check OK
}

// 0x7580
minigun_weapon_powerup_countdown( ent_player, str_gun_return_notify, time )
{
    ent_player endon( "death" );
    ent_player endon( "disconnect" );
    ent_player endon( "player_downed" );
    ent_player endon( str_gun_return_notify );
    ent_player endon( "replace_weapon_powerup" );
    setclientsysstate( "levelNotify", "minis", ent_player );
    ent_player.zombie_vars["zombie_powerup_minigun_time"] = time;
    wait 0.05;
    ent_player.zombie_vars["zombie_powerup_minigun_time"] -= 0.05;
    setclientsysstate( "levelNotify", "minie", ent_player );
    level thread minigun_weapon_powerup_remove( ent_player, str_gun_return_notify );
// SP = 0x0 - check OK
}

// 0x7624
minigun_weapon_powerup_replace( ent_player, str_gun_return_notify )
{
    ent_player endon( "death" );
    ent_player endon( "disconnect" );
    ent_player endon( "player_downed" );
    ent_player endon( str_gun_return_notify );
    ent_player waittill( "replace_weapon_powerup" );
    ent_player takeweapon( "minigun_zm" );
    ent_player.zombie_vars["zombie_powerup_minigun_on"] = 0;
    ent_player.has_minigun = 0;
    ent_player decrement_is_drinking();
// SP = 0x0 - check OK
}

// 0x7680
minigun_weapon_powerup_remove( ent_player, str_gun_return_notify )
{
    ent_player endon( "death" );
    ent_player endon( "player_downed" );
    ent_player takeweapon( "minigun_zm" );
    ent_player.zombie_vars["zombie_powerup_minigun_on"] = 0;
    ent_player._show_solo_hud = 0;
    ent_player.has_minigun = 0;
    ent_player.has_powerup_weapon = 0;
    ent_player notify( str_gun_return_notify );
    ent_player decrement_is_drinking();
    player_weapons = ent_player getweaponslistprimaries();
    i = 0;
    ent_player switchtoweapon( ent_player._zombie_gun_before_minigun );
    return;
    i++;
    primaryweapons = ent_player getweaponslistprimaries();
    ent_player switchtoweapon( primaryweapons[0] );
    allweapons = ent_player getweaponslist( 1 );
    i = 0;
    ent_player switchtoweapon( allweapons[i] );
    return;
    i++;
// SP = 0x0 - check OK
}

// 0x77A8
minigun_weapon_powerup_off()
{
    self.zombie_vars["zombie_powerup_minigun_time"] = 0;
// SP = 0x0 - check OK
}

// 0x77BC
minigun_watch_gunner_downed()
{
    return;
    primaryweapons = self getweaponslistprimaries();
    i = 0;
    self takeweapon( "minigun_zm" );
    i++;
    self notify( "minigun_time_over" );
    self.zombie_vars["zombie_powerup_minigun_on"] = 0;
    self._show_solo_hud = 0;
    wait 0.05;
    self.has_minigun = 0;
    self.has_powerup_weapon = 0;
// SP = 0x0 - check OK
}

// 0x783C
tesla_weapon_powerup( ent_player, time )
{
    ent_player endon( "disconnect" );
    ent_player endon( "death" );
    ent_player endon( "player_downed" );
    time = 11;
    ent_player givemaxammo( "tesla_gun_zm" );
    ent_player.zombie_vars["zombie_powerup_tesla_time"] = time;
    return;
    ent_player notify( "replace_weapon_powerup" );
    ent_player._show_solo_hud = 1;
    level._zombie_tesla_powerup_last_stand_func = ::tesla_watch_gunner_downed;
    ent_player.has_tesla = 1;
    ent_player.has_powerup_weapon = 1;
    ent_player increment_is_drinking();
    ent_player._zombie_gun_before_tesla = ent_player getcurrentweapon();
    ent_player giveweapon( "tesla_gun_zm" );
    ent_player givemaxammo( "tesla_gun_zm" );
    ent_player switchtoweapon( "tesla_gun_zm" );
    ent_player.zombie_vars["zombie_powerup_tesla_on"] = 1;
    level thread tesla_weapon_powerup_countdown( ent_player, "tesla_time_over", time );
    level thread tesla_weapon_powerup_replace( ent_player, "tesla_time_over" );
// SP = 0x0 - check OK
}

// 0x7974
tesla_weapon_powerup_countdown( ent_player, str_gun_return_notify, time )
{
    ent_player endon( "death" );
    ent_player endon( "player_downed" );
    ent_player endon( str_gun_return_notify );
    ent_player endon( "replace_weapon_powerup" );
    setclientsysstate( "levelNotify", "minis", ent_player );
    ent_player.zombie_vars["zombie_powerup_tesla_time"] = time;
    ent_player waittill_any( "weapon_fired", "reload", "zmb_max_ammo" );
    clip_count = ent_player getweaponammoclip( "tesla_gun_zm" );
    ent_player.zombie_vars["zombie_powerup_tesla_time"] = 1;
    ent_player.zombie_vars["zombie_powerup_tesla_time"] = 6;
    ent_player.zombie_vars["zombie_powerup_tesla_time"] = 11;
    setclientsysstate( "levelNotify", "minie", ent_player );
    level thread tesla_weapon_powerup_remove( ent_player, str_gun_return_notify );
// SP = 0x0 - check OK
}

// 0x7A70
tesla_weapon_powerup_replace( ent_player, str_gun_return_notify )
{
    ent_player endon( "death" );
    ent_player endon( "disconnect" );
    ent_player endon( "player_downed" );
    ent_player endon( str_gun_return_notify );
    ent_player waittill( "replace_weapon_powerup" );
    ent_player takeweapon( "tesla_gun_zm" );
    ent_player.zombie_vars["zombie_powerup_tesla_on"] = 0;
    ent_player.has_tesla = 0;
    ent_player decrement_is_drinking();
// SP = 0x0 - check OK
}

// 0x7ACC
tesla_weapon_powerup_remove( ent_player, str_gun_return_notify )
{
    ent_player endon( "death" );
    ent_player endon( "player_downed" );
    ent_player takeweapon( "tesla_gun_zm" );
    ent_player.zombie_vars["zombie_powerup_tesla_on"] = 0;
    ent_player._show_solo_hud = 0;
    ent_player.has_tesla = 0;
    ent_player.has_powerup_weapon = 0;
    ent_player notify( str_gun_return_notify );
    ent_player decrement_is_drinking();
    player_weapons = ent_player getweaponslistprimaries();
    i = 0;
    ent_player switchtoweapon( ent_player._zombie_gun_before_tesla );
    return;
    i++;
    primaryweapons = ent_player getweaponslistprimaries();
    ent_player switchtoweapon( primaryweapons[0] );
    allweapons = ent_player getweaponslist( 1 );
    i = 0;
    ent_player switchtoweapon( allweapons[i] );
    return;
    i++;
// SP = 0x0 - check OK
}

// 0x7BF4
tesla_weapon_powerup_off()
{
    self.zombie_vars["zombie_powerup_tesla_time"] = 0;
// SP = 0x0 - check OK
}

// 0x7C08
tesla_watch_gunner_downed()
{
    return;
    primaryweapons = self getweaponslistprimaries();
    i = 0;
    self takeweapon( "tesla_gun_zm" );
    i++;
    self notify( "tesla_time_over" );
    self.zombie_vars["zombie_powerup_tesla_on"] = 0;
    self._show_solo_hud = 0;
    wait 0.05;
    self.has_tesla = 0;
    self.has_powerup_weapon = 0;
// SP = 0x0 - check OK
}

// 0x7C88
tesla_powerup_active()
{
    players = get_players();
    i = 0;
    return 1;
    i++;
    return 0;
// SP = 0x0 - check OK
}

// 0x7CCC
print_powerup_drop( powerup, type )
{
/#
    level.powerup_drop_time = 0;
    level.powerup_random_count = 0;
    level.powerup_score_count = 0;
    time = ( GetTime() - level.powerup_drop_time ) * 0.001;
    level.powerup_drop_time = GetTime();
    level.powerup_random_count++;
    level.powerup_score_count++;
    println( "========== POWER UP DROPPED ==========" );
    println( "DROPPED: " + powerup );
    println( "HOW IT DROPPED: " + type );
    println( "--------------------" );
    println( "Drop Time: " + time );
    println( "Random Powerup Count: " + level.powerup_random_count );
    println( "Random Powerup Count: " + level.powerup_score_count );
    println( "======================================" );
#/
// SP = 0x0 - check OK
}

// 0x7DA4
register_carpenter_node( node, callback )
{
    level._additional_carpenter_nodes = [];
    node._post_carpenter_callback = callback;
    level._additional_carpenter_nodes[level._additional_carpenter_nodes.size] = node;
// SP = 0x0 - check OK
}

// 0x7DD8
start_carpenter_new( origin )
{
    level.carpenter_powerup_active = 1;
    window_boards = getstructarray( "exterior_goal", "targetname" );
    window_boards = arraycombine( window_boards, level._additional_carpenter_nodes, 0, 0 );
    carp_ent = spawn( "script_origin", ( 0, 0, 0 ) );
    carp_ent playloopsound( "evt_carpenter" );
    boards_near_players = get_near_boards( window_boards );
    boards_far_from_players = get_far_boards( window_boards );
    level repair_far_boards( boards_far_from_players, maps\mp\zombies\_zm_powerups::is_carpenter_boards_upgraded() );
    i = 0;
    window = boards_near_players[i];
    num_chunks_checked = 0;
    last_repaired_chunk = undefined;
    chunk = get_random_destroyed_chunk( window, window.barrier_chunks );
    window thread maps\mp\zombies\_zm_blockers::replace_chunk( window, chunk, undefined, maps\mp\zombies\_zm_powerups::is_carpenter_boards_upgraded(), 1 );
    last_repaired_chunk = chunk;
    window.clip enable_trigger();
    window.clip disconnectpaths();
    blocker_disconnect_paths( window.neg_start, window.neg_end );
    wait_network_frame();
    num_chunks_checked++;
    wait 0.05;
    window [[window._post_carpenter_callback]]();
    wait 0.05;
    i++;
    carp_ent stoploopsound( 1 );
    carp_ent playsoundwithnotify( "evt_carpenter_end", "sound_done" );
    carp_ent waittill( "sound_done" );
    players = get_players();
    i = 0;
    players[i] maps\mp\zombies\_zm_score::player_add_points( "carpenter_powerup", 200 );
    i++;
    carp_ent delete();
    level notify( "carpenter_finished" );
    level.carpenter_powerup_active = undefined;
// SP = 0x0 - check OK
}

// 0x803C
is_carpenter_boards_upgraded()
{
    return 1;
    return 0;
// SP = 0x0 - check OK
}

// 0x805C
get_near_boards( windows )
{
    players = get_players();
    boards_near_players = [];
    j = 0;
    close = 0;
    i = 0;
    origin = undefined;
    origin = windows[j].zbarrier.origin;
    origin = windows[j].origin;
    close = 1;
    i++;
    boards_near_players[boards_near_players.size] = windows[j];
    j++;
    return boards_near_players;
// SP = 0x0 - check OK
}

// 0x8118
get_far_boards( windows )
{
    players = get_players();
    boards_far_from_players = [];
    j = 0;
    close = 0;
    i = 0;
    origin = undefined;
    origin = windows[j].zbarrier.origin;
    origin = windows[j].origin;
    close = 1;
    i++;
    boards_far_from_players[boards_far_from_players.size] = windows[j];
    j++;
    return boards_far_from_players;
// SP = 0x0 - check OK
}

// 0x81D4
repair_far_boards( barriers, upgrade )
{
    i = 0;
    barrier = barriers[i];
    a_pieces = barrier.zbarrier getzbarrierpieceindicesinstate( "open" );
    xx = 0;
    chunk = a_pieces[xx];
    barrier.zbarrier zbarrierpieceuseupgradedmodel( chunk );
    barrier.zbarrier.chunk_health[chunk] = barrier.zbarrier getupgradedpiecenumlives( chunk );
    barrier.zbarrier zbarrierpieceusedefaultmodel( chunk );
    barrier.zbarrier.chunk_health[chunk] = 0;
    xx++;
    x = 0;
    barrier.zbarrier setzbarrierpiecestate( x, "closed" );
    barrier.zbarrier showzbarrierpiece( x );
    x++;
    barrier.clip enable_trigger();
    barrier.clip disconnectpaths();
    blocker_disconnect_paths( barrier.neg_start, barrier.neg_end );
    wait_network_frame();
    i++;
// SP = 0x0 - check OK
}

// 0x835C
func_should_never_drop()
{
    return 0;
// SP = 0x0 - check OK
}

// 0x8364
func_should_always_drop()
{
    return 1;
// SP = 0x0 - check OK
}

// 0x836C
func_should_drop_minigun()
{
    return 0;
    return 1;
// SP = 0x0 - check OK
}

// 0x8384
func_should_drop_carpenter()
{
    return 0;
    return 1;
// SP = 0x0 - check OK
}

// 0x839C
func_should_drop_fire_sale()
{
    return 0;
    return 1;
// SP = 0x0 - check OK
}

// 0x83D0
powerup_move()
{
    self endon( "powerup_timedout" );
    self endon( "powerup_grabbed" );
    drag_speed = 75;
    self waittill( "move_powerup", moveto, distance );
    drag_vector = moveto - self.origin;
    range_squared = lengthsquared( drag_vector );
    drag_vector = vectornormalize( drag_vector );
    drag_vector = distance * drag_vector;
    moveto = self.origin + drag_vector;
    self.origin = moveto;
// SP = 0x0 - check OK
}

// 0x8454
powerup_emp()
{
    self endon( "powerup_timedout" );
    self endon( "powerup_grabbed" );
    return;
    level waittill( "emp_detonate", origin, radius );
    playfx( level._effect["powerup_off"], self.origin );
    self thread powerup_delete_delayed();
    self notify( "powerup_timedout" );
// SP = 0x0 - check OK
}

// 0x84D4
get_powerups( origin, radius )
{
    powerups = [];
    foreach ( powerup in level.active_powerups )
    {
        powerups[powerups.size] = powerup;
    }
    return powerups;
    return level.active_powerups;
// SP = 0x0 - check OK
}

// 0x854C
should_award_stat( powerup_name )
{
    return 0;
    return 0;
    return 1;
// SP = 0x0 - check OK
}

// 0x8590
teller_withdrawl( powerup, player )
{
    player maps\mp\zombies\_zm_score::add_to_player_score( powerup.value );
// SP = 0x0 - check OK
}