_zm_magicbox.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\aat_shared;
#using scripts\shared\array_shared;
#using scripts\shared\clientfield_shared;
#using scripts\shared\demo_shared;
#using scripts\shared\flag_shared;
#using scripts\shared\system_shared;
#using scripts\shared\util_shared;
 
#insert scripts\shared\shared.gsh;
#insert scripts\shared\version.gsh;
 
#using scripts\zm\_bb;
#using scripts\zm\_zm_audio;
#using scripts\zm\_zm_bgb;
#using scripts\zm\_zm_daily_challenges;
#using scripts\zm\_zm_equipment;
#using scripts\zm\_zm_pack_a_punch_util;
#using scripts\zm\_zm_pers_upgrades_functions;
#using scripts\zm\_zm_score;
#using scripts\zm\_zm_stats;
#using scripts\zm\_zm_unitrigger;
#using scripts\zm\_zm_utility;
#using scripts\zm\_zm_weapons;
 
#insert scripts\zm\_zm_perks.gsh;
#insert scripts\zm\_zm_utility.gsh;
 
#precache( "fx", "zombie/fx_weapon_box_marker_zmb" );
#precache( "fx", "zombie/fx_weapon_box_marker_fl_zmb" );
#precache( "fx", "zombie/fx_barrier_buy_zmb" );
 
// level.custom_magic_box_timer_til_despawn == Custom box movement
// level.custom_magic_box_do_weapon_rise == Custom weapon rise
// level.custom_magic_box_weapon_wait == Custom weapon wait until being taken back into the box
// level.custom_pandora_show_func == Custom map marker
// level.custom_magic_box_fx == Custom FX when box opens and closes
// level.custom_treasure_chest_glowfx == Custom Chest FX
// level.custom_magicbox_float_height == (int) custom float height
//
// If custom_pandora_show_func is defined, then a custom magicbox_host_migration() must be made in the new gsc
 
#namespace zm_magicbox;
 
#precache( "triggerstring", "ZOMBIE_TRADE_EQUIP_FILL" );
#precache( "triggerstring", "ZOMBIE_TRADE_WEAPON_FILL" );
 
 
‪REGISTER_SYSTEM_EX( "zm_magicbox", &‪__init__, &‪__main__, undefined )
 
function ‪__init__()
{
    level.start_chest_name = "start_chest";
 
    level._effect["lght_marker"]                                        = "zombie/fx_weapon_box_marker_zmb";
    level._effect["lght_marker_flare"]                          = "zombie/fx_weapon_box_marker_fl_zmb";
    level._effect["poltergeist"]                                        = "zombie/fx_barrier_buy_zmb";
 
    ‪clientfield::register( "zbarrier", "magicbox_open_glow", ‪VERSION_SHIP, 1, "int" );
    ‪clientfield::register( "zbarrier", "magicbox_closed_glow", ‪VERSION_SHIP, 1, "int" );
    
    ‪clientfield::register( "zbarrier", "zbarrier_show_sounds", ‪VERSION_SHIP, 1, "counter");
    ‪clientfield::register( "zbarrier", "zbarrier_leave_sounds", ‪VERSION_SHIP, 1, "counter");    
 
    ‪clientfield::register( "scriptmover", "force_stream", ‪VERSION_TU7, 1, "int" );
    
    level thread ‪magicbox_host_migration();
}
 
function ‪__main__()
{
    // Set values that may be overwritten by level specific scripts
    if( !IsDefined( level.chest_joker_model ) )
    {
        level.chest_joker_model = "p7_zm_teddybear";
    }
    
    if( !IsDefined( level.magic_box_zbarrier_state_func ) )
    {
        level.magic_box_zbarrier_state_func = &‪process_magic_box_zbarrier_state;
    }
    
    if (!IsDefined(level.magic_box_check_equipment))
        level.magic_box_check_equipment =  &‪default_magic_box_check_equipment;  
 
    wait(0.05);//wait for initialization stage to end so we can toggle client fields
 
    if ( ‪zm_utility::is_Classic() )
    {
        level.chests = ‪struct::get_array( "treasure_chest_use", "targetname" );
        ‪treasure_chest_init( level.start_chest_name );
    }
}
 
// for the random weapon chest
//
//  The chests need to be setup as follows:
//      trigger_use - for the chest
//          targets the lid
//      lid - script_model.  Flips open to reveal the items
//          targets the script origin inside the box
//      script_origin - inside the box, used for spawning the weapons
//          targets the box
//      box - script_model of the outer casing of the chest
//      rubble - pieces that show when the box isn't there
//          script_noteworthy should be the same as the use_trigger + "_rubble"
//
function ‪treasure_chest_init( start_chest_name )
{
    level ‪flag::init("moving_chest_enabled");
    level ‪flag::init("moving_chest_now");
    level ‪flag::init("chest_has_been_used");
    
    level.chest_moves = 0;
    level.chest_level = 0;  // Level 0 = normal chest, 1 = upgraded chest
    //level.chests = GetEntArray( "treasure_chest_use", "targetname" );
 
    //level.chests = struct::get_array( "treasure_chest_use", "targetname" );       
 
    if( level.chests.size==0 )
        return;
    
    for (i=0; i<level.chests.size; i++ )
    {
        level.chests[i].box_hacks = [];
        
        level.chests[i].orig_origin = level.chests[i].origin;
        level.chests[i] ‪get_chest_pieces();
 
        if ( isDefined( level.chests[i].zombie_cost ) )
        {
            level.chests[i].old_cost = level.chests[i].zombie_cost;
        }
        else
        {
            // default chest cost
            level.chests[i].old_cost = 950;
        }
    }
 
    if(!level.enable_magic)
    {
        foreach(chest in level.chests)
        {
            chest ‪hide_chest();
        }
        return;
    }
    
    level.chest_accessed = 0;
 
    if (level.chests.size > 1)
    {
        level ‪flag::set("moving_chest_enabled");
    
        level.chests = array::randomize(level.chests);
 
        //determine magic box starting location at random or normal
        //init_starting_chest_location();
    }
    else
    {
        level.chest_index = 0;
        level.chests[0].no_fly_away = true;
    }
    
    //determine magic box starting location at random or normal
    ‪init_starting_chest_location( start_chest_name );
 
    array::thread_all( level.chests, &‪treasure_chest_think );
}
 
function ‪init_starting_chest_location( start_chest_name )
{
    level.chest_index = 0;
    start_chest_found = false;
    
    if( level.chests.size==1 )
    {
        //Only 1 chest in the map
        start_chest_found = true;
        
        if(isdefined(level.chests[level.chest_index].zbarrier))
        {
            level.chests[level.chest_index].zbarrier ‪set_magic_box_zbarrier_state("initial");
            level.chests[level.chest_index] thread ‪box_encounter_vo();
        }
    }
    else
    {
        for( i = 0; i < level.chests.size; i++ )
        {
            if( isdefined( level.random_pandora_box_start ) && level.random_pandora_box_start == true )
            {
                //start_exclude is a KVP, just need to add start_exclude 1 to the box script struct to exclude it from the initial random box selection
                if ( start_chest_found || (IsDefined( level.chests[i].start_exclude ) && level.chests[i].start_exclude == 1) )
                {
                    level.chests[i] ‪hide_chest();   
                }
                else
                {
                    level.chest_index = i;
                    level.chests[level.chest_index].hidden = false;
                    if(isdefined(level.chests[level.chest_index].zbarrier))
                    {
                        level.chests[level.chest_index].zbarrier ‪set_magic_box_zbarrier_state("initial");
                        level.chests[level.chest_index] thread ‪box_encounter_vo();
                    }                   
                    start_chest_found = true;
                }
 
            }
            else
            {
                // Semi-random implementation (not completely random).  The list is randomized
                //  prior to getting here.
                // Pick from any box marked as the "start_chest"
                if ( start_chest_found || !IsDefined(level.chests[i].script_noteworthy ) || ( !IsSubStr( level.chests[i].script_noteworthy, start_chest_name ) ) )
                {
                    level.chests[i] ‪hide_chest();   
                }
                else
                {
                    level.chest_index = i;
                    level.chests[level.chest_index].hidden = false;
                    if(isdefined(level.chests[level.chest_index].zbarrier))
                    {
                        level.chests[level.chest_index].zbarrier ‪set_magic_box_zbarrier_state("initial");
                        level.chests[level.chest_index] thread ‪box_encounter_vo();
                    }                   
                    start_chest_found = true;
                }
            }
        }
    }
 
    // Show the beacon
    if( !isDefined( level.pandora_show_func ) )
    {
        if ( isdefined( level.custom_pandora_show_func ) )
        {
            level.pandora_show_func = level.custom_pandora_show_func;
        }
        else
        {
            level.pandora_show_func = &‪default_pandora_show_func;
        }
    }
 
    level.chests[level.chest_index] thread [[ level.pandora_show_func ]]();
}
 
function ‪set_treasure_chest_cost( cost )
{
    level.zombie_treasure_chest_cost = cost;
}
 
//
//  Save off the references to all of the chest pieces
//      self = trigger
function ‪get_chest_pieces()
{
    //self.chest_lid        = GetEnt(self.target,               "targetname");
    //self.chest_origin = GetEnt(self.chest_lid.target,     "targetname");
 
//  println( "***** LOOKING FOR:  " + self.chest_origin.target );
 
    self.chest_box = GetEnt( self.script_noteworthy + "_zbarrier", "script_noteworthy" ); 
 
    //TODO fix temp hax to separate multiple instances
    self.chest_rubble   = [];
    rubble = GetEntArray( self.script_noteworthy + "_rubble", "script_noteworthy" );
    for ( i=0; i<rubble.size; i++ )
    {
        if ( DistanceSquared( self.origin, rubble[i].origin ) < 10000 )
        {
            self.chest_rubble[ self.chest_rubble.size ] = rubble[i];
        }
    }
    
    self.zbarrier = GetEnt(self.script_noteworthy + "_zbarrier", "script_noteworthy");
    if(isdefined(self.zbarrier))
    {
        self.zbarrier ZBarrierPieceUseBoxRiseLogic(3);
        self.zbarrier ZBarrierPieceUseBoxRiseLogic(4);
    }
    
    self.unitrigger_stub = spawnstruct();
    self.unitrigger_stub.origin = self.origin + (anglestoright(self.angles) * -22.5);
    self.unitrigger_stub.angles = self.angles;
    self.unitrigger_stub.script_unitrigger_type = "unitrigger_box_use";
    self.unitrigger_stub.script_width = 104;
    self.unitrigger_stub.script_height = 50;
    self.unitrigger_stub.script_length = 45;
    self.unitrigger_stub.trigger_target = self;
    ‪zm_unitrigger::unitrigger_force_per_player_triggers(self.unitrigger_stub, true);
    self.unitrigger_stub.prompt_and_visibility_func = &‪boxtrigger_update_prompt;
    self.zbarrier.owner = self;
    
}
 
function ‪boxtrigger_update_prompt( player )
{
    can_use = self ‪boxstub_update_prompt( player );
    if(isdefined(self.hint_string))
    {
        if (IsDefined(self.hint_parm1))
            self SetHintString( self.hint_string, self.hint_parm1 );
        else
            self SetHintString( self.hint_string );
    }
    return can_use;
}
 
function ‪boxstub_update_prompt( player )
{
    //self setCursorHint( "HINT_NOICON" );
 
    if (!self ‪trigger_visible_to_player( player ))
        return false;
    
    if( isdefined( level.func_magicbox_update_prompt_use_override ) )
    {
        if( [[ level.func_magicbox_update_prompt_use_override ]]() )
        {
            return false;   
        }
    }
 
    self.hint_parm1 = undefined;
    if(‪IS_TRUE(self.stub.trigger_target.grab_weapon_hint))
    {
        cursor_hint = "HINT_WEAPON";
        cursor_hint_weapon = self.stub.trigger_target.grab_weapon;
        self setCursorHint( cursor_hint, cursor_hint_weapon ); 
        if (IsDefined(level.magic_box_check_equipment) && [[level.magic_box_check_equipment]]( cursor_hint_weapon ) )
            self.hint_string = &"ZOMBIE_TRADE_EQUIP_FILL"; 
        else
            self.hint_string = &"ZOMBIE_TRADE_WEAPON_FILL"; 
    }
    else
    {
        self setCursorHint( "HINT_NOICON" );
        self.hint_parm1 = self.stub.trigger_target.zombie_cost; 
        self.hint_string = ‪zm_utility::get_hint_string( self, "default_treasure_chest" );
    }
    return true;
} 
 
function ‪default_magic_box_check_equipment( weapon )
{
    return ‪zm_utility::is_offhand_weapon( weapon );
}
 
 
function ‪trigger_visible_to_player(player)
{
    self SetInvisibleToPlayer(player);
 
    visible = true; 
    
    if(IsDefined(self.stub.trigger_target.chest_user) && !IsDefined(self.stub.trigger_target.box_rerespun))
    {
        if( player != self.stub.trigger_target.chest_user || ‪zm_utility::is_placeable_mine( self.stub.trigger_target.chest_user GetCurrentWeapon() ) || self.stub.trigger_target.chest_user ‪zm_equipment::hacker_active())
        {
            visible = false;
        }
    }   
    else
    {
        if( !player ‪can_buy_weapon() )
        {
            visible = false;
        }
    }
    
    // PORTIZ 7/20/16: players could start spinning a weapon, acquire Disorderly Combat from a nearby BGB machine, and then take the weapon.
    // separating out Disorderly Combat check since we never want a player to interact with the box while it's enabled
    if ( player ‪bgb::is_enabled( "zm_bgb_disorderly_combat" ) )
    {
        visible = false;
    }
    
    if(!visible)
    {
        return false;
    }
    
    self SetVisibleToPlayer(player);
    return true;
}
 
function ‪magicbox_unitrigger_think()
{
    self endon("kill_trigger");
 
    while ( 1 )
    {
        self waittill( "trigger", player );
        self.stub.trigger_target notify("trigger", player);
    }
}
 
function ‪play_crazi_sound()
{
    self playlocalsound( level.zmb_laugh_alias );
}
 
//
//  Show the chest pieces
//      self = chest use_trigger
//
function ‪show_chest()
{
    self.zbarrier ‪set_magic_box_zbarrier_state("arriving");
    self.zbarrier ‪util::waittill_any_timeout( 5, "arrived");
    
    self thread [[ level.pandora_show_func ]]();
 
    self.zbarrier ‪clientfield::set( "magicbox_closed_glow", true );
 
    //self TriggerEnable( true );
    thread ‪zm_unitrigger::register_static_unitrigger(self.unitrigger_stub, &‪magicbox_unitrigger_think);
 
    self.zbarrier ‪clientfield::increment("zbarrier_show_sounds" );
 
    self.hidden = false;
 
    if(IsDefined(self.box_hacks["summon_box"]))
    {
        self [[self.box_hacks["summon_box"]]](false);
    }
    
}
 
function ‪hide_chest(doBoxLeave)
{
    //self TriggerEnable( false );
    if(isDefined(self.unitrigger_stub))
    {
        thread ‪zm_unitrigger::unregister_unitrigger(self.unitrigger_stub);
    }
    if ( IsDefined( self.pandora_light ) )
    {
        self.pandora_light delete();
    }
 
    self.zbarrier ‪clientfield::set( "magicbox_closed_glow", false );
    
    self.hidden = true;
    
    if(isDefined(self.box_hacks) && IsDefined(self.box_hacks["summon_box"]))
    {
        self [[self.box_hacks["summon_box"]]](true);
    }
    
    if(isdefined(self.zbarrier))
    {
        if(‪IS_TRUE(doBoxLeave))
        {
            self.zbarrier ‪clientfield::increment("zbarrier_leave_sounds" );
            
            level thread ‪zm_audio::sndAnnouncerPlayVox("boxmove");
 
            self.zbarrier thread ‪magic_box_zbarrier_leave();
            self.zbarrier waittill("left");
            
            playfx( level._effect["poltergeist"], self.zbarrier.origin, AnglesToUp( self.zbarrier.angles ), AnglesToForward( self.zbarrier.angles ) );  // effect has X facing up, Z facing forward
    
            //TUEY - Play the 'disappear' sound
            playsoundatposition ("zmb_box_poof", self.zbarrier.origin);
        }
        else
        {
            self.zbarrier thread ‪set_magic_box_zbarrier_state("away");          
        }
    }   
}
 
function ‪magic_box_zbarrier_leave()
{
    self ‪set_magic_box_zbarrier_state("leaving");
    self waittill("left");
    self ‪set_magic_box_zbarrier_state("away");
}
 
function ‪default_pandora_fx_func( )
{
    self endon( "death" );
 
    self.pandora_light = ‪Spawn( "script_model", self.zbarrier.origin );
    self.pandora_light.angles = self.zbarrier.angles + (-90, 0, -90);
    //  level.pandora_light.angles = (-90, anchorTarget.angles[1] + 180, 0);
    self.pandora_light SetModel( "tag_origin" );
    if(!‪IS_TRUE(level._box_initialized))
    {
        level ‪flag::wait_till("start_zombie_round_logic");
        level._box_initialized = true;
    }
    wait(1);
    if ( IsDefined( self ) && IsDefined( self.pandora_light ) )
    {
        playfxontag(level._effect["lght_marker"], self.pandora_light, "tag_origin");
    }
 
}
 
 
//
//  Show a column of light
//
function ‪default_pandora_show_func( anchor, anchorTarget, pieces )
{
    
    if ( !IsDefined(self.pandora_light) )
    {
        // Show the column light effect on the box
        if( !IsDefined( level.pandora_fx_func ) )
        {
            level.pandora_fx_func = &‪default_pandora_fx_func;
        }
        self thread [[ level.pandora_fx_func ]]();
    }
 
    playfx( level._effect["lght_marker_flare"],self.pandora_light.origin );
    
    //Add this location to the map
    //Objective_Add( 0, "active", "Mystery Box", self.chest_lid.origin, "minimap_icon_mystery_box" );
}
 
function ‪unregister_unitrigger_on_kill_think()
{
    self notify( "unregister_unitrigger_on_kill_think" );
    self endon( "unregister_unitrigger_on_kill_think" );
    
    self waittill("kill_chest_think");
    thread ‪zm_unitrigger::unregister_unitrigger(self.unitrigger_stub);
    
}
 
function ‪treasure_chest_think()
{
    self endon("kill_chest_think");
    // waittill someuses uses this
    user = undefined;
    user_cost = undefined;
    self.box_rerespun = undefined;
    self.weapon_out = undefined;
    
    self thread ‪unregister_unitrigger_on_kill_think();
    
    while( 1 )
    {
        if(!IsDefined(self.forced_user))
        {
            self waittill( "trigger", user ); 
            if (user == level)
                continue;
        }
        else
        {
            user = self.forced_user;
        }
        
        if( user ‪zm_utility::in_revive_trigger() )
        {
            wait( 0.1 );
            continue;
        }
        
        if( ‪IS_DRINKING(user.is_drinking) )
        {
            wait( 0.1 );
            continue;
        }
 
        if ( ‪IS_TRUE( self.disabled ) )
        {
            wait( 0.1 );
            continue;
        }
 
        if( user GetCurrentWeapon() == level.weaponNone )
        {
            wait( 0.1 );
            continue;
        }
 
        // firesale is in the process of removing this box
        if ( ‪IS_TRUE( self.being_removed ) )
        {
            wait( 0.1 );
            continue;
        }
 
        reduced_cost = undefined;
        
        // Make sure the user is a player, and that they can afford it
        if( IsDefined(self.auto_open) && ‪zm_utility::is_player_valid( user ) )
        {
            if(!IsDefined(self.no_charge))
            {
                user  ‪zm_score::minus_to_player_score( self.zombie_cost );
                user_cost = self.zombie_cost; 
            }
            else
            {
                user_cost = 0;
            }           
            
            self.chest_user = user;
            break;
        }
        // Do we have enough money to use the box?
        else if( ‪zm_utility::is_player_valid( user ) && user ‪zm_score::can_player_purchase( self.zombie_cost ) )
        {
            user  ‪zm_score::minus_to_player_score( self.zombie_cost );
            user_cost = self.zombie_cost; 
            self.chest_user = user;
            break; 
        }
        // Has the box cost been reduced?
        else if( IsDefined(reduced_cost) && ( user ‪zm_score::can_player_purchase( reduced_cost ) ) )
        {
            user  ‪zm_score::minus_to_player_score( reduced_cost );
            user_cost = reduced_cost;
            self.chest_user = user;
            break; 
        }
        // Can't afford the box purchase
        else if ( !user ‪zm_score::can_player_purchase( self.zombie_cost ) )
        {
            ‪zm_utility::play_sound_at_pos( "no_purchase", self.origin );
            user  ‪zm_audio::create_and_play_dialog( "general", "outofmoney" );
            continue;   
        }
 
        ‪WAIT_SERVER_FRAME; 
    }
 
    level ‪flag::set("chest_has_been_used");
    
    //stat tracking
    ‪demo::bookmark( "zm_player_use_magicbox", gettime(), user );
    user ‪zm_stats::increment_client_stat( "use_magicbox" );
    user ‪zm_stats::increment_player_stat( "use_magicbox" );
    user ‪zm_stats::increment_challenge_stat( "SURVIVALIST_BUY_MAGIC_BOX" );
    user ‪zm_daily_challenges::increment_magic_box();
    
    if ( isDefined( level._magic_box_used_VO ) )
    {
        user thread [[ level._magic_box_used_VO ]]();
    }
    
    self thread ‪watch_for_emp_close();
    
    self._box_open = true;
    self._box_opened_by_fire_sale = false;
    if ( ‪IS_TRUE( level.zombie_vars["zombie_powerup_fire_sale_on"] ) && !IsDefined(self.auto_open) && self [[level._zombiemode_check_firesale_loc_valid_func]]())
    {
        self._box_opened_by_fire_sale = true;
    }
 
    //open the lid
    if(isdefined(self.chest_lid))
    {
        self.chest_lid thread ‪treasure_chest_lid_open();
    }
 
    if(isdefined(self.zbarrier))
    {
        ‪zm_utility::play_sound_at_pos( "open_chest", self.origin );
        ‪zm_utility::play_sound_at_pos( "music_chest", self.origin );
        self.zbarrier ‪set_magic_box_zbarrier_state("open");
    }
    
    // SRS 9/3/2008: added to help other functions know if we timed out on grabbing the item
    self.timedOut = false;
 
    // mario kart style weapon spawning
    self.weapon_out = true;
    self.zbarrier thread ‪treasure_chest_weapon_spawn( self, user ); 
 
    // the glowfx
    if ( isdefined(level.custom_treasure_chest_glowfx ) )
    {
        self.zbarrier thread [[level.custom_treasure_chest_glowfx]]();
    }
    else
    {
        self.zbarrier thread ‪treasure_chest_glowfx();
    }
 
    // take away usability until model is done randomizing
    //self TriggerEnable( false ); 
    thread ‪zm_unitrigger::unregister_unitrigger(self.unitrigger_stub);
 
    self.zbarrier ‪util::waittill_any( "randomization_done", "box_hacked_respin" ); 
 
    // refund money from teddy.
    if ( level ‪flag::get( "moving_chest_now" ) && !self._box_opened_by_fire_sale && isdefined( user_cost ) )
    {
        user ‪zm_score::add_to_player_score( user_cost, false, "magicbox_bear" );
    }
 
    if ( level ‪flag::get( "moving_chest_now" ) && !level.zombie_vars[ "zombie_powerup_fire_sale_on" ] && !self._box_opened_by_fire_sale )
    {
        //CA AUDIO: 01/12/10 - Changed dialog to use correct function
        //self.chest_user zm_audio::create_and_play_dialog( "general", "box_move" );
        self thread ‪treasure_chest_move( self.chest_user );
    }
    else
    {
        if( !‪IS_TRUE( self.unbearable_respin ) )
        {
            // Let the player grab the weapon and re-enable the box //
            self.grab_weapon_hint = true;
            self.grab_weapon = self.zbarrier.weapon;
            self.chest_user = user;
            weaponIdx = undefined;
            if (isDefined(self.grab_weapon))
            {
                weaponIdx = MatchRecordGetWeaponIndex(self.grab_weapon);
            }
            
            if ( isDefined(weaponIdx) )
            {
                user RecordMapEvent(‪ZM_MAP_EVENT_MAGIC_BOX_OFFERED, GetTime(), user.origin,  level.round_number, weaponIdx);    
            }
            
            // Limit its visibility to the player who bought the box
            //self TriggerEnable( true ); 
            thread ‪zm_unitrigger::register_static_unitrigger(self.unitrigger_stub, &‪magicbox_unitrigger_think);
            
            if( isDefined(self.zbarrier) && !‪IS_TRUE(self.zbarrier.closed_by_emp) )
            {
                self thread ‪treasure_chest_timeout();
            }
        }
 
        // make sure the guy that spent the money gets the item
        // SRS 9/3/2008: ...or item goes back into the box if we time out
        while( !‪IS_TRUE(self.closed_by_emp) )
        {
            self waittill( "trigger", grabber );
            self.weapon_out = undefined;
 
            if ( ‪IS_TRUE( level.magic_box_grab_by_anyone ) )
            {
                if( IsPlayer(grabber) )
                {
                    user = grabber;
                }
            }
 
            if( IsDefined( grabber.is_drinking ) && ‪IS_DRINKING(grabber.is_drinking) )
            {
                wait( 0.1 );
                continue;
            }
 
            if ( grabber == user && user GetCurrentWeapon() == level.weaponNone )
            {
                wait( 0.1 );
                continue;
            }
 
            if(grabber != level && (IsDefined(self.box_rerespun) && self.box_rerespun))
            {
                user = grabber;
            }
            
            if( grabber == user || grabber == level )           
            {
                self.box_rerespun = undefined;
                current_weapon = level.weaponNone;
                
                if(‪zm_utility::is_player_valid(user))
                {
                    current_weapon = user GetCurrentWeapon();
                }
                
                if( grabber == user && 
                    ‪zm_utility::is_player_valid( user ) && 
                    !‪IS_DRINKING(user.is_drinking) && 
                    !‪zm_utility::is_placeable_mine( current_weapon ) && 
                    !‪zm_equipment::is_equipment( current_weapon ) && 
                    !user ‪zm_utility::is_player_revive_tool(current_weapon) && 
                    !current_weapon.isheroweapon &&
                    !current_weapon.isgadget )
                {
                    weaponIdx = undefined;
                    if (isDefined(self.zbarrier) && isDefined(self.zbarrier.weapon))
                    {
                        weaponIdx = MatchRecordGetWeaponIndex(self.zbarrier.weapon);
                    }
                    
                    if (isDefined(weaponidx))
                    {
                        user RecordMapEvent(‪ZM_MAP_EVENT_MAGIC_BOX_TAKEN, GetTime(), user.origin,  level.round_number, weaponIdx);
                    }
                    
                    self notify( "user_grabbed_weapon" );
                    user notify( "user_grabbed_weapon" );
                    user thread ‪treasure_chest_give_weapon( self.zbarrier.weapon );
                    
                    ‪demo::bookmark( "zm_player_grabbed_magicbox", gettime(), user );
                    
                    //stat tracking
                    user ‪zm_stats::increment_client_stat( "grabbed_from_magicbox" );
                    user ‪zm_stats::increment_player_stat( "grabbed_from_magicbox" );
 
                    break; 
                }
                else if( grabber == level )
                {
                    // it timed out
                    self.timedOut = true;
                    weaponIdx = undefined;
                    if (isDefined(self.zbarrier) && isDefined(self.zbarrier.weapon))
                    {
                        weaponIdx = MatchRecordGetWeaponIndex(self.zbarrier.weapon);
                    }
                    if (isDefined(weaponidx))
                    {
                        user RecordMapEvent(‪ZM_MAP_EVENT_MAGIC_BOX_RETURNED, GetTime(), user.origin,  level.round_number, weaponIdx);
                    }
                    break;
                }
            }
 
            ‪WAIT_SERVER_FRAME; 
        }
 
        self.grab_weapon_hint = false;
        self.zbarrier notify( "weapon_grabbed" );
 
        if ( !‪IS_TRUE( self._box_opened_by_fire_sale ) )
        {
            //increase counter of amount of time weapon grabbed, but not during a fire sale
            level.chest_accessed += 1;
        }
 
        //self TriggerEnable( false );
        thread ‪zm_unitrigger::unregister_unitrigger(self.unitrigger_stub);
 
        // spend cash here...
        // give weapon here...
        if(isdefined(self.chest_lid))
        {
            self.chest_lid thread ‪treasure_chest_lid_close( self.timedOut );
        }
 
        if(isdefined(self.zbarrier))
        {
            self.zbarrier ‪set_magic_box_zbarrier_state("close");
            ‪zm_utility::play_sound_at_pos( "close_chest", self.origin );
            self.zbarrier waittill("closed");
            
            wait 1;
        }
        else
        {
            wait 3.0;
        }
        
        // Magic box dissapears and moves to a new spot after a predetermined number of uses
        if ( (‪IS_TRUE( level.zombie_vars["zombie_powerup_fire_sale_on"] ) && self [[level._zombiemode_check_firesale_loc_valid_func]]()) || self == level.chests[level.chest_index] )
        {
            //self TriggerEnable( true );
            thread ‪zm_unitrigger::register_static_unitrigger(self.unitrigger_stub, &‪magicbox_unitrigger_think);
            
//          self setvisibletoall();
        }
    }
 
    self._box_open = false;
    self._box_opened_by_fire_sale = false;
    self.unbearable_respin = undefined;
    self.chest_user = undefined;
    
    self notify( "chest_accessed" );
    
    self thread ‪treasure_chest_think();
}
 
function ‪watch_for_emp_close()
{
    self endon( "chest_accessed" );
    self.closed_by_emp = 0;
    if (!‪zm_utility::should_watch_for_emp())
        return;
    if(isDefined(self.zbarrier))
    {
        self.zbarrier.closed_by_emp = 0;
    }
    
    while (1)
    {
        level waittill("emp_detonate",origin,radius);
        if ( DistanceSquared( origin, self.origin) < radius * radius )
        {
            break;
        }
    }
    
    if (level ‪flag::get("moving_chest_now"))
        return;
    
    // kill the threads
    self.closed_by_emp = 1;
    if(isdefined(self.zbarrier))
    {
        self.zbarrier.closed_by_emp = 1;
        self.zbarrier notify("box_hacked_respin");  
        if(isDefined(self.zbarrier.weapon_model))
        {
            self.zbarrier.weapon_model notify("kill_weapon_movement");
        }
        if(IsDefined(self.zbarrier.weapon_model_dw))
        {
            self.zbarrier.weapon_model_dw notify("kill_weapon_movement");
        }
    }
    
    wait 0.1;   
    
    self notify( "trigger", level );
}
    
 
function ‪can_buy_weapon()
{
    if( IsDefined( self.is_drinking ) && ‪IS_DRINKING(self.is_drinking) )
    {
        return false;
    }
 
    if(self ‪zm_equipment::hacker_active())
    {
        return false;
    }
    
    current_weapon = self GetCurrentWeapon();
    if( ‪zm_utility::is_placeable_mine( current_weapon ) || ‪zm_equipment::is_equipment_that_blocks_purchase( current_weapon ) )
    {
        return false;
    }
    if( self ‪zm_utility::in_revive_trigger() )
    {
        return false;
    }
    
    if( current_weapon == level.weaponNone )
    {
        return false;
    }
 
    if ( current_weapon.isheroweapon || current_weapon.isgadget )
    {
        return false;
    }
 
    return true;
}
 
function ‪default_box_move_logic()
{
    // Check to see if there's a chest selection we should use for this move
    // This is indicated by a script_noteworthy of "moveX*"
    //  (e.g. move1_chest0, move1_chest1)  We will randomly choose between 
    //      one of those two chests for that move number only.
    index = -1;
    for ( i=0; i<level.chests.size; i++ )
    {
        // Check to see if there is something that we have a choice to move to for this move number
        if ( IsSubStr( level.chests[i].script_noteworthy, ("move"+(level.chest_moves+1)) ) &&
             i != level.chest_index )
        {
            index = i;
            break;
        }
    }
 
    if ( index != -1 )
    {
        level.chest_index = index;
    }
    else
    {
        level.chest_index++;
    }
 
    if (level.chest_index >= level.chests.size)
    {
        //PI CHANGE - this way the chests won't move in the same order the second time around
        temp_chest_name = level.chests[level.chest_index - 1].script_noteworthy;
        level.chest_index = 0;
        level.chests = array::randomize(level.chests);
        //in case it happens to randomize in such a way that the chest_index now points to the same location
        // JMA - want to avoid an infinite loop, so we use an if statement
        if (temp_chest_name == level.chests[level.chest_index].script_noteworthy)
        {
            level.chest_index++;
        }
        //END PI CHANGE
    }
}
 
//
//  Chest movement sequence, including lifting the box up and disappearing
//
function ‪treasure_chest_move( player_vox )
{
    level waittill("weapon_fly_away_start");
 
    players = GetPlayers();
    
    array::thread_all(players, &‪play_crazi_sound);
    
    //Delaying the Player Vox
    if( IsDefined( player_vox ) )
    {    
        player_vox ‪util::delay( randomintrange(2,7), undefined, &‪zm_audio::create_and_play_dialog, "general", "box_move"  );
    }   
    
    level waittill("weapon_fly_away_end");
 
    if(isdefined(self.zbarrier))
    {
        self ‪hide_chest(true);
    }
 
    wait(0.1);
    
    post_selection_wait_duration = 7;   
 
    // DCS 072710: check if fire sale went into effect during move, reset with time left.
    if(level.zombie_vars["zombie_powerup_fire_sale_on"] == true && self [[level._zombiemode_check_firesale_loc_valid_func]]())
    {
        current_sale_time = level.zombie_vars["zombie_powerup_fire_sale_time"];
        //IPrintLnBold("need to reset this box spot! Time left is ", current_sale_time);
 
        ‪util::wait_network_frame();             
        self thread ‪fire_sale_fix();
        level.zombie_vars["zombie_powerup_fire_sale_time"] = current_sale_time;
 
        while(level.zombie_vars["zombie_powerup_fire_sale_time"] > 0)
        {
            wait(0.1);
        }   
    }   
    else
    {
        post_selection_wait_duration += 5;
    }
    level.verify_chest = false;
 
 
    if(IsDefined(level._zombiemode_custom_box_move_logic))
    {
        [[level._zombiemode_custom_box_move_logic]]();
    }
    else
    {
        ‪default_box_move_logic();
    }
 
    if(IsDefined(level.chests[level.chest_index].box_hacks["summon_box"]))
    {
        level.chests[level.chest_index] [[level.chests[level.chest_index].box_hacks["summon_box"]]](false);
    }
 
    // Now choose a new location
 
    //wait for all the chests to reset 
    wait(post_selection_wait_duration);
        
    playfx(level._effect["poltergeist"], level.chests[level.chest_index].zbarrier.origin, AnglesToUp( level.chests[level.chest_index].zbarrier.angles ), AnglesToForward( level.chests[level.chest_index].zbarrier.angles ));
    level.chests[level.chest_index] ‪show_chest();
    
    level ‪flag::clear("moving_chest_now");
    self.zbarrier.chest_moving = false;
}
 
 
function ‪fire_sale_fix()
{
    if( !isdefined ( level.zombie_vars["zombie_powerup_fire_sale_on"] ) )
    {
        return;
    }
 
    if( level.zombie_vars["zombie_powerup_fire_sale_on"] )
    {
        self.old_cost = 950;
        self thread ‪show_chest();
        self.zombie_cost = 10;
        self.unitrigger_stub ‪zm_utility::unitrigger_set_hint_string( self , "default_treasure_chest", self.zombie_cost );
 
        ‪util::wait_network_frame();
 
        level waittill( "fire_sale_off" );
        
        while(‪IS_TRUE(self._box_open ))
        {
            wait(.1);
        }       
 
        self ‪hide_chest(true);
    
        self.zombie_cost = self.old_cost;
    }
}
 
function ‪check_for_desirable_chest_location()
{
    if( !isdefined( level.desirable_chest_location ) )
        return level.chest_index;
 
    if( level.chests[level.chest_index].script_noteworthy == level.desirable_chest_location )
    {
        level.desirable_chest_location = undefined;
        return level.chest_index;
    }
    for(i = 0 ; i < level.chests.size; i++ )
    {
        if( level.chests[i].script_noteworthy == level.desirable_chest_location )
        {
            level.desirable_chest_location = undefined;
            return i;
        }
    }
 
    level.desirable_chest_location = undefined;
    return level.chest_index;
}
 
 
function ‪rotateroll_box()
{
    angles = 40;
    angles2 = 0;
    //self endon("movedone");
    while(isdefined(self))
    {
        self RotateRoll(angles + angles2, 0.5);
        wait(0.7);
        angles2 = 40;
        self RotateRoll(angles * -2, 0.5);
        wait(0.7);
    }
    
 
 
}
//verify if that magic box is open to players or not.
function ‪verify_chest_is_open()
{
 
    //for(i = 0; i < 5; i++)
    //PI CHANGE - altered so that there can be more than 5 valid chest locations
    for (i = 0; i < level.open_chest_location.size; i++)
    {
        if(isdefined(level.open_chest_location[i]))
        {
            if(level.open_chest_location[i] == level.chests[level.chest_index].script_noteworthy)
            {
                level.verify_chest = true;
                return;     
            }
        }
 
    }
 
    level.verify_chest = false;
 
 
}
 
 
function ‪treasure_chest_timeout()
{
    self endon( "user_grabbed_weapon" );
    self.zbarrier endon( "box_hacked_respin" );
    self.zbarrier endon( "box_hacked_rerespin" );
 
    wait( 12 );
    self notify( "trigger", level );  
}
 
function ‪treasure_chest_lid_open()
{
    openRoll = 105;
    openTime = 0.5;
 
    self RotateRoll( 105, openTime, ( openTime * 0.5 ) );
 
    ‪zm_utility::play_sound_at_pos( "open_chest", self.origin );
    ‪zm_utility::play_sound_at_pos( "music_chest", self.origin );
}
 
function ‪treasure_chest_lid_close( timedOut )
{
    closeRoll = -105;
    closeTime = 0.5;
 
    self RotateRoll( closeRoll, closeTime, ( closeTime * 0.5 ) );
    ‪zm_utility::play_sound_at_pos( "close_chest", self.origin );
    
    self notify("lid_closed");
}
 
 
function ‪treasure_chest_CanPlayerReceiveWeapon( player, weapon, pap_triggers )
{
    if ( !‪zm_weapons::get_is_in_box( weapon ) )
    {
        return false;
    }
 
    if ( IsDefined( player ) && player ‪zm_weapons::has_weapon_or_upgrade( weapon ) )
    {
        return false;
    }
 
    if ( !‪zm_weapons::limited_weapon_below_quota( weapon, player, pap_triggers ))
        return false;
    
    if ( !player ‪zm_weapons::player_can_use_content( weapon ) )
        return false;
    
    if(isdefined(level.custom_magic_box_selection_logic))
    {
        if(![[level.custom_magic_box_selection_logic]](weapon, player, pap_triggers))
        {
            return false;
        }
    }
 
    if ( weapon.name == "ray_gun" )
    {
        if ( player ‪zm_weapons::has_weapon_or_upgrade( GetWeapon( "raygun_mark2" ) ) )
        {
            return false;
        }
    }
    
    if ( weapon.name == "raygun_mark2" )
    {
        if ( player ‪zm_weapons::has_weapon_or_upgrade( GetWeapon( "ray_gun" ) ) )
        {
            return false;
        }
    }   
 
    // enable special level by level weapon checks
    if( IsDefined( player ) && isdefined( level.special_weapon_magicbox_check ) )
    {
        return player [[level.special_weapon_magicbox_check]]( weapon );
    }
 
    return true;
}
 
function ‪treasure_chest_ChooseWeightedRandomWeapon( player )
{
    keys = array::randomize( GetArrayKeys( level.zombie_weapons ) );
    if (IsDefined(level.CustomRandomWeaponWeights))
    {
        keys = player [[level.CustomRandomWeaponWeights]](keys); 
    }
    pap_triggers = ‪zm_pap_util::get_triggers();
    for ( i = 0; i < keys.size; i++ )
    {
        if ( ‪treasure_chest_CanPlayerReceiveWeapon( player, keys[i], pap_triggers ) )
        {
            return keys[i];
        }
    }
 
    return keys[0];
}
 
 
function ‪weapon_show_hint_choke()
{
    level._weapon_show_hint_choke = 0;
    
    while(1)
    {
        ‪WAIT_SERVER_FRAME;
        level._weapon_show_hint_choke = 0;
    }
}
 
function ‪decide_hide_show_hint( endon_notify, second_endon_notify, onlyplayer, can_buy_weapon_extra_check_func )
{
    self endon("death");
    
    if( isDefined( endon_notify ) )
    {
        self endon( endon_notify );
    }
 
    if( isDefined( second_endon_notify ))
    {
        self endon( second_endon_notify );
    }
    
    if(!IsDefined(level._weapon_show_hint_choke))
    {
        level thread ‪weapon_show_hint_choke();
    }
 
    use_choke = false;
    
    if(IsDefined(level._use_choke_weapon_hints) && level._use_choke_weapon_hints == 1)
    {
        use_choke = true;
    }
 
 
    while( true )
    {
 
        last_update = GetTime();
 
        if ( IsDefined( self.chest_user ) && !IsDefined( self.box_rerespun ) )
        {
            if ( ‪zm_utility::is_placeable_mine( self.chest_user GetCurrentWeapon() ) || self.chest_user ‪zm_equipment::hacker_active() )
            {
                self SetInvisibleToPlayer( self.chest_user);
            }
            else
            {
                self SetVisibleToPlayer( self.chest_user );
            }
        }
        else if ( IsDefined( onlyplayer ) )
        {
            if ( onlyplayer ‪can_buy_weapon() && ( !IsDefined( can_buy_weapon_extra_check_func ) || onlyplayer [[ can_buy_weapon_extra_check_func ]]( self.weapon ) ) && !onlyplayer ‪bgb::is_enabled( "zm_bgb_disorderly_combat" ) )
            {
                self SetInvisibleToPlayer( onlyplayer, false );
            }
            else
            {
                self SetInvisibleToPlayer( onlyplayer, true );
            }
        }
        else // all players
        {   
            players = GetPlayers();
            for ( i = 0; i < players.size; i++ )
            {
                if ( players[ i ] ‪can_buy_weapon() && ( !IsDefined( can_buy_weapon_extra_check_func ) || players[ i ] [[ can_buy_weapon_extra_check_func ]]( self.weapon ) ) && !players[ i ] ‪bgb::is_enabled( "zm_bgb_disorderly_combat" ) )
                {
                    self SetInvisibleToPlayer( players[i], false );
                }
                else
                {
                    self SetInvisibleToPlayer( players[i], true );
                }
            }
        }   
        
        if(use_choke)
        {
            while((level._weapon_show_hint_choke > 4) && (GetTime() < (last_update + 150)))
            {
                ‪WAIT_SERVER_FRAME;
            }
        }
        else
        {
            wait(0.1);
        }       
        
        level._weapon_show_hint_choke ++;
    }
}
 
function ‪get_left_hand_weapon_model_name( weapon )
{
    dw_weapon = weapon.dualWieldWeapon;
    if ( dw_weapon != level.weaponNone )
    {
        return dw_weapon.worldModel;
    }
 
    return weapon.worldModel;
}
 
function ‪clean_up_hacked_box()
{
    self waittill("box_hacked_respin");
    self endon("box_spin_done");
    
    if(IsDefined(self.weapon_model))
    {
        self.weapon_model Delete();
        self.weapon_model = undefined;
    }
 
    if(IsDefined(self.weapon_model_dw))
    {
        self.weapon_model_dw Delete();
        self.weapon_model_dw = undefined;
    }
    
 
    self HideZBarrierPiece(3);
    self HideZBarrierPiece(4);
    self SetZBarrierPieceState(3, "closed");
    self SetZBarrierPieceState(4, "closed");
}
 
 
function ‪treasure_chest_firesale_active()
{
    return ‪IS_TRUE( level.zombie_vars["zombie_powerup_fire_sale_on"] ); 
}
 
function ‪treasure_chest_should_move( chest, player )
{
    // Increase the chance of joker appearing from 0-100 based on amount of the time chest has been opened.
    if( ( GetDvarString( "magic_chest_movable") == "1") && 
        !‪IS_TRUE( chest._box_opened_by_fire_sale ) && 
        !‪treasure_chest_firesale_active() && 
        self [[level._zombiemode_check_firesale_loc_valid_func]]() )
    {
        // random change of getting the joker that moves the box
        random = Randomint(100);
 
        if( !isdefined( level.chest_min_move_usage ) )
        {
            level.chest_min_move_usage = 4;
        }
 
        if( level.chest_accessed < level.chest_min_move_usage )
        {       
            chance_of_joker = -1;
        }
        else
        {
            chance_of_joker = level.chest_accessed + 20;
 
            // make sure teddy bear appears on the 8th pull if it hasn't moved from the initial spot
            if ( level.chest_moves == 0 && level.chest_accessed >= 8 )
            {
                chance_of_joker = 100;
            }
 
            // pulls 4 thru 8, there is a 15% chance of getting the teddy bear
            // NOTE:  this happens in all cases
            if( level.chest_accessed >= 4 && level.chest_accessed < 8 )
            {
                if( random < 15 )
                {
                    chance_of_joker = 100;
                }
                else
                {
                    chance_of_joker = -1;
                }
            }
 
            // after the first magic box move the teddy bear percentages changes
            if ( level.chest_moves > 0 )
            {
                // between pulls 8 thru 12, the teddy bear percent is 30%
                if( level.chest_accessed >= 8 && level.chest_accessed < 13 )
                {
                    if( random < 30 )
                    {
                        chance_of_joker = 100;
                    }
                    else
                    {
                        chance_of_joker = -1;
                    }
                }
                
                // after 12th pull, the teddy bear percent is 50%
                if( level.chest_accessed >= 13 )
                {
                    if( random < 50 )
                    {
                        chance_of_joker = 100;
                    }
                    else
                    {
                        chance_of_joker = -1;
                    }
                }
            }
        }
 
        if(IsDefined(chest.no_fly_away))
        {
            chance_of_joker = -1;
        }
 
        if(IsDefined(level._zombiemode_chest_joker_chance_override_func))
        {
            chance_of_joker = [[level._zombiemode_chest_joker_chance_override_func]](chance_of_joker);
        }
 
        if ( chance_of_joker > random )
        {
            return true; 
        }
    }
    
    return false;   
}
 
function ‪spawn_joker_weapon_model( player, model, origin, angles )
{
    weapon_model = ‪spawn( "script_model", origin ); 
    if ( isdefined( angles ) )
    {
        weapon_model.angles = angles;
    }
    weapon_model SetModel(model);
    return weapon_model;
}
 
 
// lock or unlock a weapon model
function ‪treasure_chest_weapon_locking( player, weapon, onOff )
{
    if ( isdefined(self.locked_model) ) 
    {
        self.locked_model delete();
        self.locked_model = undefined;
    }
 
    if ( onOff )
    {
        if ( weapon == level.weaponNone )
        {
            self.locked_model = ‪spawn_joker_weapon_model( player, level.chest_joker_model, self.origin, (0,0,0) );
        }
        else
        {
            self.locked_model = ‪zm_utility::spawn_buildkit_weapon_model( player, weapon, undefined, self.origin, (0,0,0));
        }
        self.locked_model Ghost(); 
        self.locked_model ‪clientfield::set( "force_stream", 1 );
    }
}
 
function ‪treasure_chest_weapon_spawn( chest, player, respin )
{
    self endon("box_hacked_respin");
    self thread ‪clean_up_hacked_box();
    assert(IsDefined(player));
    // spawn the model
//  model = spawn( "script_model", self.origin ); 
//  model.angles = self.angles +( 0, 90, 0 );
 
//  floatHeight = 40;
 
    //move it up
//  model moveto( model.origin +( 0, 0, floatHeight ), 3, 2, 0.9 ); 
 
    self.chest_moving = false;
    move_the_box = ‪treasure_chest_should_move( chest, player ); 
    
    preferred_weapon = undefined; 
    
    if ( move_the_box )
    {
        preferred_weapon = level.weaponNone;
    }
    //  Pick a random weapon
    else
    {
        preferred_weapon = ‪treasure_chest_ChooseWeightedRandomWeapon( player );
    }
    
    chest ‪treasure_chest_weapon_locking( player, preferred_weapon, true );
    
    // rotation would go here
 
    // make with the mario kart
    const FLOAT_HEIGHT = 40;
    const BOX_MOVE_BEAR_FLYAWAY_DISTANCE = 500;
    const BOX_MOVE_BEAR_FLYAWAY_TIME = 4;
    const BOX_MOVE_BEAR_FLYAWAY_ACCEL = 3;
    self.weapon = level.weaponNone;
    modelname = undefined; 
    rand = undefined; 
    number_cycles = 40;
    
    if(isdefined(chest.zbarrier))
    {
        if ( IsDefined( level.custom_magic_box_do_weapon_rise ) )
        {
            chest.zbarrier thread [[level.custom_magic_box_do_weapon_rise]]();
        }
        else
        {
            chest.zbarrier thread ‪magic_box_do_weapon_rise();
        }
    }
    
    for( i = 0; i < number_cycles; i++ )
    {
 
        if( i < 20 )
        {
            ‪WAIT_SERVER_FRAME; 
        }
        else if( i < 30 )
        {
            wait( 0.1 ); 
        }
        else if( i < 35 )
        {
            wait( 0.2 ); 
        }
        else if( i < 38 )
        {
            wait( 0.3 ); 
        }
    }
 
    if ( IsDefined( level.custom_magic_box_weapon_wait ) )
    {
        [[level.custom_magic_box_weapon_wait]](); // wait to match up with any waits in the custom weapon rise
    }
 
    //**********************************
    // Pick a random weapon from the box
    //**********************************
 
    new_firesale = ( move_the_box && ‪treasure_chest_firesale_active() );
    
    // if the box was scheduled to move and a firesale has started since the box started cycling pick a real weapon
    if ( new_firesale )
    {
        move_the_box = false; 
        preferred_weapon = ‪treasure_chest_ChooseWeightedRandomWeapon( player );
    }
    
    // make sure the player can still get the weapon we picked at the start 
    if ( !move_the_box && ‪treasure_chest_CanPlayerReceiveWeapon( player, preferred_weapon, ‪zm_pap_util::get_triggers() ) )
    {
        rand = preferred_weapon;
    }
    //  Pick a random weapon
    else
    {
        rand = ‪treasure_chest_ChooseWeightedRandomWeapon( player );
    }
 
    // forcing box weapons from the devgui is now handled in treasure_chest_ChooseWeightedRandomWeapon
    // this allows us to test box weapon filtering. 
    // if you need to give yourself a weapon without filtering you can use 
    //   set zombie_devgui_gun gunyouwant_zm
    
    // Here's where the org get it's weapon type for the give function
    self.weapon = rand; 
    
    if ( isdefined( level.func_magicbox_weapon_spawned ) )
    {
        self thread [[ level.func_magicbox_weapon_spawned ]]( self.weapon );
    }
    
    //util::wait_network_frame();
    wait( 0.1 );
 
    // get offset for floating weapon
    if ( IsDefined( level.custom_magicbox_float_height ) )
    {
        v_float = AnglesToUp( self.angles ) * level.custom_magicbox_float_height;
    }
    else
    {
        v_float = AnglesToUp( self.angles ) * FLOAT_HEIGHT;  // draw vector straight up with reference to the mystery box angles
    }
 
    self.model_dw = undefined;
 
    self.weapon_model = ‪zm_utility::spawn_buildkit_weapon_model( player, rand, undefined, self.origin + v_float, (-self.angles[0], self.angles[1] + 180, -self.angles[2]));
 
    if ( rand.isDualWield )
    {
        dweapon = rand; 
        if ( isdefined( rand.dualwieldweapon ) && rand.dualwieldweapon != level.weaponNone )
        {
            dweapon = rand.dualwieldweapon; 
        }
        
        self.weapon_model_dw = ‪zm_utility::spawn_buildkit_weapon_model( player, dweapon, undefined, self.weapon_model.origin - ( 3, 3, 3 ), self.weapon_model.angles ); 
    }
 
    if ( move_the_box && !(level.zombie_vars["zombie_powerup_fire_sale_on"] && self [[level._zombiemode_check_firesale_loc_valid_func]]()) )
    {
        self.weapon_model SetModel(level.chest_joker_model);
 
        if(IsDefined(self.weapon_model_dw))
        {
            self.weapon_model_dw Delete();
            self.weapon_model_dw = undefined;
        }
        
        if( IsPlayer( chest.chest_user ) && chest.chest_user ‪bgb::is_enabled( "zm_bgb_unbearable" ) )
        {
            level.chest_accessed = 0;
            chest.unbearable_respin = true;
            chest.chest_user notify( "zm_bgb_unbearable", chest );
            chest waittill( "forever" );
        }
        
        self.chest_moving = true;
        level ‪flag::set("moving_chest_now");
        level.chest_accessed = 0;
 
        level.chest_moves++;
    }
 
    self notify( "randomization_done" );
 
    if (‪IS_TRUE(self.chest_moving))
    {
        if( IsDefined( level.chest_joker_custom_movement ) )
        {
            self [[ level.chest_joker_custom_movement ]]();
        }
        else
        {
            //record the weapon model origin and delete it, it could have parts hidden based on what weapon spawned
            v_origin = self.weapon_model.origin;
            self.weapon_model Delete();
 
            //spawn a fresh new model with everything correct
            self.weapon_model = ‪Spawn( "script_model", v_origin );
            self.weapon_model SetModel( level.chest_joker_model );
            self.weapon_model.angles = self.angles + ( 0, 180, 0 );
 
            wait .5;    // we need a wait here before this notify
            level notify("weapon_fly_away_start");
            wait 2;
            if( IsDefined( self.weapon_model ) )
            {
                v_fly_away = self.origin + ( AnglesToUp( self.angles ) * BOX_MOVE_BEAR_FLYAWAY_DISTANCE );
                self.weapon_model MoveTo( v_fly_away, BOX_MOVE_BEAR_FLYAWAY_TIME, BOX_MOVE_BEAR_FLYAWAY_ACCEL );
            }
            
            if ( IsDefined(self.weapon_model_dw ) )
            {
                v_fly_away = self.origin + ( AnglesToUp( self.angles ) * BOX_MOVE_BEAR_FLYAWAY_DISTANCE );
                self.weapon_model_dw MoveTo( v_fly_away, BOX_MOVE_BEAR_FLYAWAY_TIME, BOX_MOVE_BEAR_FLYAWAY_ACCEL );
            }
            
            self.weapon_model waittill("movedone");
            self.weapon_model delete();
            
            if(IsDefined(self.weapon_model_dw))
            {
                self.weapon_model_dw Delete();
                self.weapon_model_dw = undefined;
            }
            
            self notify( "box_moving" );
            level notify("weapon_fly_away_end");
        }
    }
    else
    {
        if(!IsDefined(respin))
        {
            if(IsDefined(chest.box_hacks["respin"]))
            {
                self [[chest.box_hacks["respin"]]](chest, player);
            }
        }
        else
        {
            if(IsDefined(chest.box_hacks["respin_respin"]))
            {
                self [[chest.box_hacks["respin_respin"]]](chest, player);
            }
        }
 
        // allow for custom back-into-box movement      
        if(IsDefined(level.custom_magic_box_timer_til_despawn))
        {
            self.weapon_model thread [[level.custom_magic_box_timer_til_despawn]]( self );
        }
        else
        {
            // weapon re-enters box
            self.weapon_model thread ‪timer_til_despawn( v_float );
        }
        
        if(IsDefined(self.weapon_model_dw))
        {
            if(IsDefined(level.custom_magic_box_timer_til_despawn))
            {
                self.weapon_model_dw thread [[level.custom_magic_box_timer_til_despawn]]( self );
            }
            else
            {
                self.weapon_model_dw thread ‪timer_til_despawn( v_float );
            }
        }
        
        self waittill( "weapon_grabbed" );
 
        if( !chest.timedOut )
        {
            if(IsDefined(self.weapon_model))
            {
                self.weapon_model Delete();
            }
            
            if(IsDefined(self.weapon_model_dw))
            {
                self.weapon_model_dw Delete();
            }
        }
    }
 
    chest ‪treasure_chest_weapon_locking( player, preferred_weapon, false );
    
    self.weapon = level.weaponNone;
    self notify("box_spin_done");
}
 
//
//
function ‪chest_get_min_usage()
{
    min_usage = 4;
 
    return( min_usage );
}
 
//
//
function ‪chest_get_max_usage()
{
    max_usage = 6;
 
    players = GetPlayers();
 
    // Special case max box pulls before 1st box move
    if( level.chest_moves == 0 )
    {
        if( players.size == 1 )
        {
            max_usage = 3;
        }
        else if( players.size == 2 )
        {
            max_usage = 4;
        }
        else if( players.size == 3 )
        {
            max_usage = 5;
        }
        else
        {
            max_usage = 6;
        }
    }
    // Box has moved, what is the maximum number of times it can move again?
    else
    {
        if( players.size == 1 )
        {
            max_usage = 4;
        }
        else if( players.size == 2 )
        {
            max_usage = 4;
        }
        else if( players.size == 3 )
        {
            max_usage = 5;
        }
        else
        {
            max_usage = 7;
        }
    }
    return( max_usage );
}
 
 
function ‪timer_til_despawn( v_float )
{
    self endon("kill_weapon_movement");
    // SRS 9/3/2008: if we timed out, move the weapon back into the box instead of deleting it
    putBackTime = 12;
    self MoveTo( self.origin - ( v_float * 0.85 ), putBackTime, ( putBackTime * 0.5 ) );
    wait( putBackTime );
 
    if(isdefined(self))
    {   
        self Delete();
    }
}
 
function ‪treasure_chest_glowfx()
{
    self ‪clientfield::set( "magicbox_open_glow", true );
    self ‪clientfield::set( "magicbox_closed_glow", false );
 
    ret_val = self ‪util::waittill_any_return( "weapon_grabbed", "box_moving" ); 
 
    self ‪clientfield::set( "magicbox_open_glow", false );
 
    if ( "box_moving" != ret_val )
    {
        self ‪clientfield::set( "magicbox_closed_glow", true );
    }
}
 
// self is the player string comes from the randomization function
function ‪treasure_chest_give_weapon( weapon )
{
    self.last_box_weapon = GetTime();
 
    // this function was almost identical to weapon_give() so it calls that instead
 
    //Audio: Raygun ALWAYS plays this stinger when getting it from the magicbox
    if( weapon.name == "ray_gun" || weapon.name == "raygun_mark2" )
    {
        playsoundatposition( "mus_raygun_stinger", (0,0,0) );
    }
    
    if( ‪should_upgrade_weapon( self, weapon ) )
    {
        if( self ‪zm_weapons::can_upgrade_weapon( weapon ) )
        {
            weapon = ‪zm_weapons::get_upgrade_weapon( weapon );
            self notify( "zm_bgb_crate_power_used" );
        }
    }   
    
    if( ‪zm_utility::is_hero_weapon( weapon ) && !self HasWeapon( weapon ) )
    {
        self ‪give_hero_weapon( weapon );
    }
    else
    {
        w_give = self ‪zm_weapons::weapon_give(weapon, false, true);
        
        // make sure no aat given from the box  
        if( isdefined(weapon) )
        {
            self thread ‪aat::remove( w_give );
        }           
    }
}
 
function ‪give_hero_weapon( weapon )//self = player
{
    w_previous = self GetCurrentWeapon();
    self ‪zm_weapons::weapon_give( weapon );
    self GadgetPowerSet( 0, 99 );
    self SwitchToWeapon( weapon );
    self waittill( "weapon_change_complete" );
    self SetLowReady( true ); 
    self SwitchToWeapon( w_previous );
    self ‪util::waittill_any_timeout( 1.0, "weapon_change_complete" );
    self SetLowReady( false );
    self GadgetPowerSet( 0, 100 );
}
 
function ‪should_upgrade_weapon( player, weapon )
{
    if( isdefined( level.magicbox_should_upgrade_weapon_override ) )
    {
        return [[ level.magicbox_should_upgrade_weapon_override ]]( player, weapon ); // PORTIZ 7/19/2016: pass in player and weapon to check specific conditions
    }
    
    if( player ‪bgb::is_enabled( "zm_bgb_crate_power" ) )
    {
        return true;
    }
    
    return false;
}
 
function ‪magic_box_initial()
{
    self SetZBarrierPieceState(1, "open");
 
    self ‪clientfield::set( "magicbox_closed_glow", true );
}
 
function ‪magic_box_arrives()
{
    self SetZBarrierPieceState(1, "opening");
    while(self GetZBarrierPieceState(1) == "opening")
    {
        ‪WAIT_SERVER_FRAME;
    }
    self notify("arrived");
}
 
function ‪magic_box_leaves()
{
    self SetZBarrierPieceState(1, "closing");
    while(self GetZBarrierPieceState(1) == "closing")
    {
        wait (0.1);
    }
    self notify("left");
}
 
function ‪magic_box_opens()
{
    self SetZBarrierPieceState(2, "opening");
    while(self GetZBarrierPieceState(2) == "opening")
    {
        wait (0.1);
    }
    self notify("opened");
}
 
function ‪magic_box_closes()
{
    self SetZBarrierPieceState(2, "closing");
    while(self GetZBarrierPieceState(2) == "closing")
    {
        wait (0.1);
    }
    self notify("closed");
}
 
function ‪magic_box_do_weapon_rise()
{
    self endon("box_hacked_respin");
    
    self SetZBarrierPieceState(3, "closed");
    self SetZBarrierPieceState(4, "closed");
    
    ‪util::wait_network_frame();
 
    self ZBarrierPieceUseBoxRiseLogic(3);
    self ZBarrierPieceUseBoxRiseLogic(4);
    
    self ShowZBarrierPiece(3);
    self ShowZBarrierPiece(4);
    self SetZBarrierPieceState(3, "opening");
    self SetZBarrierPieceState(4, "opening");
    
    while(self GetZBarrierPieceState(3) != "open")
    {
        wait(0.5);
    }
    
    self HideZBarrierPiece(3);
    self HideZBarrierPiece(4);
    
}
 
function ‪magic_box_do_teddy_flyaway()
{
    self ShowZBarrierPiece(3);
    self SetZBarrierPieceState(3, "closing");
}
 
function ‪is_chest_active()
{
    curr_state = self.zbarrier ‪get_magic_box_zbarrier_state();
    
    if( level ‪flag::get( "moving_chest_now" ) )
    {
        return false;
    }
    
    if( curr_state == "open" || curr_state == "close" )
    {
        return true;
    }
    
    return false;
}
 
function ‪get_magic_box_zbarrier_state()
{
    return self.state;
}
 
function ‪set_magic_box_zbarrier_state(state)
{
    for(i = 0; i < self GetNumZBarrierPieces(); i ++)
    {
        self HideZBarrierPiece(i);
    }
    self notify("zbarrier_state_change");
    
    self [[level.magic_box_zbarrier_state_func]](state);
}
 
function ‪process_magic_box_zbarrier_state(state)
{
    switch(state)
    {
        case "away":
            self ShowZBarrierPiece(0);
            self.state = "away";
            break;
        case "arriving":
            self ShowZBarrierPiece(1);
            self thread ‪magic_box_arrives();
            self.state = "arriving";
            break;
        case "initial":
            self ShowZBarrierPiece(1);
            self thread ‪magic_box_initial();
            thread ‪zm_unitrigger::register_static_unitrigger(self.owner.unitrigger_stub, &‪magicbox_unitrigger_think);
            self.state = "initial";
            break;
        case "open":
            self ShowZBarrierPiece(2);
            self thread ‪magic_box_opens();
            self.state = "open";
            break;
        case "close":
            self ShowZBarrierPiece(2);
            self thread ‪magic_box_closes();
            self.state = "close";
            break;
        case "leaving":
            self showZBarrierPiece(1);
            self thread ‪magic_box_leaves();
            self.state = "leaving";
            break;
        default:
            if( IsDefined( level.custom_magicbox_state_handler ) )
            {
                self [[ level.custom_magicbox_state_handler ]]( state );
            }
            break;
    }
}
 
function ‪magicbox_host_migration()
{
    level endon("end_game");
    
    level notify("mb_hostmigration");
    level endon("mb_hostmigration");
        
    while(1)
    {
        level waittill("host_migration_end");
        
        if(!isDefined(level.chests))
            continue;
        
        foreach( chest in level.chests ) 
        {
            if ( !‪IS_TRUE( chest.hidden ) ) 
            {
                if ( IsDefined( chest ) && IsDefined( chest.pandora_light ) )
                {
                    playfxontag(level._effect["lght_marker"], chest.pandora_light, "tag_origin");
                }
            }
            ‪util::wait_network_frame();
        }
    }
}
 
function ‪box_encounter_vo()
{
    level ‪flag::wait_till( "initial_blackscreen_passed" );
 
    self endon("left");
    
    while (1)
    {
        foreach (player in getPlayers())
        {
            distanceFromPlayerToBox = distance(player.origin, self.origin);
            
            if (distanceFromPlayerToBox < 400 && player ‪zm_utility::is_player_looking_at(self.origin))
            {
                player ‪zm_audio::create_and_play_dialog( "box", "encounter" );
                return;             
            }           
        }
        wait 0.5;
    }
}