-- General infection settings
zombie_team = 1 -- 0 is red, 1 is blue
human_team = 1 - zombie_team
zombie_speed = 2 -- zombie speed
join_team = zombie_team -- the team that people will join as if a game is currently running
lastman_speed = 1.5 -- 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 (loaded ammo)
alphazombie_ammo_count = 0 -- backpack ammo they get (unloaded ammo)
alphazombie_battery_count = 0 -- stored as a percent (0 to 1, do NOT go over or under)
zombie_clip_count = 0 -- number of shots in clip for zombies once there are not only alpha zombies (loaded ammo)
zombie_ammo_count = 0 -- backpack ammo zombies once there are not only alpha zombies (unloaded ammo)
zombie_battery_count = 0 -- stored as a percent (0 to 1, do NOT go over or under)
infect_on_fall = true -- if this is set to true then people who die from fall damage will become zombies.
infect_on_guardians = false -- if this is set to true then people who get killed by the guardians will become zombies.
infect_on_suicide = true -- if this is set to true then people who kill themselves will become a zombie.
infect_on_betray = true -- if this is set to true then people who betray their teammates will become a zombie.
humans_allowed_in_vehis = true -- if this is set to false then humans cannot enter vehicles
zombies_allowed_in_vehis = false -- if this is set to false then zombies cannot enter vehicles.
zombies_invisible_on_crouch = true -- if this is set to true then zombies will be invisible when they crouch.
humans_invisible_on_crouch = false -- if this is set to true then humans will become invisible when they crouch.

--Zombie weapons.
-- Note: If you decide the player holds a flag or a ball, make sure the secondary, tertiary, and quarternary fields are "".
-- DO NOT make zombies hold multiple weapons if you want them to hold an oddball or a flag. If you do it will not work right, and it's entirely your fault.
zombie_weapon = {} -- don't touch this
zombie_weapon[1] = "weapons\\flag\\flag" -- Primary weapon for zombies
zombie_weapon[2] = "" -- Secondary weapon for zombies.
zombie_weapon[3] = "" -- Tertiary weapon for zombies.
zombie_weapon[4] = "" -- Quarternary weapon for 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"
in_hill_too_long_msg = " has been infected because they were in the hill too long!"
welcome_message = "Welcome to Zombies, brought to you by Phasor\nhttp://phasor.proboards.com"
koth_additional_welcome_msg = "The hill is a safezone! Use it for quick getaways!"
slayer_additional_welcome_msg = "The nav points are not just for decoration!\nThey will point to the last man surviving!"
lastman_message = "%s is the last human alive and is invisible for %.0f seconds!"
nozombiesleftmessage = "There are no zombies left. Someone needs to change team, otherwise a random player will be forced to."

-- 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
flagball_weap = {}
flags_balls_table = {}
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)

	for i = 1,4 do
		if zombie_weapon[i] == "weapons\\ball\\ball" or zombie_weapon[i] == "weapons\\flag\\flag" then
			oddball_or_flag = zombie_weapon[i]
		end
	end

	processid = process

	-- assume a game is running
	game_started = true
	game = GetGameAddresses()

	gametype = readbyte(gametype_base, 0x30)
	if gametype == 1 then
		gametype = "CTF"
		writedword(flag_respawn_addr, 0x0, 0xFFFFFFFF)
		registertimer(0, "DelayWriteCoords")
	elseif gametype == 2 then
		gametype = "Slayer"
		writebyte(gametype_base, 0x58, 3)
		speedtimer = registertimer(1000, "SpeedTimer")
	elseif gametype == 4 then
		gametype = "KOTH"
	end

	team_play = readbyte(gametype_base, 0x34) -- Confirmed. (Off = 0) (On = 1)

	if team_play == 1 then
		team_play = true
	else
		team_play = false
		zombie_team = 0
		function getteam(player)
			local m_player = getplayer(player)
			if m_player then
				local team = readbyte(m_player, 0x20)
				if team then
					return team
				end
			end
		end

		function changeteam(player, forcekill, team, updatecounters)
			local m_player = getplayer(player)
			local cur_team = readbyte(m_player, 0x20)
			if not team then
				if cur_team ~= zombie_team then
					team = zombie_team
				end
			end
			if m_player then
				if team == zombie_team then
					writebyte(m_player, 0x20, team)
					writebyte(m_player, 0x60, 3)
					if forcekill == true or forcekill == 1 then
						kill(player)
					end
					if team ~= cur_team then
						OnFFATeamChange(player, cur_team, team, updatecounters)
					end
					return
				elseif team then
					writebyte(m_player, 0x20, team)
				else
					for i = 1,15 do
						local bool
						for j = 0,15 do
							local m_player = getplayer(j)
							if m_player then
								local team = readbyte(m_player, 0x20)
								if team == i then
									bool = true
									break
								end
							end
						end
						if not bool then
							team = i
							writebyte(m_player, 0x20, i)
							break
						end
					end
				end
				for i = 0,17 do
					if i ~= 3 then
						local bool
						for j = 0,15 do
							local m_player = getplayer(j)
							if m_player then
								local color = readbyte(m_player, 0x60)
								if color == i then
									bool = true
									break
								end
							end
						end
						if not bool then
							writebyte(m_player, 0x60, i)
							break
						end
					end
				end
				if forcekill == true or forcekill == 1 then
					kill(player)
				end
			end
			if team ~= cur_team then
				OnFFATeamChange(player, cur_team, team, updatecounters)
			end
		end

		function OnFFATeamChange(player, cur_team, dest_team, updatecounters)
			-- update team counts
			if not updatecounters then
				if dest_team == zombie_team then
					cur_human_count = cur_human_count - 1
					cur_zombie_count = cur_zombie_count + 1
				elseif dest_team ~= zombie_team then
					cur_human_count = cur_human_count + 1
					cur_zombie_count = cur_zombie_count - 1
				end
			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 ~= zombie_team then
					makehuman(player, false)
				end--]]

				checkgamestate(player)
			end

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

	end

	starting_equipment = readbit(gametype_base, 0x38, 2) -- Generic = 0, Custom = 1

	if starting_equipment == 1 then
		starting_equipment = "Generic"
	else
		starting_equipment = "Custom"
	end

	humantimer = registertimer(1000, "HumanTimer")
	crouch_timer = registertimer(200, "invisCrouch")

	if oddball_or_flag then
		for i = 0,15 do
			if getplayer(i) then
				local m_object = getobject(getplayerobjectid(i))
				if m_object then
					local weapID = readdword(m_object, 0x118)
					local weap = getobject(weapID)
					local tagName = getobjecttag(weapID)
					if tagName == oddball_or_flag then
						flagball_weap[i] = weapID
						table.insert(flags_balls_table, weapID)
					end
				end
			end
		end
	end

	-- recalculate team counters
	cur_zombie_count = getzombiesize()
	cur_human_count = gethumansize()
	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

	checkgamestate()

end

function SpeedTimer(id, count)
	for i = 0,15 do
		if getteam(i) == zombie_team then
			local m_player = getplayer(i)
			local speed = readfloat(m_player, 0x60)
			if speed < zombie_speed then
				setspeed(i, zombie_speed)
			end
		end
	end
	return 1
end

function gethumansize()
	local size = 0
	for i = 0,15 do
		local m_player = getplayer(i)
		if m_player then
			local team = readbyte(m_player, 0x20)
			if team ~= zombie_team then
				size = size + 1
			end
		end
	end
	return size
end

function getzombiesize()
	local size = 0
	for i = 0,15 do
		local m_player = getplayer(i)
		if m_player then
			local team = readbyte(m_player, 0x20)
			if team == zombie_team then
				size = size + 1
			end
		end
	end
	return size
end

GetGameAddresses = function()
	local map_header_version = readbyte(0x630E74, 0x4)
	if map_header_version == 7 then
		map_pointer = 0x63525c
		ctf_globals = 0x639B98
		slayer_globals = 0x63A0E8
		gametype_base = 0x671340
		ctf_flag_stolen = 0x639BB4
		ball_holder_addr = 0x639F1C
		team_oddball_score_array = 0x639E9C
		oddball_score_array = 0x639E5C
		koth_move_timer = 0x639D78
		team_koth_score_array = 0x639BD0
		team_race_score_array = 0x63A028
		machine_pointer = 0x745BA0
		flag_respawn_addr = 0x488A7E
		inhill_addr = 0x639C50
		return "PC"
	else
		map_pointer = 0x5B927C
		ctf_globals = 0x5BDBB8
		slayer_globals = 0x5BE108
		gametype_base = 0x5F5498
		ctf_flag_stolen = 0x5BD8B4
		ball_holder_addr = 0x5BDF3C
		team_oddball_score_array = 0x5BDE9C
		oddball_score_array = 0x5BDE5C
		koth_move_timer = 0x5BDD78
		team_koth_score_array = 0x5BDBF0
		team_race_score_array = 0x5BD028
		machine_pointer = 0x6C7980
		flag_respawn_addr = 0x4638EE
		inhill_addr = 0x5BDC70
		return "CE"
	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(map_pointer, 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

	map = Map

	-- 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" then
		zombie_speed = 1.5
		lastman_speed = 1.25
	end

end

function DelayWriteCoords(id, count)
	writefloat(readdword(ctf_globals, 0x0), 0x8, readfloat(readdword(ctf_globals, 0x0), 0x8) - 100)
	writefloat(readdword(ctf_globals, 0x4), 0x8, readfloat(readdword(ctf_globals, 0x4), 0x8) - 100)
	return 0
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(crouch_timer)
		game_started = false
	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) then
				local cur_team = getteam(player)
				if cur_team == zombie_team then
					makehuman(player, true)
					privatesay(player, human_message)
				elseif cur_team ~= zombie_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 then
					local m_object = getobject(getplayerobjectid(i))
					if m_object then
						local team = getteam(i)
						if team == zombie_team then
							destroyweaps(i)
						end
					end
				end
			end
		end
	end
	return allow
end

function HumanTimer(id, count)
	if game_started == true then
		for i = 0,15 do
			local m_player = getplayer(i)
			if m_player then
				local hash = gethash(i)
				local team = readbyte(m_player, 0x20)
				local m_object = getobject(getplayerobjectid(i))
				if team ~= zombie_team and game_started then
					local m_playerObjId = getplayerobjectid(i)
					if getobject(m_playerObjId) then
						if tonumber(human_time[hash]) then
							human_time[hash] = tonumber(human_time[hash]) + 1
						else
							human_time[hash] = 1
						end
					end
				end
				if gametype == "KOTH" then
					if PlayerInHill(i) == true and m_object then
						--if cur_last_man ~= i then
							if inhill_time[hash] == nil then
								inhill_time[hash] = 0
								writebit(m_object, 0x10, 7, 1)
								--[[say(getname(i) .. " is in the hill and they are immortal until they leave!")
								if team ~= zombie_team then
									say(getname(i) .. " must leave the hill in 10 seconds or they will be infected!")
								else
									say(getname(i) .. " must leave the hill in 10 seconds or they will be killed!")
								end--]]
							elseif inhill_time[hash] >= 10 then
								if team ~= zombie_team then
									makezombie(i, true)
									say(getname(i) .. " is now a zombie because they were in the hill too long!")
								else
									kill(i)
									say(getname(i) .. " has been killed because they were in the hill too long!")
								end
								inhill_time[hash] = nil
							elseif team ~= zombie_team then
								privatesay(i, "You have " .. math.abs(inhill_time[hash] - 10) .. " seconds to leave the hill!")
								inhill_time[hash] = inhill_time[hash] + 1
							end
						--end
					elseif m_object then
						inhill_time[hash] = nil
						writebit(m_object, 0x10, 7, 0)
					end
				end
			end
		end
	end
	return 1
end

function PlayerInHill(player)
	player = tonumber(player)
	local bool = false
	local m_player = getplayer(player)
	if m_player then
		local InHill = readbyte(inhill_addr + player, 0x0)
		if InHill == 1 then
			bool = true
		end
	end
	return bool
end

function invisCrouch(id, count)
	if not zombies_invisible_on_crouch and not humans_invisible_on_crouch then return 0 end
	for i = 0,15 do
		if getplayer(i) then
			local m_object = getobject(getplayerobjectid(i))
			if m_object then
				local obj_crouch = readbyte(m_object, 0x2A0)
				if obj_crouch == 3 then
					local team = readbyte(getplayer(i), 0x20)
					if (team == zombie_team and zombies_invisible_on_crouch) or (team ~= zombie_team and humans_invisible_on_crouch) then
						applycamo(i, 1)
					end
				end
			end
		end
	end
	return 1
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 = join_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

	-- onteamdecision isn't called for ffa gametypes
	if not team_play then

		-- initialize the destination team as the join team
		local dest_team = join_team

		-- make sure the game is started
		if game_started then

			-- if no zombies make them human
			if cur_players == 0 then

				-- change the destination team to human if cur_players 0 (doesn't matter if join_team is humanteam)
				dest_team = human_team

			-- check if there are zombies but no humans
			elseif cur_zombie_count > 0 and cur_human_count == 0 then

				-- change the destination team to human if condition met (doesn't matter if join_team is humanteam)
				dest_team = human_team
			end
		end

		-- we need to overwrite the 'team' variable being passed to onplayerjoin
		if dest_team == zombie_team then
			team = zombie_team
		elseif tonumber(dest_team) then
			team = 2
		end
	end


	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

					--check what team they currently are (only added for ffa gametypes)
					if team == zombie_team then
						makehuman(player, false)
					else
						makezombie(player, false)
					end
				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

	-- make sure the game is started
	if game_started == true then

		-- check if the player is a zombie
		if team == zombie_team then

			--we don't need to update the counters since they're already on the zombieteam
			makezombie(player, false, true)

			--send them the zombie message
			privatesay(player, zombie_message)
		else
			-- if we're at last man, make this player a zombie
			if cur_last_man then

				--make this person a zombie (they're currently a human)
				makezombie(player, true)

				--send them the zombie message
				privatesay(player, zombie_message)
			else

				--make this person a human (they're currently a zombie)
				makehuman(player, false, true)

				--send them the human message
				privatesay(player, human_message)
			end
		end

		--send the player the welcome message
		privatesay(player, welcome_message)
		if gametype == "KOTH" then
			privatesay(player, koth_additional_welcome_msg)
		elseif gametype == "Slayer" then
			privatesay(player, slayer_additional_welcome_msg)
		end
		checkgamestate(-1)
	else
		registertimer(10000, "MsgTimer", player)
	end
end

--called when a person joins before the game is started so that the welcome message
--doesn't get lost in the spam
function MsgTimer(id, count, player)
	privatesay(player, welcome_message)
	if gametype == "KOTH" then
		privatesay(player, koth_additional_welcome_msg)
	elseif gametype == "Slayer" then
		privatesay(player, slayer_additional_welcome_msg)
	end
	return 0
end

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

	--check if they're a zombie
	if team == zombie_team then

		--get their object struct
		local m_object = getobject(getplayerobjectid(player))
		if m_object then -- make sure the player is alive
			for i = 0,3 do -- loop through all their weapons (primary through quartenary)

				--get their weapon's ID
				local weapID = readdword(m_object, 0x2F8 + i*4)

				--get their weapon's struct
				local weap = getobject(weapID)

				--make sure the weapon exists
				if weap then

					--weapon needs to be destroyed
					registertimer(0, "destroyweaps", weapID)
				end
			end
		end

		--take one away from the current zombie count
		cur_zombie_count = cur_zombie_count - 1
	elseif team ~= zombie_team then

		--take one away from the current human count
		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

	--minus one from current players
	cur_players = cur_players - 1

	--check the current game state (the player that left might have been the last man or the only zombie)
	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)

	-- make sure this kill doesn't add to the score so that the game won't end prematurely
	if gametype == "Slayer" and killer and getplayer(killer) then writedword(slayer_globals, 0x40 + killer*4, 0) end

	-- make sure the game is started
	if game_started then

		-- get the victim's team
		local team = getteam(victim)

		-- i used this for debugging lol
		--hprintf("Victim Team: " .. tostring(team))

		if mode == 0 then -- server kill
		elseif mode == 1 then -- fall damage

			-- if this is true then a person who dies from falling will be infected
			if infect_on_fall then

				--chech if the team is the human team
				if tonumber(team) and team ~= zombie_team then

					--get the victim's name
					local name = getname(victim)

					--send the victim the infected message
					say(name .. infected_message)

					--make the victim a zombie
					makezombie(victim, false)
				end
			end
		elseif mode == 2 then -- killed by guardians

			-- if this is true then a person who dies from the guardians will be infected
			if infect_on_guardians then

				--check if the victim's team is the human team
				if tonumber(team) and team ~= zombie_team then

					--get the victim's name
					local name = getname(victim)

					--send the victim the infected message
					say(name .. infected_message)

					--make the victim a zombie
					makezombie(victim, false)
				end
			end
		elseif mode == 3 then -- killed by vehicle
		elseif mode == 4 then -- killed by another player

			--get the killer's team
			local killer_team = getteam(killer)

			-- check to see if a zombie killed them
			if tonumber(killer_team) and killer_team == zombie_team and tonumber(team) and team ~= zombie_team then

				--get the victim's name
				name = getname(victim)

				--send the victim the infected message
				say(name .. infected_message)

				--make the victim a zombie
				makezombie(victim, false)
				--privatesay(victim, zombie_message)
			end

			--i used this for debugging
			--hprintf("Killer Team: " .. killer_team)
		elseif mode == 5 then -- betrayed
			--if this is true then a person who betrays will be infected
			if infect_on_betray then

				--get the killer's team
				local killer_team = getteam(killer)

				--check if the killer is a human
				if tonumber(killer_team) and killer_team ~= zombie_team then

					--get the betrayer's name
					name = getname(killer)

					--send the betrayer the infected message
					say(tostring(name) .. infected_message)

					--make the betrayer a zombie
					makezombie(killer, true)
				end
			end
		elseif mode == 6 then -- suicide
			--if this is true then a person who suicides will be come a zombie
			if infect_on_suicide then

				-- if they're human, make them zombies
				if tonumber(team) and team ~= zombie_team then

					--get the suicider's name
					name = getname(victim)

					--they're not going to end their life that easily
					say(name .. infected_message)

					--make the suicider a zombie
					makezombie(victim, false)
				end
			end
		end

		-- this next block of code gets rid of any weapons a zombie is holding
		if tonumber(team) and team == zombie_team then
			local m_player = getplayer(victim) --get the player's struct
			local m_object = getobject(readdword(m_player, 0x34)) -- get the player's object struct

			--there's an off chance that the player might be dead (phasor bug) can't hurt to add this check
			if m_object then
				for i = 0,3 do -- loop through the player's weapons (primary to quartenary)
					local weapID = readdword(m_object, 0x2F8 + i*4)
					local weap = getobject(weapID)

					--make sure the weapon exists
					if weap then

						--destroy their weapons
						registertimer(0, "destroyweaps", weapID)
					end
				end
			end
		end
	end
end

--I made this function because there's a bug with destroyobject in phasor version 058X
--basically all it does is move the objects under the map lol
function destroyweaps(id, count, m_weaponId)
	local m_weapon = getobject(m_weaponId)
	if m_weapon then
		writefloat(m_weapon, 0x5C, readfloat(m_weapon, 0x5C) - 1000)
	end
	return 0
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)

	--get the player's team
	local team = getteam(player)

	--check if the player is a zombie
	if team == zombie_team then

		--get the player's object ID
		local m_objectId = getplayerobjectid(player)

		--get the player's object struct
		local m_object = getobject(m_objectId)

		--make sure the player is alive (off chance that there's a glitch in phasor)
		if m_object 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
			local batterycount = alphazombie_battery_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
				batterycount = zombie_battery_count
			else -- set alpha nades
				writebyte(m_object, 0x31E, alphazombie_frag_count)
				writebyte(m_object, 0x31F, alphazombie_plasma_count)
			end

			--check if the starting equipment is generic
			if starting_equipment == "Generic" then

				-- initialize this boolean as false
				local bool = false
				for i=0,3 do --loop through the player's weapons (primary through quartenary)

					--get the player's weapon's ID
					local m_weaponId = readdword(m_object, 0x2F8 + i*4)

					--check if the zombie weapon is an oddball or a flag
					if oddball_or_flag then

						--make sure the boolean is still false and the player's weapon exists.
						if bool == false and getobject(m_weaponId) then

							--get the weapon's tagname
							local tagName = getobjecttag(m_weaponId)

							--make sure the weapon's tagname is the zombie weapon (oddball/flag)
							if tagName == oddball_or_flag then

								--store the weapon's ID in the flagball_weap table
								flagball_weap[player] = m_weaponId

								--set bool to true
								bool = true
							end
						end

					--zombie weapon is not a flag or a ball
					elseif m_weaponId ~= 0xFFFFFFFF then

						--get the weapon's struct
						local m_weapon = getobject(m_weaponId)

						--make sure the weapon exists
						if m_weapon then

							-- set the ammo
							writeword(m_weapon, 0x2B6, ammocount)
							writeword(m_weapon, 0x2B8, clipcount)

							-- set the battery (math.abs is absolute value meaning it takes the opposite of battery count (meaning 0 needs to be 1 and 1 needs to be 0))
							writefloat(m_weapon, 0x240, math.abs(batterycount - 1))

							-- force it to sync
							updateammo(m_weaponId)
						end
					end
				end

				-- check if we still need to assign leftover weapons to zombies (tertiary and quartenary weapons)
				if (zombie_weapon[3] and zombie_weapon[3] ~= "") then -- make sure the script user isn't retarded
					--assign the leftover weapons to the player
					registertimer(0, "AssignLeftoverZombieWeapons", player, clipcount, ammocount, batterycount)
				end
			elseif starting_equipment == "Custom" then
				--assign the correct weapons to the player
				registertimer(0, "AssignZombieWeapons", player, clipcount, ammocount, batterycount)
			end
		end
	end

	--check if the gametype is slayer
	if gametype == "Slayer" then
		local m_player = getplayer(player)

		--check if we're at the last_man
		if cur_last_man then
			--write the navpoint to the current last man
			writeword(m_player, 0x88, cur_last_man)
		else
			--there is no last man so put a nav above this player's head
			writeword(m_player, 0x88, player)
		end
	end
end

--basically this timer assigns the tertiary and quarternary weapons to zombies if specified at the top
--this is needed since onweaponassignment isn't called for tertiary and quartenary weapons
function AssignLeftoverZombieWeapons(id, count, player, clipcount, ammocount, batterycount)

	local m_objectId = getplayerobjectid(player)
	if m_objectId ~= 0xFFFFFFFF then
		local m_object = getobject(m_objectId)
		if m_object then
			local m_weaponId = createobject("weap", zombie_weapon[3], 0, 0, false, 5, 2, 2)
			if m_weaponId ~= 0xFFFFFFFF then
				local m_weapon = getobject(m_weaponId)
				if m_weapon then
					-- set the ammo
					writeword(m_weapon, 0x2B6, ammocount)
					writeword(m_weapon, 0x2B8, clipcount)
					writefloat(m_weapon, 0x240, math.abs(batterycount - 1))
					-- force it to sync
					updateammo(m_weaponId)
				end
			end
			--make sure the script user isn't retarded so we don't get errors
			if zombie_weapon[4] and zombie_weapon[4] ~= "" then

				--create the quarternary weapon
				local m_weaponId = createobject("weap", zombie_weapon[4], 0, 0, false, 5, 5, 2)

				--make sure createobject didn't screw up
				if m_weaponId ~= 0xFFFFFFFF then

					--assign the weapon to the player
					assignweapon(player, m_weaponId)

					--make sure we can safely set the ammo
					local m_weapon = getobject(m_weaponId)
					if m_weapon then
						-- set the ammo
						writeword(m_weapon, 0x2B6, ammocount)
						writeword(m_weapon, 0x2B8, clipcount)
						writefloat(m_weapon, 0x240, math.abs(batterycount - 1))
						-- force it to sync
						updateammo(m_weaponId)
					end
				end
			end
		end
	end
	return 0
end

--this function is called when a gametype is 'custom'
--this function will delete the player's weapons and reassign the weapon's specified at the top
function AssignZombieWeapons(id, count, player, clipcount, ammocount, batterycount)
	local m_objectId = getplayerobjectid(player)
	if m_objectId ~= 0xFFFFFFFF then
		local m_object = getobject(m_objectId)
		if m_object then
			--count is increased everytime the timer is called
			if count == 1 then
				for i = 0,3 do -- this is used to remove any weapons they already have
					local m_weaponId = readdword(m_object, 0x2F8 + i*4)
					if getobject(m_weaponId) then
						destroyobject(m_weaponId)
					end
				end
			end
			local i = count
			if zombie_weapon and zombie_weapon[i] and zombie_weapon[i] ~= "" then
				local m_weaponId = createobject("weap", zombie_weapon[i], 0, 0, false, 1, 1, 1)
				if m_weaponId ~= 0xFFFFFFFF then
					assignweapon(player, m_weaponId)
					if oddball_or_flag then
						flagball_weap[player] = m_weaponId
					else
						local m_weapon = getobject(m_weaponId)
						if m_weapon 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
			if count < 4 then return 1 else return 0 end
		end
	end
	return 0
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 change their team.
-- 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 or relevant == true then

		if not allow_change then
			privatesay(player, blockteamchange_message)
		elseif allow_change and 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 (relevant == 0 or relevant == false) and 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 ~= zombie_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 ~= zombie_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

--i made code in here to make the oddball/flag impossible to be dropped except that was a long time ago and i have no idea how it works, sorry :(
--there's a bunch of redundant code in here, i wouldn't touch it if i were you.
-- this function is also used to continually set the scores
function OnClientUpdate(player, m_objectId)
	local m_player = getplayer(player)
	local m_object = getobject(m_objectId)
	local hash = gethash(player)
	--if gametype == "CTF" then writebit(ctf_globals, 0x1C, human_team, 0) end
	if m_object and game_started == true then
		local team = readbyte(m_player, 0x20)
		if team == zombie_team and oddball_or_flag then
			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)
				say("IS SHOOTING")
				if weap then--]]
					weapID = flagball_weap[player]
					local m_player = getplayer(player)
					if m_player then
						if weapID == nil then
							flagball_weap[player] = createobject("weap", oddball_or_flag, 0, 0, false, 5, 5, 2)
							assignweapon(player, flagball_weap[player])
						else
							if getobject(weapID) then
								if IsFlagOrBall(weapID) then
									assignweapon(player, weapID)
								else
									flagball_weap[player] = createobject("weap", oddball_or_flag, 0, 0, false, 5, 5, 2)
									assignweapon(player, flagball_weap[player])
								end
							else
								flagball_weap[player] = createobject("weap", oddball_or_flag, 0, 0, false, 5, 5, 2)
								assignweapon(player, flagball_weap[player])
							end
						end
					end
				--end
			end
		end
		-- this block of code sets the player's score according to what it should be.
		if tonumber(human_time[hash]) then
			if gametype == "KOTH" then
				local hill_time = readword(m_player, 0xC4)
				if tonumber(hill_time) then
					writewordsigned(m_player, 0xC4, tonumber(human_time[hash])*30)
				end
			elseif gametype == "CTF" then
				local player_score = readdword(m_player, 0xC8)
				if tonumber(player_score) then
					writedwordsigned(m_player, 0xC8, human_time[hash])
				end
			elseif gametype == "Slayer" then
				writedwordsigned(slayer_globals, 0x40 + player * 4, human_time[hash])
			end
		else
			human_time[hash] = 0
		end
	end

	--continually write 0 to these addresses
	if gametype == "KOTH" then
		writedword(team_koth_score_array, 0x0, 0)
		writedword(team_koth_score_array, 0x4, 0)
	elseif gametype == "CTF" then
		writedword(ctf_globals, 0x10, 0)
		writedword(ctf_globals, 0x14, 0)
	elseif gametype == "Slayer" then
		writedword(slayer_globals, 0x0, 0)
		writedword(slayer_globals, 0x4, 0)
	end

	--this makes sure that people won't camp in unreachable places.
	local x,y,z = getobjectcoords(m_objectId)
	local team = getteam(player)
	if map == "damnation" and team ~= zombie_team then
		if object_in_sphere(m_objectId, 1.99, 9.03, 7.82, 5) then
			kill(player)
			privatesay(player, "Do not camp in unreachable spots!")
		elseif object_in_sphere(m_objectId, 11.4, 11.21, 10.51, 5) then
			kill(player)
			privatesay(player, "Do not camp in unreachable spots!")
		end
	elseif map == "icefields" and team ~= zombie_team then
		if object_in_sphere(m_objectId, -31.27, 42.44, 11.48, 5) then
			kill(player)
			privatesay(player, "Do not camp in unreachable spots!")
		elseif object_in_sphere(m_objectId, -71.29, 70.83, 6.67, 10) then
			kill(player)
			privatesay(player, "Do not camp in unreachable spots!")
		elseif object_in_sphere(m_objectId, -17.28, 19.63, 11.55, 5) then
			kill(player)
			privatesay(player, "Do not camp in unreachable spots!")
		end
	end
end

function writewordsigned(address, offset, value)
	if value and value > 0x7FFF then
		local max = 0xFFFF
		local difference = max - value
		value = -1 - difference
	end
	writeword(address, offset, value)
end

function writedwordsigned(address, offset, value)
	if value and value > 0x7FFFFFFF then
		local max = 0xFFFFFFFF
		local difference = max - value
		value = -1 - difference
	end
	writedword(address, offset, value)
end

--called to check if an object is in a virtual sphere
--i use this to check if a person is in a unreachable spot.
function object_in_sphere(m_objectId, X, Y, Z, R)
	local Pass = false
	if getobject(m_objectId) then
		local x,y,z = getobjectcoords(m_objectId)
		if (X - x)^2 + (Y - y)^2 + (Z - z)^2 <= R then
            Pass = true
        end
    end
    return Pass
end

--checks if the object is a flag or a ball
function IsFlagOrBall(weapID)
	for i = 1,#flags_balls_table do
		if flags_balls_table[i] == weapID then
			return true
		end
	end
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

		-- we don't need to stop people from taking the flag
		-- since the flag is moved under the map
		if tagType == "weap" then
			if tagName == oddball_or_flag then
				local team = getteam(player)
				if team == zombie_team then
					return 1
				end
				return 0
			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 then

							local m_playerObjId = readdword(m_player, 0x34)
							local m_object = getobject(m_playerObjId)
							if m_object 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 = 0
	if game_started and relevant == 1 then

		local team = getteam(player)
		if (team == zombie_team and zombies_allowed_in_vehis) or (tonumber(team) and team ~= zombie_team and humans_allowed_in_vehis) then
			response = 1
		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 then

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

			-- Check if it's a human causing the damage
			if c_team ~= zombie_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 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 * 1.75 * modifier)
				writefloat(tagdata, 0x1D4, max_dmg_min * 1.75 * modifier)
				writefloat(tagdata, 0x1D8, max_dmg_max * 1.75 * 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)
				local r_team = getteam(receiver)

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

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

				end

				--check if a person is trying to damage their own team (ffa only, basically friendly fire is on to reduce confusion)
				if not team_play and c_team == r_team and causer ~= receiver then
					writefloat(tagdata, 0x1D0, 0)
					writefloat(tagdata, 0x1D4, 0)
					writefloat(tagdata, 0x1D8, 0)
					privatesay(causer, "Do not hit your own team.")
				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 'Custom' if not this has no effect.
function OnWeaponAssignment(player, object, count, tag)
	if starting_equipment == "Custom" then return 0 end -- this function does nothing if starting equipment is Custom

	local actualWeapon = 0
	local team = getteam(player)

	if team == zombie_team then
		if count == 0 and zombie_weapon[1] ~= "" and zombie_weapon[1] then
			actualWeapon = lookuptag("weap", zombie_weapon[1])
		elseif count == 1 and zombie_weapon[2] ~= "" and zombie_weapon[2] then
			actualWeapon = lookuptag("weap", zombie_weapon[2])
		end
	end
	if not actualWeapon then actualWeapon = 0 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 gametype == "CTF" then
		-- move the ctf flags under the map
		if tag == "weapons\\flag\\flag" then
			local red_scoreflag_objId = readdword(ctf_globals, 0x8)
			local blue_scoreflag_objId = readdword(ctf_globals, 0x12)
			if m_objectId == red_scoreflag_objId or m_objectId == blue_scoreflag_objId then
				registertimer(0, "PutUnderMap", m_objectId)
				return -- return so it won't add this weapon to the flags_balls_table
			end
		end
	end
	if tag == oddball_or_flag then
		table.insert(flags_balls_table, m_objectId)
	end
end

--i basically use this to put the object under the map, i could use destroyweaps like i do above but w/e
function PutUnderMap(id, count, m_objectId)
	local m_object = getobject(m_objectId)
	if m_object then
		local x,y,z = getobjectcoords(m_objectId)
		movobjcoords(m_objectId, x, y, z - 20)
	end
	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 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
					if getplayer(i) then
						local hash = gethash(i)
						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 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 then
					-- check if they're a zombie
					if pteam == zombie_team then
						privatesay(i, zombie_message)
					else
						if not team_play then makehuman(i) end
						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

			if team_play then say("Thank you, the game can continue.") end

			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 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 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(nozombiesleftmessage)
	player_change_timer = registertimer(1000, "PlayerChangeTimer")
end

--this function writes navpoints to zombies which will point to the last man
function WriteNavsToZombies()
	for i = 0,15 do
		local team = getteam(i)
		if team == zombie_team then
			local m_player = getplayer(i)
			if m_player then
				local slayer_target = readword(m_player, 0x88)
				if slayer_target < 16 and slayer_target > -1 then
					writeword(m_player, 0x88, cur_last_man)
				end
			end
		end
	end
end

-- called when a last man exists
function onlastman()

	-- lookup the last man
	for x=0,15 do
		local team = getteam(x)
		if team ~= zombie_team and team then

			cur_last_man = x
			if gametype == "Slayer" then WriteNavsToZombies(x) end
			-- 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 then
				local m_ObjId = readdword(m_player, 0x34)

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

				if m_object then
					if lastman_invulnerable 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 then
								-- set the ammo
								writeword(m_weapon, 0x2B6, 600)
							end
						end
					end
				end
			end
		end
	end

	if cur_last_man then

		local lastman_name = getname(cur_last_man)
		local msg = string.format(lastman_message, tostring(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, onplayerjoin, onplayerleave, onffateamchange, and onscriptload
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 " .. tostring(zombie_count))
		--hprintf("human count " .. tostring(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 not cur_last_man then
			onlastman()
		elseif cur_last_man and zombie_count == 0 then
			makehuman(cur_last_man, false)
			cur_last_man = nil
		elseif cur_last_man and human_count > 1 then
			if gametype == "Slayer" then takenavsaway(cur_last_man) end
			makehuman(cur_last_man, false)
			cur_last_man = nil
		end
	end

end

--called when the lastman no longer exists
function takenavsaway(lastman)
	for i = 0,15 do
		local m_player = getplayer(i)
		if m_player then
			writeword(m_player, 0x88, i)
		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(tostring(last_man_hash))
			file:close()
		end
	end

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

--called when a player needs to be made a zombie
function makezombie(player, forcekill, updatecounters)

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

	local team = getteam(player)
	if team ~= zombie_team then
		if team_play then
			changeteam(player, forcekill)
		else
			changeteam(player, forcekill, nil, updatecounters)
		end
	end
end

--called when a player needs to be a human
function makehuman(player, forcekill, updatecounters)
	-- change the player's speed
	setspeed(player, human_speed)

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

--gets the number of alpha zombies
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

--rounds the number
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