Create a new version of paste:

-- General infection settings
zombie_team = 1 -- 0 is red, 1 is blue
human_team = 1 - zombie_team
zombie_speed = 1.5 -- zombie speed
lastman_speed = 1.4 -- last man speed
lastman_dmgmodifier = 1.5 -- damage modifier for the last man (on top of human damage)
lastman_invistime = 10 -- in seconds
human_speed = 1.0 -- speed when not infected
zombie_count = 1 -- if value is less than 1 is it used as a percentage, more than or equal to one is absolute count
last_man_next_zombie = true -- if this value is true the last man standing becomes the next zombie, if not it's random
max_zombie_count = 2 -- this caps what the zombie count would be w/ ratio (nil is disable)
lastman_invulnerable = 5 -- time (in seconds) the last man is invulnerable for: replace with nil to disable
alphazombie_frag_count = 0 -- number of frag nades they spawn with
alphazombie_plasma_count = 0 -- number of plasma nades they spawn with
zombie_frag_count = 0 -- number of frag nades they spawn with
zombie_plasma_count = 0 -- number of plasma nades they spawn with
alphazombie_clip_count = 0 -- number of shots in clip
alphazombie_ammo_count = 0 -- backpack ammo they get
zombie_clip_count = 0 -- number of shots in clip for zombies once there are not only alpha zombies
zombie_ammo_count = 0 -- backpack ammo zombies once there are not only alpha zombies

-- Game messages
zombie_message = "YOU'RE A ZOMBIE. KILL THE HUMANS!"
human_message = "YOU'RE A HUMAN. SURVIVE."
rejoin_message = "Please don't leave and rejoin. You've been put back onto your last team."
infected_message = " has been infected!"
teamkill_message = "Don't team kill..."
blockteamchange_message = "You're not allowed to change team."
zombieinvis_message = "The zombies are invisible for 20 seconds!"
timer_team_change_msg = "Thank you. The game will now continue"

-- Don't modify below variables unless you know what you're doing
cur_zombie_count = 0
cur_human_count = 0
alpha_zombie_count = 0
human_time = {}
cur_players = 0
cur_last_man = nil
last_man_hash = 0
processid = 0
game_started = false
allow_change = false
new_game_timer = 0
player_change_timer = 0
oddball_weap = {}
balls = {}
last_hill_time = {}
hash_table = {}
inhill_time = {}

-- This function is required for scripts to run on Phasor (including and after 01.00.03.104)
-- You should return the minimum required version of Phasor
-- Official releases:
--   01.00.03.104 - 3104
--   01.00.10.057 - 10057
function GetRequiredVersion()
	return 10057
end

-- called when the script is loaded
function OnScriptLoad(process)

	processid = process

	-- assume a game is running
	game_started = true

	humantimer = registertimer(1000, "HumanTimer")

	for i = 0,15 do
		if getplayer(i) ~= nil then
			local m_object = getobject(getplayerobjectid(i))
			if m_object ~= nil then
				local weapID = readdword(m_object, 0x118)
				local weap = getobject(weapID)
				local tagName = getobjecttag(weapID)
				if tagName == "weapons\\ball\\ball" then
					oddball_weap[i] = weapID
				end
			end
		end
	end

	-- recalculate team counters
	cur_zombie_count = getteamsize(zombie_team)
	cur_human_count = getteamsize(human_team)
	cur_players = cur_zombie_count + cur_human_count

	-- recalculate how many "alpha" zombies there are
	alpha_zombie_count = getalphacount()

	-- load the last man hash (if there is one)
	local file = io.open("lasthash_" .. processid .. ".tmp", "r")

	if (file ~= nil) then

		-- read the ip
		last_man_hash = file:read("*line")

		file:close()

		-- delete the file
		os.remove("lasthash_" .. processid .. ".tmp")
	end
end

-- called when the script is unloaded
-- Do not return a value
function OnScriptUnload()

end

function getobjecttag(object)
	local m_object = getobject(object)
	local object_map_id = readdword(m_object, 0x0)

	local map_base = readdword(0x63525c, 0x0)
	local map_tag_count = todec(endian(map_base, 0xC, 0x3))
	local tag_table_base = map_base + 0x28
	local tag_table_size = 0x20

	for i=0,(map_tag_count - 1) do
		local tag_id = todec(endian(tag_table_base, 0xC + (tag_table_size * i), 0x3))

		if tag_id == object_map_id then
			tag_name_address = endian(tag_table_base, 0x10 + (tag_table_size * i), 0x3)
			tag_name = readtagname("0x" .. tag_name_address)

			return tag_name
		end
	end
end

function endian(address, offset, length)

        local data_table = {}
        local data = ""

        for i=0,length do

                local hex = string.format("%X", readbyte(address, offset + i))

                if tonumber(hex, 16) < 16 then
                        hex = 0 .. hex
                end

                table.insert(data_table, hex)

        end

        for k,v in pairs(data_table) do
                data = v .. data
        end

        return data

end

function todec(number)
	return tonumber(number, 16)
end

-- called when a game is starting (before any players join)
-- Do not return a value.
function OnNewGame(map)

	-- reset our variables
	cur_zombie_count = 0
	cur_human_count = 0
	cur_players = 0

	-- the game hasn't started yet, will once timer runs down
	game_started = false
	new_game_timer = registertimer(2000, "NewGameTimer")
	
        if map == "putput" or map == "longest" or map == "beavercreek" or map == "chillout" then
		zombie_speed = 1.35
		lastman_speed = 1.2
	if map == "dangercanyon" or map == "gephyrophobia" or map == "timberland" or map == "deathisland" or map == "bloodgulch" then
                zombie_speed = 1.8
                lastman_speed = 1.6 
        
end            
end
end


-- called when a game is ending
-- Do not return a value.
function OnGameEnd(mode)
	-- mode 1 = score menu (F1) is being displayed to clients, they are still ingame
	-- mode 2 = post game menu appeared
	-- mode 3 = players can quit via the post game score card

	-- remove the new game timer (if still active)
	if mode == 1 then
		removetimer(new_game_timer)
		removetimer(humantimer)
	end
end

-- Called when there is chat within the server
-- It must return a value which indicates whether or not the chat is sent.
function OnServerChat(player, chattype, message)
	return 1
end

-- Called when a server command is being executed
-- It must return a value which indicates whether or not the command should be processed
-- Note: It is only called when an authenticated (and allowed) player attempts to use the command.
--		 player is -1 when being executed via the server console.
function OnServerCommand(player, command)
	local allow = 1
	local tokencount = getcmdtokencount(command)
	if tokencount > 0 then
		local cmd = getcmdtoken(command, 0)
		if cmd == "sv_changeteam" and tokencount == 2 then
			local player = getcmdtoken(command, 1)
			player = rresolveplayer(player)
			if getplayer(player) ~= nil then
				local cur_team = getteam(player)
				if cur_team == zombie_team then
					makehuman(player, true)
					privatesay(player, human_message)
				elseif cur_team == human_team then
					makezombie(player, true)
					privatesay(player, zombie_message)
				end
				hprintf("The player's team has been changed.")
			else
				hprintf("The specified player is invalid")
			end

			allow = 0
		elseif cmd == "sv_map_reset" then
			for i = 0,15 do
				local m_player = getplayer(i)
				if m_player ~= nil then
					local m_object = getobject(getplayerobjectid(i))
					if m_object ~= nil then
						local team = getteam(i)
						if team == zombie_team then
						--	destroyweaps(i)
						end
					end
				end
			end
		end
	end
	return allow
end


-- Called when a player's team is being chosen as the join the server.
-- It must return a value which indicates the team the player is to be put on.
-- Note: this function being called doesn't guarantee that the player will be able to successfully join.
function OnTeamDecision(cur_team)
	local dest_team = zombie_team

	if game_started then
		if cur_players == 0  then -- if no zombies make them human
			dest_team = human_team
		elseif cur_zombie_count > 0 and cur_human_count == 0 then
			dest_team = human_team
		end
	end

	return dest_team
end

-- Called when a player joins the server.
-- Do not return a value.
function OnPlayerJoin(player, team)

	-- update the player counts
	cur_players = cur_players + 1

	local thisTeamSize = 0 -- used so we don't create empty teams for rejoining players
	if team == zombie_team then
		cur_zombie_count = cur_zombie_count + 1
		thisTeamSize = cur_zombie_count
	else
		cur_human_count = cur_human_count + 1
		thisTeamSize = cur_human_count
	end

	alpha_zombie_count = getalphacount()

	local thisHash = gethash(player)
	local alreadyExists = false

	-- check if the player has joined this game previously
	for k,v in pairs(hash_table) do
		if thisHash == k then

			if thisTeamSize > 1 then
				if v ~= team then changeteam(player, 0)	end

				--privatesay(player, rejoin_message)
				team = v
			end
			alreadyExists = true

			break
		end
	end

	-- add team entry for this hash
	if alreadyExists == false then
		hash_table[thisHash] = team
	end

	if game_started == true then

		-- check if the player is a zombie
		if team == zombie_team then
			makezombie(player, false)
			privatesay(player, zombie_message)
		else
			-- if we're at last man, make this player a zombie
			if cur_last_man ~= nil then
				makezombie(player, true)
				privatesay(player, zombie_message)
			else
				makehuman(player, false)
				privatesay(player, human_message)
			end
		end
		privatesay(i, "Welcome to Wizard's Zombie Server!")
		privatesay(i, "The hill is a safe-zone! Use it for quick getaways!")
		checkgamestate(-1)
	else
		registertimer(10000, "MsgTimer", player)
	end
end

function MsgTimer(id, count, player)
	privatesay(player, "Welcome to SPN zombies!")
	privatesay(player, "Have fun!")
	return 0
end

-- Called when a player the server.
-- Do not return a value.
function OnPlayerLeave(player, team)
	if team == zombie_team then
		local m_object = getobject(getplayerobjectid(player))
		if m_object ~= nil then
			for i = 0,3 do
				local weapID = readdword(m_object, 0x2F8 + i*4)
				local weap = getobject(weapID)
				if weap ~= nil then
					registertimer(0, "destroyweaps", weapID)
				end
			end
		end
		cur_zombie_count = cur_zombie_count - 1
	elseif team == human_team then
		cur_human_count = cur_human_count - 1
	end

	-- if last man is leaving, reset it
	if cur_last_man == player then
		cur_last_man = nil
	end

	cur_players = cur_players - 1

	checkgamestate(-1)

	-- update team within table
	local thisHash = gethash(player)
	hash_table[thisHash] = team
end

-- called when a player kills another, 'killer' is the index of the killing player, 'victim' is the index of the dead player
-- Do not return a value.
function OnPlayerKill(killer, victim, mode)

	local v_team = getteam(victim)
	
	if v_team == zombie_team then
		local m_victim = getplayer(victim)
		local v_objId = readdword(m_victim, 0x34)
		local v_object = getobject(v_objId)
		for i = 0,3 do
			local m_weapId = readdword(v_object, 0x2F8 + i * 4)
			local m_weapon = getobject(m_weapId)
			defaultammo(m_weapId)
		end
	end

	if game_started then

		local team = getteam(victim)
		if mode == 0 then -- server kill
		elseif mode == 1 then -- fall damage
			if team ~= zombie_team then
				local name = getname(victim)
				say(name .. infected_message)
				makezombie(victim, false)
			end
		elseif mode == 2 then -- killed by guardians
		elseif mode == 3 then -- killed by vehicle
		elseif mode == 4 then -- killed by another player

			local killer_team = getteam(killer)
			-- check to see if a zombie killed them
			if killer_team == zombie_team and team == human_team then
				name = getname(victim)
				say(name .. infected_message)
				makezombie(victim, false)
				--privatesay(victim, zombie_message)
			end
		elseif mode == 5 then -- betrayed
		elseif mode == 6 then -- suicide
			-- if they're human, make them zombies
			if team == human_team then
				name = getname(victim)
				say(name .. infected_message)
				makezombie(victim, false)
			end
		end
	end
end

function defaultammo(m_weapId)

	local tagType, tagName = getobjecttag(m_weapId)
	local m_weapon = getobject(m_weapId)
	say(tagName)
	if tagName == "weapons\\assault rifle\\assault rifle" then
		writeword(m_weapon, 0x2B6, 180)
		writeword(m_weapon, 0x2B8, 60)
	elseif tagName == "weapons\\pistol\\pistol" then
		writeword(m_weapon, 0x2B6, 48)
		writeword(m_weapon, 0x2B8, 12)
	elseif tagName == "weapons\\shotgun\\shotgun" then
		writeword(m_weapon, 0x2B6, 12)
		writeword(m_weapon, 0x2B8, 12)
	elseif tagName == "weapons\\sniper rifle\\sniper rifle" then
		writeword(m_weapon, 0x2B6, 8)
		writeword(m_weapon, 0x2B8, 4)
	end
	
	updateammo(m_weapId)
end

-- called when a player gets a double kill, killing spree etc
-- see Phasor documentation for multiplier values
function OnKillMultiplier(player, multiplier)
end

-- Called when a player s (after object is created, before players are notified)
-- Do not return a value
function OnPlayerSpawn(player, m_objectId)

	local team = getteam(player)

	if team == zombie_team then

		local m_objectId = getplayerobjectid(player)
		local m_object = getobject(m_objectId)
		if m_object ~= nil then
			-- set nade counts
			writebyte(m_object, 0x31E, zombie_frag_count)
			writebyte(m_object, 0x31F, zombie_plasma_count)

			-- set the ammo
			local clipcount = alphazombie_clip_count
			local ammocount = alphazombie_ammo_count

			-- set ammo counts for zombies when others have been infected
			if cur_zombie_count > alpha_zombie_count then
				clipcount = zombie_clip_count
				ammocount = zombie_ammo_count
			else -- set alpha nades
				writebyte(m_object, 0x31E, alphazombie_frag_count)
				writebyte(m_object, 0x31F, alphazombie_plasma_count)
			end

			local bool = false
			for i=0,3 do
				local m_weaponId = readdword(m_object, 0x2F8 + (i*4))
				if bool == false and getobject(m_weaponId) ~= nil then
					local tagName = getobjecttag(m_weaponId)
					if tagName == "weapons\\ball\\ball" then
						oddball_weap[player] = m_weaponId
						bool = true
					end
				end
				if m_weaponId ~= 0xffffffff then
					local m_weapon = getobject(m_weaponId)
					if m_weapon ~= nil then
						-- set the ammo
						writeword(m_weapon, 0x2B6, ammocount)
						writeword(m_weapon, 0x2B8, clipcount)
						writefloat(m_weapon, 0x240, 1)
						-- force it to sync
						updateammo(m_weaponId)
					end
				end
			end
		end
	end
end

-- Called after clients have been notified of a player spawn
-- Do not return a value
function OnPlayerSpawnEnd(player, m_objectId)

end

-- Called when a player is attempting to .
-- A value must be returned. The return value indicates whether or not the player is allowed the change team.
-- Notes: If relevant is 1 the return value is considered, if it's 0 then the return value is ignored.
function OnTeamChange(relevant, player, team, dest_team)
	if relevant == 1 then

		if allow_change == false then
			privatesay(player, blockteamchange_message)
		elseif dest_team == zombie_team then
			-- this is so memory is updated for processing
			-- when relevant is 0 OnTeamChange is called once the changes
			-- have been committed
			changeteam(player, 1)
		end

		-- we don't let people change team
		return 0


	elseif dest_team ~= team then -- we can't stop the person changing teams, bein done by an admin

		-- update team counts
		if dest_team == zombie_team then
			cur_human_count = cur_human_count - 1
			cur_zombie_count = cur_zombie_count + 1
		elseif dest_team == human_team then
			cur_human_count = cur_human_count + 1
			cur_zombie_count = cur_zombie_count - 1
		end

		-- they're allowed to change if the timer is active, if it is disable it
		if allow_change == true and dest_team == zombie_team then

			allow_change = false
			-- remove change timer
			removetimer(player_change_timer)
			player_change_timer = 0

			say(timer_team_change_msg)
		end

		-- check if the game has started yet
		if game_started == true then

			-- set attributes
			if dest_team == zombie_team then
				makezombie(player, false)
			elseif dest_team == human_team then
				makehuman(player, false)
			end

			checkgamestate(player)
		end

		-- update team withf
		local thisHash = gethash(player)
		hash_table[thisHash] = dest_team
	end

	return 1
end

function OnClientUpdate(player, m_objectId)
	local m_player = getplayer(player)
	local m_object = getobject(m_objectId)
	local hash = gethash(player)
	if m_object ~= nil then
		local team = readbyte(m_player, 0x20)
		if team == zombie_team then
			local obj_crouch = readbyte(m_object, 0x2A0)
			if obj_crouch == 3 then
				applycamo(player, 5)
			end
			--[[local shooting = readbit(m_object, 0x209, 4)
			local nading2 = readbit(m_object, 0x209, 2)
			local nading = readbit(m_object, 0x209, 3)
			if shooting == 1 or nading == 1 then
				local weapID = readdword(m_object, 0x2FC)
				local weap = getobject(weapID)
				if weap ~= nil then
					weapID = oddball_weap[player]
					local m_player = getplayer(player)
					if m_player ~= nil then
						if weapID == nil then
							oddball_weap[player] = createobject("weap", "weapons\\ball\\ball", 0, 0, false, 5, 5, 2)
							assignweapon(player, oddball_weap[player])
						else
							if getobject(weapID) ~= nil then
								if IsBall(weapID) then
									assignweapon(player, weapID)
								else
									oddball_weap[player] = createobject("weap", "weapons\\ball\\ball", 0, 0, false, 5, 5, 2)
									assignweapon(player, oddball_weap[player])
								end
							else
								oddball_weap[player] = createobject("weap", "weapons\\ball\\ball", 0, 0, false, 5, 5, 2)
								assignweapon(player, oddball_weap[player])
							end
						end
					end
				end
			end--]]
		end
		if tonumber(human_time[hash]) ~= nil then
			local hill_time = readword(m_player, 0xC4)
			if tonumber(hill_time) ~= nil then
				writeword(m_player, 0xC4, tonumber(human_time[hash])*30)
			end
		else
			human_time[hash] = 0
		end
	end
	writedword(0x639BD0, 0x0, 0)
	writedword(0x639BD0, 0x1, 0)
end

function IsBall(weapID)
	for i = 1,#balls do
		if balls[i] == weapID then
			return true
		end
	end
end

--[[function GiveOddball(id, count, player, weapID)
	local m_player = getplayer(player)
	if m_player ~= nil then
		if weapID == nil then
			oddball_weap[player] = createobject("weap", "weapons\\ball\\ball", 0, 0, false, 5, 5, 2)
			assignweapon(player, oddball_weap[player])
			return 0
		else
			local m_object = getobject(getplayerobjectid(player))
			if m_object ~= nil then
				if getobject(weapID) ~= nil then
					local tagName = getobjecttag(weapID)
					if tagName == "weapons\\ball\\ball" then
						assignweapon(player, weapID)
					else
						oddball_weap[player] = createobject("weap", "weapons\\ball\\ball", 0, 0, false, 5, 5, 2)
						assignweapon(player, oddball_weap[player])
					end
				else
					oddball_weap[player] = createobject("weap", "weapons\\ball\\ball", 0, 0, false, 5, 5, 2)
					assignweapon(player, oddball_weap[player])
				end
			end
			return 0
		end
	end
	return 0
end--]]


-- Called when a player interacts with an object
-- It can be called while attempting to pick the object up
-- It is also called when standing above an object so can be called various times quickly
function OnObjectInteraction(player, m_ObjectId, tagType, tagName)

	local response = 1

	if game_started == true then

		-- regardless of the team, stop people taking the flag
		if tagType == "weap" then
			if tagName == "weapons\\flag\\flag" then
				response = 0
			elseif tagName == "weapons\\ball\\ball" then
				local team = getteam(player)
				if team == zombie_team then
					return 1
				else
					return 0
				end
			end
		end

		if response == 1 then

			local team = getteam(player)

			if team == zombie_team then

				-- we want to stop zombies picking up weapons
				if tagType == "weap" then
					response = 0
				elseif tagType == "eqip" then

					if tagName == "weapons\\frag grenade\\frag grenade" or tagName == "weapons\\plasma grenade\\plasma grenade" then
						response = 0 -- don't let them pick the nades
					elseif tagName == "powerups\\active camouflage" then

						-- check if the picking player is already invisible
						local m_player = getplayer(player)
						if m_player ~= nil then

							local m_playerObjId = readdword(m_player, 0x34)
							local m_object = getobject(m_playerObjId)
							if m_object ~= nil then

								local camoFlag = readdword(m_object, 0x204)
								if camoFlag ~= 0x51 then

									-- check if zombies are to be made invisible
									local doInvis = getrandomnumber(1, 10)

									if doInvis > 5 then

										-- make the whole zombie team invis for 20 seconds
										for x = 0,15 do

											local team = getteam(x)

											if team == zombie_team and x ~= player then
												--hprintf("applying camo to player " .. x)
												applycamo(x, 30.00)
											end
										end

										say(zombieinvis_message)
									end
								end
							end
						end
					end
				end
			end
		end
	end
	return response
end

-- Called when a player attempts to reload their weapon.
-- A value must be returned. The return value indicates whether or not the player is allowed to reload.
-- Notes: If player is -1 then the weapon being reload wasn't located (it could be a vehicle's weapon)
function OnWeaponReload(player, weapon)
	return 1
end

-- Called when a player attempts to enter a vehicle.
-- A value must be returned. The return value indicates whether or not the player is allowed to enter.
function OnVehicleEntry(relevant, player, vehicleId, vehicle_tag, seat)

	local response = 1
	if game_started and relevant == 1 then

		local team = getteam(player)
		if team == zombie_team then
			response = 0
		end
	end

	return response
end

function OnVehicleEject(player, forceEject)
	return 1
end

-- Called when damage is being done to an object.
-- This doesn't always need to be a player.
-- Do not return a value
function OnDamageLookup(receiving_obj, causing_obj, tagdata, tagname)

	-- Resolve the object ids into player ids
	-- Remember, the damage doesn't always need to be done by a player.
	local receiver = objecttoplayer(receiving_obj)
	local causer = objecttoplayer(causing_obj)

	-- We want to amplify human damage, so make sure the causer is human
	if causer ~= nil then

		local c_team = getteam(causer)
		-- Make sure the team was found
		if c_team ~= nil then

			-- Check if it's a human causing the damage
			if c_team == human_team then

				-- It's human damage, read the current damage the weapon has
				local min_dmg = readfloat(tagdata, 0x1D0)
				local max_dmg_min = readfloat(tagdata, 0x1D4)
				local max_dmg_max = readfloat(tagdata, 0x1D8)

				-- This is used to increase human damage (for last man)
				local modifier = 1.0

				-- Check if we're up to last man
				if cur_last_man ~= nil then
					-- Change the damage modifier to the last man's
					modifier = lastman_dmgmodifier
				end

				-- Change the damage that will be done
				writefloat(tagdata, 0x1D0, min_dmg * 2 * modifier)
				writefloat(tagdata, 0x1D4, max_dmg_min * 2 * modifier)
				writefloat(tagdata, 0x1D8, max_dmg_max * 2 * modifier)

			-- It's a zombie causing the damage
			elseif c_team == zombie_team then

				-- check if it is melee damage, if so increase it to instant kill
				local found = string.find(tagname, "melee", -5)

				-- We only want to increase zombie's melee damage
				if found ~= nil then

					-- make melee instant kill
					writefloat(tagdata, 0x1D0, 500)
					writefloat(tagdata, 0x1D4, 500)
					writefloat(tagdata, 0x1D8, 500)

				end
			end
		end
	end
end

-- Called when a player is being assigned a weapon (usually when they spawn)
-- A value must be returned. The return value is the id of the weapon they're to spawn with. Return zero if the weapon shouldn't change.
-- Notes: 	This is called for all weapon spawns the player has
--			This is also called with player 255 when vehicles are being assigned weapons.
-- 			This is only considered if in gametype, the weapon set is 'generic' if not this has no effect.
function OnWeaponAssignment(player, object, count, tag)

	local actualWeapon = 0
	local team = getteam(player)
	local weapons = {"weapons\\assault rifle\\assault rifle", "weapons\\shotgun\\shotgun", "weapons\\pistol\\pistol", "weapons\\sniper rifle\\sniper rifle"}

	if team == zombie_team then
		local rand = getrandomnumber(1, #weapons + 1)
		actualWeapon = lookuptag("weap", weapons[rand])
	end

	return actualWeapon
end

function readtagname(address)

        local char_table = {}
        local i = 0
        local string = ""

        while readbyte(address, i) ~= 0 do
                table.insert(char_table, string.char(readbyte(address, i)))
                i = i + 1
        end

        for k,v in pairs(char_table) do
                string = string .. v
        end

        return string

end

-- Called when an object is created
-- Do not return a value.
function OnObjectCreation(m_objectId, player_owner, tag)
	if tag == "weapons\\ball\\ball" then
		table.insert(balls, m_objectId)
	elseif tag == "weapons\\rocket launcher\\rocket launcher" or tag == "weapons\\plasma_cannon\\plasma_cannon" or tag == "weapons\\flamethrower\\flamethrower" then
		registertimer(10, "DeleteHeavies", m_objectId)
	end
end

function DeleteHeavies(id, count, m_objId)

	destroyobject(m_objId)
	return 0
end

-- The below functions are used internally within the Lua script
function NewGameTimer(id, count)

	if count == 5 then

		say("The game is starting...")

		if cur_players ~= 0 then

			local newgame_zombie_count = 0

			-- by default make all players human
			for x=0,15 do
				local thisTeam = getteam(x)
				local hash = gethash(x)
				if thisTeam ~= nil then
					if thisTeam == zombie_team then
						changeteam(x, 0)
					end
					human_time[hash] = 0
				end
			end

			local possible_count = cur_players

			-- make players zombie until the count has been met
			local finalZombies = 0

			if zombie_count >= 1 then
				finalZombies = zombie_count
			else
				finalZombies = round((possible_count * zombie_count) + 0.5)
			end

			-- make last man zombie
			local last_man_index = -1

			-- check if the last man is to be made a zombie
			-- if so find who was last man
			if last_man_next_zombie == true and cur_players > 1 then

				-- loop through all hashes and check if any match the last man
				for i=0,15 do
					local hash = gethash(i)

					if getplayer(i) ~= nil then
						if last_man_hash == hash then

							-- make them a zombie and save their info
							makezombie(i, true)
							newgame_zombie_count = 1
							last_man_index = i

							break
						end
					end
				end
			end

			-- reset last man
			last_man_hash = 0

			--hprintf("Expecting " .. finalZombies .. " zombies. Cur players " .. cur_players .. " possibles " .. possible_count)

			if finalZombies == cur_players then -- if 0 players they will be human
				finalZombies = finalZombies - 1
			elseif finalZombies > possible_count then -- fix the count
				finalZombies = possible_count
			elseif max_zombie_count ~= nil and finalZombies > max_zombie_count then -- cap the zombie count
				finalZombies = max_zombie_count
			elseif finalZombies < 0 then
				finalZombies = 0
			end

			-- set counters such that changeteam wont end the game
			cur_zombie_count = 16
			cur_human_count = 16

			--hprintf("Expecting " .. finalZombies .. " zombies. Cur players " .. cur_players .. " possibles " .. possible_count)

			-- loop through the players, randomly selecting ones to become
			-- zombies
			while (newgame_zombie_count < finalZombies) do

				-- randomly choose a player
				local newzomb = ChooseRandomPlayer(zombie_team)

				if newzomb == nil then
					break
				elseif newzomb ~= last_man_index then

					makezombie(newzomb, true)
					newgame_zombie_count = newgame_zombie_count + 1
				end
			end

			-- fix the team counters
			cur_zombie_count = newgame_zombie_count
			cur_human_count = cur_players - finalZombies

			-- reset the map
			svcmd("sv_map_reset")

			-- loop through and tell players which team they're on
			for i=0,15 do

				local pteam = getteam(i)
				if pteam ~= nil then
					-- check if they're a zombie
					if pteam == zombie_team then
						privatesay(i, zombie_message)
					else
						privatesay(i, human_message)
					end
				end
			end

		end

		game_started = true

		return 0 -- remove timer
	else
		say("The game will start in " .. 10 - 2*count .. " seconds.")

		return 1 -- keep timer
	end
end

function PlayerChangeTimer(id, count)
	if count ~= 10 then

		local zombsize = cur_zombie_count

		if allow_change == false or zombsize > 0 then

			allow_change = false

			say("Thank you, the game can continue.")

			return 0
		end

		say("In " .. 10 - count .. " seconds a player will be forced to become a zombie.")

		return 1
	else -- timer up, force team change

		allow_change = false

		-- pick a human and make them zombie.
		local newZomb = ChooseRandomPlayer(zombie_team)

		if newZomb ~= nil then
			makezombie(newZomb, true)
			privatesay(player, zombie_message)
		end

		return 0
	end
end

-- this function searches through current players and selects a random one
function ChooseRandomPlayer(excludeTeam)

	local t = {}

	-- loop through all 16 possible spots and add to table
	for i=0,15 do

		-- check if the player exists
		local team = getteam(i)

		if team ~= nil and team ~= excludeTeam then
			table.insert(t, i)
		end

	end

	if #t > 0 then
		-- generate a random number that we will use to select a player
		local tableCount = 	table.getn(t)
		local r = getrandomnumber(1, tableCount+1)
		return t[r]
	else
		return nil
	end
end

function RemoveLastmanProtection(id, count, m_object)
	writebit(m_object, 0x10, 7, 0)
	return 0
end

-- there are no zombies left
function noZombiesLeft()

	allow_change = true
	say("There are no zombies left. Someone needs to change team, otherwise a random player will be forced to.")
	player_change_timer = registertimer(1000, "PlayerChangeTimer")

end

-- called when its the last man
function onlastman()

	-- lookup the last man
	for x=0,15 do
		local team = getteam(x)

		if team == human_team then

			cur_last_man = x
			-- give the last man speed and extra ammo
			setspeed(x, lastman_speed)

			-- find the last man's weapons
			local m_player = getplayer(x)

			if m_player ~= nil then
				local m_ObjId = readdword(m_player, 0x34)

				-- find the player's object
				local m_object = getobject(m_ObjId)

				if m_object ~= nil then

					if lastman_invulnerable ~= nil and lastman_invulnerable > 0 then
						-- setup the invulnerable timer
						writebit(m_object, 0x10, 7, 1)
						registertimer(lastman_invulnerable * 1000, "RemoveLastmanProtection", m_object)
					end

					-- give all weapons 600 ammo
					for i=0,3 do
						local m_weaponId = readdword(m_object, 0x2F8 + (i*4))

						if m_weaponId ~= 0xffffffff then

							-- get the weapons memory address
							local m_weapon = getobject(m_weaponId)

							if m_weapon ~= nil then
								-- set the ammo
								writeword(m_weapon, 0x2B6, 600)
							end
						end
					end
				end
			end
		end
	end

	if cur_last_man ~= nil then

		local lastman_name = getname(cur_last_man)
		local msg = string.format("%s is the last man alive and is invisible for %.0f seconds!", lastman_name, lastman_invistime)
		say(msg)
		applycamo(cur_last_man, lastman_invistime)
	end


end

-- checks the game state, for last man, all zombies etc
-- called onteamchange, player join and leave
function checkgamestate(player)

	-- check if the game has started yet
	if game_started == true then

		local zombie_count = cur_zombie_count
		local human_count = cur_human_count
		--hprintf("zombie count " .. zombie_count)
		--hprintf("human count " .. human_count)

		-- if no humans, but there are zombies, end the game
		if human_count == 0 and zombie_count > 0 then
			all_players_zombies(player)
		elseif human_count > 1 and zombie_count == 0 then
			noZombiesLeft()
		elseif human_count == 1 and zombie_count > 0 and cur_last_man == nil then
			onlastman()
		elseif cur_last_man ~= nil and zombie_count == 0 then
			makehuman(cur_last_man, false)
			cur_last_man = nil
		end
	end
end

-- called when all players are zombies (no shit)
function all_players_zombies(player)

	-- if there is a last man, store their hash
	if player ~= -1 then
		last_man_hash = gethash(player)
		-- write the hash to file
		local file = io.open("lasthash_" .. processid .. ".tmp", "w")

		if (file ~= nil) then
			file:write(last_man_hash)
			file:close()
		end
	end

	-- move onto the next map
	svcmd("sv_map_next")
end

function makezombie(player, forcekill)

	-- change the player's speed
	setspeed(player, zombie_speed)

	local team = getteam(player)
	if team == human_team then
		changeteam(player, forcekill)
	end
end

function makehuman(player, forcekill)
	-- change the player's speed
	setspeed(player, human_speed)

	local team = getteam(player)
	if team == zombie_team then
		changeteam(player, forcekill)
	end
end

function getalphacount()
	-- recalculate how many "alpha" zombies there are
	if zombie_count < 1 then
		alpha_zombie_count = round((cur_players * zombie_count) + 0.5)
	else
		alpha_zombie_count = zombie_count
	end

	if alpha_zombie_count > max_zombie_count then
		alpha_zombie_count = max_zombie_count
	end
	return alpha_zombie_count
end


function round(num)
    under = math.floor(num)
    upper = math.floor(num) + 1
    underV = -(under - num)
    upperV = upper - num
    if (upperV > underV) then
        return under
    else
        return upper
    end
end