#include maps\mp\zombies\_zm_weapons;
#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\zombies\_zm_utility;

init_weapon_upgrade()
{
    init_spawnable_weapon_upgrade();
    weapon_spawns = [];
    weapon_spawns = getentarray( "weapon_upgrade", "targetname" );

    for ( i = 0; i < weapon_spawns.size; i++ )
    {
		scripts\zm\replaced\utility::wallbuy( weapon_spawns[i].zombie_weapon_upgrade, weapon_spawns[i].target + "_weapon_upgrade", weapon_spawns[i].targetname, weapon_spawns[i].origin, weapon_spawns[i].angles, 0 );
    }
}

init_spawnable_weapon_upgrade()
{
    spawn_list = [];
    spawnable_weapon_spawns = getstructarray( "weapon_upgrade", "targetname" );
    spawnable_weapon_spawns = arraycombine( spawnable_weapon_spawns, getstructarray( "bowie_upgrade", "targetname" ), 1, 0 );
    spawnable_weapon_spawns = arraycombine( spawnable_weapon_spawns, getstructarray( "sickle_upgrade", "targetname" ), 1, 0 );
    spawnable_weapon_spawns = arraycombine( spawnable_weapon_spawns, getstructarray( "tazer_upgrade", "targetname" ), 1, 0 );
    spawnable_weapon_spawns = arraycombine( spawnable_weapon_spawns, getstructarray( "buildable_wallbuy", "targetname" ), 1, 0 );

    if ( !is_true( level.headshots_only ) )
        spawnable_weapon_spawns = arraycombine( spawnable_weapon_spawns, getstructarray( "claymore_purchase", "targetname" ), 1, 0 );

    match_string = "";
    location = level.scr_zm_map_start_location;

    if ( ( location == "default" || location == "" ) && isdefined( level.default_start_location ) )
        location = level.default_start_location;

    match_string = level.scr_zm_ui_gametype;

    if ( "" != location )
        match_string = match_string + "_" + location;

    match_string_plus_space = " " + match_string;

    for ( i = 0; i < spawnable_weapon_spawns.size; i++ )
    {
        spawnable_weapon = spawnable_weapon_spawns[i];

        if ( isdefined( spawnable_weapon.zombie_weapon_upgrade ) && spawnable_weapon.zombie_weapon_upgrade == "sticky_grenade_zm" && is_true( level.headshots_only ) )
            continue;

        if ( !isdefined( spawnable_weapon.script_noteworthy ) || spawnable_weapon.script_noteworthy == "" )
        {
            spawn_list[spawn_list.size] = spawnable_weapon;
            continue;
        }

        matches = strtok( spawnable_weapon.script_noteworthy, "," );

        for ( j = 0; j < matches.size; j++ )
        {
            if ( matches[j] == match_string || matches[j] == match_string_plus_space )
                spawn_list[spawn_list.size] = spawnable_weapon;
        }
    }

    tempmodel = spawn( "script_model", ( 0, 0, 0 ) );

    for ( i = 0; i < spawn_list.size; i++ )
    {
        clientfieldname = spawn_list[i].zombie_weapon_upgrade + "_" + spawn_list[i].origin;
        numbits = 2;

        if ( isdefined( level._wallbuy_override_num_bits ) )
            numbits = level._wallbuy_override_num_bits;

        registerclientfield( "world", clientfieldname, 1, numbits, "int" );
        target_struct = getstruct( spawn_list[i].target, "targetname" );

        if ( spawn_list[i].targetname == "buildable_wallbuy" )
        {
            bits = 4;

            if ( isdefined( level.buildable_wallbuy_weapons ) )
                bits = getminbitcountfornum( level.buildable_wallbuy_weapons.size + 1 );

            registerclientfield( "world", clientfieldname + "_idx", 12000, bits, "int" );
            spawn_list[i].clientfieldname = clientfieldname;
            continue;
        }

        precachemodel( target_struct.model );
        unitrigger_stub = spawnstruct();
        unitrigger_stub.origin = spawn_list[i].origin;
        unitrigger_stub.angles = spawn_list[i].angles;
        tempmodel.origin = spawn_list[i].origin;
        tempmodel.angles = spawn_list[i].angles;
        mins = undefined;
        maxs = undefined;
        absmins = undefined;
        absmaxs = undefined;
        tempmodel setmodel( target_struct.model );
        tempmodel useweaponhidetags( spawn_list[i].zombie_weapon_upgrade );
        mins = tempmodel getmins();
        maxs = tempmodel getmaxs();
        absmins = tempmodel getabsmins();
        absmaxs = tempmodel getabsmaxs();
        bounds = absmaxs - absmins;
        unitrigger_stub.script_length = 64;
        unitrigger_stub.script_width = bounds[1];
        unitrigger_stub.script_height = bounds[2];
        unitrigger_stub.origin -= anglestoright( unitrigger_stub.angles ) * ( bounds[0] * 0.1 );
        unitrigger_stub.target = spawn_list[i].target;
        unitrigger_stub.targetname = spawn_list[i].targetname;
        unitrigger_stub.cursor_hint = "HINT_NOICON";

        if ( spawn_list[i].targetname == "weapon_upgrade" )
        {
            unitrigger_stub.cost = get_weapon_cost( spawn_list[i].zombie_weapon_upgrade );

            if ( !( isdefined( level.monolingustic_prompt_format ) && level.monolingustic_prompt_format ) )
            {
                unitrigger_stub.hint_string = get_weapon_hint( spawn_list[i].zombie_weapon_upgrade );
                unitrigger_stub.hint_parm1 = unitrigger_stub.cost;
            }
            else
            {
                unitrigger_stub.hint_parm1 = get_weapon_display_name( spawn_list[i].zombie_weapon_upgrade );

                if ( !isdefined( unitrigger_stub.hint_parm1 ) || unitrigger_stub.hint_parm1 == "" || unitrigger_stub.hint_parm1 == "none" )
                    unitrigger_stub.hint_parm1 = "missing weapon name " + spawn_list[i].zombie_weapon_upgrade;

                unitrigger_stub.hint_parm2 = unitrigger_stub.cost;
                unitrigger_stub.hint_string = &"ZOMBIE_WEAPONCOSTONLY";
            }
        }

        unitrigger_stub.weapon_upgrade = spawn_list[i].zombie_weapon_upgrade;
        unitrigger_stub.script_unitrigger_type = "unitrigger_box_use";
        unitrigger_stub.require_look_at = 1;

        if ( isdefined( spawn_list[i].require_look_from ) && spawn_list[i].require_look_from )
            unitrigger_stub.require_look_from = 1;

        unitrigger_stub.zombie_weapon_upgrade = spawn_list[i].zombie_weapon_upgrade;
        unitrigger_stub.clientfieldname = clientfieldname;
        maps\mp\zombies\_zm_unitrigger::unitrigger_force_per_player_triggers( unitrigger_stub, 1 );

        if ( is_melee_weapon( unitrigger_stub.zombie_weapon_upgrade ) )
        {
            if ( unitrigger_stub.zombie_weapon_upgrade == "tazer_knuckles_zm" )
                unitrigger_stub.origin += (anglesToForward(unitrigger_stub.angles) * -7) + (anglesToRight(unitrigger_stub.angles) * -2);

            maps\mp\zombies\_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::weapon_spawn_think );
        }
        else if ( unitrigger_stub.zombie_weapon_upgrade == "claymore_zm" )
        {
            unitrigger_stub.prompt_and_visibility_func = scripts\zm\replaced\_zm_weap_claymore::claymore_unitrigger_update_prompt;
            maps\mp\zombies\_zm_unitrigger::register_static_unitrigger( unitrigger_stub, scripts\zm\replaced\_zm_weap_claymore::buy_claymores );
        }
        else
        {
			if( is_lethal_grenade( unitrigger_stub.zombie_weapon_upgrade ) )
				unitrigger_stub.prompt_and_visibility_func = ::lethal_grenade_update_prompt;
			else
				unitrigger_stub.prompt_and_visibility_func = ::wall_weapon_update_prompt;

            maps\mp\zombies\_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::weapon_spawn_think );
        }

        spawn_list[i].trigger_stub = unitrigger_stub;
    }

    level._spawned_wallbuys = spawn_list;
    tempmodel delete();
}

add_dynamic_wallbuy( weapon, wallbuy, pristine )
{
    spawned_wallbuy = undefined;

    for ( i = 0; i < level._spawned_wallbuys.size; i++ )
    {
        if ( level._spawned_wallbuys[i].target == wallbuy )
        {
            spawned_wallbuy = level._spawned_wallbuys[i];
            break;
        }
    }

    if ( !isdefined( spawned_wallbuy ) )
    {
        return;
    }

    if ( isdefined( spawned_wallbuy.trigger_stub ) )
    {
        return;
    }

    target_struct = getstruct( wallbuy, "targetname" );
    wallmodel = spawn_weapon_model( weapon, undefined, target_struct.origin, target_struct.angles );
    clientfieldname = spawned_wallbuy.clientfieldname;
    model = getweaponmodel( weapon );
    unitrigger_stub = spawnstruct();
    unitrigger_stub.origin = target_struct.origin;
    unitrigger_stub.angles = target_struct.angles;
    wallmodel.origin = target_struct.origin;
    wallmodel.angles = target_struct.angles;
    mins = undefined;
    maxs = undefined;
    absmins = undefined;
    absmaxs = undefined;
    wallmodel setmodel( model );
    wallmodel useweaponhidetags( weapon );
    mins = wallmodel getmins();
    maxs = wallmodel getmaxs();
    absmins = wallmodel getabsmins();
    absmaxs = wallmodel getabsmaxs();
    bounds = absmaxs - absmins;
    unitrigger_stub.script_length = 64;
    unitrigger_stub.script_width = bounds[1];
    unitrigger_stub.script_height = bounds[2];
    unitrigger_stub.origin -= anglestoright( unitrigger_stub.angles ) * ( bounds[0] * 0.1 );
    unitrigger_stub.target = spawned_wallbuy.target;
    unitrigger_stub.targetname = "weapon_upgrade";
    unitrigger_stub.cursor_hint = "HINT_NOICON";
    unitrigger_stub.first_time_triggered = !pristine;

    if ( !is_melee_weapon( weapon ) )
    {
        if ( pristine || weapon == "claymore_zm" )
            unitrigger_stub.hint_string = get_weapon_hint( weapon );
        else
            unitrigger_stub.hint_string = get_weapon_hint_ammo();

        unitrigger_stub.cost = get_weapon_cost( weapon );
        unitrigger_stub.hint_parm1 = unitrigger_stub.cost;
    }

    unitrigger_stub.weapon_upgrade = weapon;
    unitrigger_stub.script_unitrigger_type = "unitrigger_box_use";
    unitrigger_stub.require_look_at = 1;
    unitrigger_stub.zombie_weapon_upgrade = weapon;
    unitrigger_stub.clientfieldname = clientfieldname;
    unitrigger_force_per_player_triggers( unitrigger_stub, 1 );

    if ( is_melee_weapon( weapon ) )
    {
        if ( weapon == "tazer_knuckles_zm" )
			unitrigger_stub.origin += (anglesToForward(unitrigger_stub.angles) * -7) + (anglesToRight(unitrigger_stub.angles) * -2);

        maps\mp\zombies\_zm_melee_weapon::add_stub( unitrigger_stub, weapon );
        maps\mp\zombies\_zm_unitrigger::register_static_unitrigger( unitrigger_stub, maps\mp\zombies\_zm_melee_weapon::melee_weapon_think );
    }
    else if ( weapon == "claymore_zm" )
    {
        unitrigger_stub.prompt_and_visibility_func = maps\mp\zombies\_zm_weap_claymore::claymore_unitrigger_update_prompt;
        maps\mp\zombies\_zm_unitrigger::register_static_unitrigger( unitrigger_stub, maps\mp\zombies\_zm_weap_claymore::buy_claymores );
    }
    else
    {
        if( is_lethal_grenade( unitrigger_stub.zombie_weapon_upgrade ) )
			unitrigger_stub.prompt_and_visibility_func = ::lethal_grenade_update_prompt;
		else
			unitrigger_stub.prompt_and_visibility_func = ::wall_weapon_update_prompt;

        maps\mp\zombies\_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::weapon_spawn_think );
    }

    spawned_wallbuy.trigger_stub = unitrigger_stub;
    weaponidx = undefined;

    if ( isdefined( level.buildable_wallbuy_weapons ) )
    {
        for ( i = 0; i < level.buildable_wallbuy_weapons.size; i++ )
        {
            if ( weapon == level.buildable_wallbuy_weapons[i] )
            {
                weaponidx = i;
                break;
            }
        }
    }

    if ( isdefined( weaponidx ) )
    {
        level setclientfield( clientfieldname + "_idx", weaponidx + 1 );
        wallmodel delete();

        if ( !pristine )
            level setclientfield( clientfieldname, 1 );
    }
    else
    {
        level setclientfield( clientfieldname, 1 );
        wallmodel show();
    }
}

lethal_grenade_update_prompt( player )
{
    weapon = self.stub.zombie_weapon_upgrade;

    cost = get_weapon_cost( weapon );
	self.stub.hint_string = get_weapon_hint( weapon );
	self sethintstring( self.stub.hint_string, cost );

    self.stub.cursor_hint = "HINT_WEAPON";
	self.stub.cursor_hint_weapon = weapon;
	self setcursorhint( self.stub.cursor_hint, self.stub.cursor_hint_weapon );

    return 1;
}

weapon_give( weapon, is_upgrade, magic_box, nosound )
{
	primaryweapons = self getweaponslistprimaries();
	current_weapon = self getcurrentweapon();
	current_weapon = self maps\mp\zombies\_zm_weapons::switch_from_alt_weapon( current_weapon );
	if ( !isDefined( is_upgrade ) )
	{
		is_upgrade = 0;
	}
	weapon_limit = get_player_weapon_limit( self );
	if ( is_equipment( weapon ) )
	{
		self maps\mp\zombies\_zm_equipment::equipment_give( weapon );
	}
	if ( weapon == "riotshield_zm" )
	{
		if ( isDefined( self.player_shield_reset_health ) )
		{
			self [[ self.player_shield_reset_health ]]();
		}
	}
	if ( self hasweapon( weapon ) )
	{
		if ( issubstr( weapon, "knife_ballistic_" ) )
		{
			self notify( "zmb_lost_knife" );
		}
		self givestartammo( weapon );
		if ( !is_offhand_weapon( weapon ) )
		{
			self switchtoweapon( weapon );
		}
		return;
	}
	if ( is_melee_weapon( weapon ) )
	{
		current_weapon = maps\mp\zombies\_zm_melee_weapon::change_melee_weapon( weapon, current_weapon );
	}
	else if ( is_lethal_grenade( weapon ) )
	{
		old_lethal = self get_player_lethal_grenade();
		if ( isDefined( old_lethal ) && old_lethal != "" )
		{
			self takeweapon( old_lethal );
			unacquire_weapon_toggle( old_lethal );
		}
		self set_player_lethal_grenade( weapon );
	}
	else if ( is_tactical_grenade( weapon ) )
	{
		old_tactical = self get_player_tactical_grenade();
		if ( isDefined( old_tactical ) && old_tactical != "" )
		{
			self takeweapon( old_tactical );
			unacquire_weapon_toggle( old_tactical );
		}
		self set_player_tactical_grenade( weapon );
	}
	else if ( is_placeable_mine( weapon ) )
	{
		old_mine = self get_player_placeable_mine();
		if ( isDefined( old_mine ) )
		{
			self takeweapon( old_mine );
			unacquire_weapon_toggle( old_mine );
		}
		self set_player_placeable_mine( weapon );
	}
	if ( !is_offhand_weapon( weapon ) )
	{
		self maps\mp\zombies\_zm_weapons::take_fallback_weapon();
	}
	if ( primaryweapons.size >= weapon_limit )
	{
		if ( is_melee_weapon( current_weapon ) || is_placeable_mine( current_weapon ) || is_equipment( current_weapon ) )
		{
			current_weapon = undefined;
		}
		if ( isDefined( current_weapon ) )
		{
			if ( !is_offhand_weapon( weapon ) )
			{
				if ( current_weapon == "tesla_gun_zm" )
				{
					level.player_drops_tesla_gun = 1;
				}
				if ( issubstr( current_weapon, "knife_ballistic_" ) )
				{
					self notify( "zmb_lost_knife" );
				}
				self takeweapon( current_weapon );
				unacquire_weapon_toggle( current_weapon );
			}
		}
	}
	if ( isDefined( level.zombiemode_offhand_weapon_give_override ) )
	{
		if ( self [[ level.zombiemode_offhand_weapon_give_override ]]( weapon ) )
		{
			return;
		}
	}
	if ( weapon == "cymbal_monkey_zm" )
	{
		self maps\mp\zombies\_zm_weap_cymbal_monkey::player_give_cymbal_monkey();
		self play_weapon_vo( weapon, magic_box );
		return;
	}
	else if ( issubstr( weapon, "knife_ballistic_" ) )
	{
		weapon = self maps\mp\zombies\_zm_melee_weapon::give_ballistic_knife( weapon, issubstr( weapon, "upgraded" ) );
	}
	else if ( weapon == "claymore_zm" )
	{
		self thread maps\mp\zombies\_zm_weap_claymore::claymore_setup();
		self play_weapon_vo( weapon, magic_box );
		return;
	}
	if ( isDefined( level.zombie_weapons_callbacks ) && isDefined( level.zombie_weapons_callbacks[ weapon ] ) )
	{
		self thread [[ level.zombie_weapons_callbacks[ weapon ] ]]();
		play_weapon_vo( weapon, magic_box );
		return;
	}
	if ( !is_true( nosound ) )
	{
		self play_sound_on_ent( "purchase" );
	}
	if ( is_true( magic_box ) && is_limited_weapon( weapon ) && level.limited_weapons[ weapon ] == 1 )
	{
		playsoundatposition( "mus_raygun_stinger", ( 0, 0, 0 ) );
	}
	if ( !is_weapon_upgraded( weapon ) )
	{
		self giveweapon( weapon );
	}
	else
	{
		self giveweapon( weapon, 0, self get_pack_a_punch_weapon_options( weapon ) );
	}
	acquire_weapon_toggle( weapon, self );
	self givestartammo( weapon );
	if ( !is_offhand_weapon( weapon ) )
	{
		if ( !is_melee_weapon( weapon ) )
		{
			self switchtoweapon( weapon );
		}
		else
		{
			self switchtoweapon( current_weapon );
		}
	}
	self play_weapon_vo( weapon, magic_box );

	self notify("weapon_ammo_change");
}

ammo_give( weapon )
{
    give_ammo = 0;

    if ( !is_offhand_weapon( weapon ) )
    {
        weapon = get_weapon_with_attachments( weapon );

        if ( isdefined( weapon ) )
        {
            stockmax = weaponstartammo( weapon );
			clipmax = weaponclipsize( weapon );
            ammocount = self getammocount( weapon );

			give_ammo = ammocount < (stockmax + clipmax);

			if (!give_ammo)
			{
				alt_weap = weaponaltweaponname( weapon );

				if ( "none" != alt_weap )
				{
					stockmax = weaponstartammo( alt_weap );
					clipmax = weaponclipsize( alt_weap );
					ammocount = self getammocount( alt_weap );

					give_ammo = ammocount < (stockmax + clipmax);
				}
			}
        }
    }
    else if ( self has_weapon_or_upgrade( weapon ) )
    {
        if ( self getammocount( weapon ) < weaponmaxammo( weapon ) )
            give_ammo = 1;
    }

    if ( give_ammo )
    {
        self play_sound_on_ent( "purchase" );
        self givemaxammo( weapon );
		self setWeaponAmmoClip( weapon, weaponClipSize(weapon) );
        alt_weap = weaponaltweaponname( weapon );

        if ( "none" != alt_weap )
		{
			self givemaxammo( alt_weap );
			self setWeaponAmmoClip( alt_weap, weaponClipSize(alt_weap) );
		}

		self notify("weapon_ammo_change");

        return true;
    }

    if ( !give_ammo )
        return false;
}

weapon_spawn_think()
{
	cost = maps\mp\zombies\_zm_weapons::get_weapon_cost( self.zombie_weapon_upgrade );
	ammo_cost = maps\mp\zombies\_zm_weapons::get_ammo_cost( self.zombie_weapon_upgrade );
	shared_ammo_weapon = undefined;
	second_endon = undefined;

	is_grenade = 0;
	if(weapontype( self.zombie_weapon_upgrade ) == "grenade")
	{
		is_grenade = 1;
	}

	if ( isDefined( self.stub ) )
	{
		second_endon = "kill_trigger";
		self.first_time_triggered = self.stub.first_time_triggered;
	}

	if ( isDefined( self.stub ) && is_true( self.stub.trigger_per_player ) )
	{
		self thread maps\mp\zombies\_zm_magicbox::decide_hide_show_hint( "stop_hint_logic", second_endon, self.parent_player );
	}
	else
	{
		self thread maps\mp\zombies\_zm_magicbox::decide_hide_show_hint( "stop_hint_logic", second_endon );
	}

	if ( is_grenade )
	{
		self.first_time_triggered = 0;
		hint = maps\mp\zombies\_zm_weapons::get_weapon_hint( self.zombie_weapon_upgrade );
		self sethintstring( hint, cost );
	}
	else if ( !isDefined( self.first_time_triggered ) )
	{
		self.first_time_triggered = 0;
		if ( isDefined( self.stub ) )
		{
			self.stub.first_time_triggered = 0;
		}
	}
	else if ( self.first_time_triggered )
	{
		if ( is_true( level.use_legacy_weapon_prompt_format ) )
		{
			self maps\mp\zombies\_zm_weapons::weapon_set_first_time_hint( cost, maps\mp\zombies\_zm_weapons::get_ammo_cost( self.zombie_weapon_upgrade ) );
		}
	}

	for ( ;; )
	{
		self waittill( "trigger", player );

		if ( !is_player_valid( player ) )
		{
			player thread ignore_triggers( 0.5 );
			continue;
		}

		if ( !is_grenade && !player maps\mp\zombies\_zm_magicbox::can_buy_weapon() )
		{
			wait 0.1;
			continue;
		}

		if ( isDefined( self.stub ) && is_true( self.stub.require_look_from ) )
		{
			toplayer = player get_eye() - self.origin;
			forward = -1 * anglesToRight( self.angles );
			dot = vectordot( toplayer, forward );
			if ( dot < 0 )
			{
				continue;
			}
		}

		if ( player has_powerup_weapon() )
		{
			wait 0.1;
			continue;
		}

		player_has_weapon = player maps\mp\zombies\_zm_weapons::has_weapon_or_upgrade( self.zombie_weapon_upgrade );
		if ( !player_has_weapon && is_true( level.weapons_using_ammo_sharing ) )
		{
			shared_ammo_weapon = player maps\mp\zombies\_zm_weapons::get_shared_ammo_weapon( self.zombie_weapon_upgrade );
			if ( isDefined( shared_ammo_weapon ) )
			{
				player_has_weapon = 1;
			}
		}

		if ( is_true( level.pers_upgrade_nube ) )
		{
			player_has_weapon = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_should_we_give_raygun( player_has_weapon, player, self.zombie_weapon_upgrade );
		}

		cost = maps\mp\zombies\_zm_weapons::get_weapon_cost( self.zombie_weapon_upgrade );
		if ( player maps\mp\zombies\_zm_pers_upgrades_functions::is_pers_double_points_active() )
		{
			cost = int( cost / 2 );
		}

		if ( !player_has_weapon )
		{
			if ( player.score >= cost )
			{
				if ( self.first_time_triggered == 0 )
				{
					self maps\mp\zombies\_zm_weapons::show_all_weapon_buys( player, cost, ammo_cost, is_grenade );
				}

				player maps\mp\zombies\_zm_score::minus_to_player_score( cost, 1 );
				bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, cost, self.zombie_weapon_upgrade, self.origin, "weapon" );
				level notify( "weapon_bought", player, self.zombie_weapon_upgrade );

				if ( self.zombie_weapon_upgrade == "riotshield_zm" )
				{
					player maps\mp\zombies\_zm_equipment::equipment_give( "riotshield_zm" );
					if ( isDefined( player.player_shield_reset_health ) )
					{
						player [[ player.player_shield_reset_health ]]();
					}
				}
				else if ( self.zombie_weapon_upgrade == "jetgun_zm" )
				{
					player maps\mp\zombies\_zm_equipment::equipment_give( "jetgun_zm" );
				}
				else if ( is_lethal_grenade( self.zombie_weapon_upgrade ) )
				{
					player takeweapon( player get_player_lethal_grenade() );
					player set_player_lethal_grenade( self.zombie_weapon_upgrade );
				}

				str_weapon = self.zombie_weapon_upgrade;

				if ( is_true( level.pers_upgrade_nube ) )
				{
					str_weapon = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_weapon_upgrade_check( player, str_weapon );
				}

				player maps\mp\zombies\_zm_weapons::weapon_give( str_weapon );
				player maps\mp\zombies\_zm_stats::increment_client_stat( "wallbuy_weapons_purchased" );
				player maps\mp\zombies\_zm_stats::increment_player_stat( "wallbuy_weapons_purchased" );
			}
			else
			{
				play_sound_on_ent( "no_purchase" );
				player maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "no_money_weapon" );
			}
		}
		else
		{
			str_weapon = self.zombie_weapon_upgrade;

			if ( isDefined( shared_ammo_weapon ) )
			{
				str_weapon = shared_ammo_weapon;
			}

			if ( is_true( level.pers_upgrade_nube ) )
			{
				str_weapon = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_weapon_ammo_check( player, str_weapon );
			}

			if ( is_true( self.hacked ) )
			{
				if ( !player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
				{
					ammo_cost = maps\mp\zombies\_zm_weapons::get_upgraded_ammo_cost( str_weapon );
				}
				else
				{
					ammo_cost = maps\mp\zombies\_zm_weapons::get_ammo_cost( str_weapon );
				}
			}
			else if ( player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
			{
				ammo_cost = maps\mp\zombies\_zm_weapons::get_upgraded_ammo_cost( str_weapon );
			}
			else
			{
				ammo_cost = maps\mp\zombies\_zm_weapons::get_ammo_cost( str_weapon );
			}

			if ( is_true( player.pers_upgrades_awarded[ "nube" ] ) )
			{
				ammo_cost = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_override_ammo_cost( player, self.zombie_weapon_upgrade, ammo_cost );
			}

			if ( player maps\mp\zombies\_zm_pers_upgrades_functions::is_pers_double_points_active() )
			{
				ammo_cost = int( ammo_cost / 2 );
			}

			if ( str_weapon == "riotshield_zm" )
			{
				play_sound_on_ent( "no_purchase" );
			}
			else if ( player.score >= ammo_cost )
			{
				if ( self.first_time_triggered == 0 )
				{
					self maps\mp\zombies\_zm_weapons::show_all_weapon_buys( player, cost, ammo_cost, is_grenade );
				}

				if ( player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
				{
					player maps\mp\zombies\_zm_stats::increment_client_stat( "upgraded_ammo_purchased" );
					player maps\mp\zombies\_zm_stats::increment_player_stat( "upgraded_ammo_purchased" );
				}
				else
				{
					player maps\mp\zombies\_zm_stats::increment_client_stat( "ammo_purchased" );
					player maps\mp\zombies\_zm_stats::increment_player_stat( "ammo_purchased" );
				}

				if ( str_weapon == "riotshield_zm" )
				{
					if ( isDefined( player.player_shield_reset_health ) )
					{
						ammo_given = player [[ player.player_shield_reset_health ]]();
					}
					else
					{
						ammo_given = 0;
					}
				}
				else if ( player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
				{
					ammo_given = player maps\mp\zombies\_zm_weapons::ammo_give( level.zombie_weapons[ str_weapon ].upgrade_name );
				}
				else
				{
					ammo_given = player maps\mp\zombies\_zm_weapons::ammo_give( str_weapon );
				}

				if ( ammo_given )
				{
					player maps\mp\zombies\_zm_score::minus_to_player_score( ammo_cost, 1 );
					bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, ammo_cost, str_weapon, self.origin, "ammo" );
				}
			}
			else
			{
				play_sound_on_ent( "no_purchase" );

				if ( isDefined( level.custom_generic_deny_vo_func ) )
				{
					player [[ level.custom_generic_deny_vo_func ]]();
				}
				else
				{
					player maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "no_money_weapon" );
				}
			}
		}

		if ( isDefined( self.stub ) && isDefined( self.stub.prompt_and_visibility_func ) )
		{
			self [[ self.stub.prompt_and_visibility_func ]]( player );
		}
	}
}

get_upgraded_ammo_cost( weapon_name )
{
	if ( isDefined( level.zombie_weapons[ weapon_name ].upgraded_ammo_cost ) )
	{
		return level.zombie_weapons[ weapon_name ].upgraded_ammo_cost;
	}

	return 2500;
}

weapon_set_first_time_hint( cost, ammo_cost )
{
	// remove
}

makegrenadedudanddestroy()
{
	self endon( "death" );

	self notify( "grenade_dud" );
	self makegrenadedud();

	if ( isDefined( self ) )
	{
		self delete();
	}
}

createballisticknifewatcher_zm( name, weapon )
{
	watcher = self maps\mp\gametypes_zm\_weaponobjects::createuseweaponobjectwatcher( name, weapon, self.team );
	watcher.onspawn = scripts\zm\replaced\_zm_weap_ballistic_knife::on_spawn;
	watcher.onspawnretrievetriggers = maps\mp\zombies\_zm_weap_ballistic_knife::on_spawn_retrieve_trigger;
	watcher.storedifferentobject = 1;
	watcher.headicon = 0;
}