local meta = FindMetaTable("Player")
local P_Team = meta.Team

local DMG_TAKE_BLEED = DMG_SLASH + DMG_CLUB + DMG_BULLET + DMG_BUCKSHOT + DMG_CRUSH
function meta:ProcessDamage(dmginfo)
	if not self:IsValidLivingPlayer() then return end --??? Apparently player was null sometimes on server?

	local attacker, inflictor, dmgtype = dmginfo:GetAttacker(), dmginfo:GetInflictor(), dmginfo:GetDamageType()

	if not GAMEMODE:PlayerShouldTakeDamage(self, attacker) then return true end

	local dmgbypass = bit.band(dmgtype, DMG_DIRECT) ~= 0

	if self.DamageVulnerability and not dmgbypass then
		dmginfo:SetDamage(dmginfo:GetDamage() * self.DamageVulnerability)
	end

	if attacker.AttackerForward and attacker.AttackerForward:IsValid() then
		dmginfo:SetAttacker(attacker.AttackerForward)
		attacker = attacker.AttackerForward

		if attacker:IsPlayer() and attacker:Team() == P_Team(self) and attacker ~= self then
			dmginfo:SetDamage(0)
		end
	end

	if attacker.PBAttacker and attacker.PBAttacker:IsValid() then
		attacker = attacker.PBAttacker
	end

	if P_Team(self) == TEAM_UNDEAD then
		if self.SpawnProtection then
			dmginfo:SetDamage(0)
			dmginfo:ScaleDamage(0)
			dmginfo:SetDamageForce(vector_origin)
			return
		end

		local corrosion = self.Corrosion and self.Corrosion + 2 > CurTime()
		if self ~= attacker and not corrosion and not dmgbypass then
			dmginfo:SetDamage(dmginfo:GetDamage() * GAMEMODE:GetZombieDamageScale(dmginfo:GetDamagePosition(), self))
		end

		self.ShouldFlinch = true

		if attacker:IsValidLivingHuman() and inflictor:IsValid() and inflictor == attacker:GetActiveWeapon() then
			local damage = dmginfo:GetDamage()
			local wep = attacker:GetActiveWeapon()
			local attackermaxhp = math.floor(attacker:GetMaxHealth() * (attacker:IsSkillActive(SKILL_D_FRAIL) and 0.25 or 1))

			if wep.IsMelee then
				if attacker:IsSkillActive(SKILL_CHEAPKNUCKLE) and math.abs(self:GetForward():Angle().yaw - attacker:GetForward():Angle().yaw) <= 90 then
					self:AddLegDamage(12)
				end

				if attacker.MeleeDamageToBloodArmorMul and attacker.MeleeDamageToBloodArmorMul > 0 and attacker:GetBloodArmor() < attacker.MaxBloodArmor then
					attacker:SetBloodArmor(math.min(attacker.MaxBloodArmor, attacker:GetBloodArmor() + math.min(damage, self:Health()) * attacker.MeleeDamageToBloodArmorMul * attacker.BloodarmorGainMul))
				end

				if attacker:IsSkillActive(SKILL_HEAVYSTRIKES) and not self:GetZombieClassTable().Boss and (wep.IsFistWeapon and attacker:IsSkillActive(SKILL_CRITICALKNUCKLE) or wep.MeleeKnockBack > 0) then
					attacker:TakeSpecialDamage(damage * (wep.Unarmed and 1 or 0.08), DMG_SLASH, self, self:GetActiveWeapon())
				end

				if attacker:IsSkillActive(SKILL_BLOODLUST) and attacker:GetPhantomHealth() > 0 and attacker:Health() < attackermaxhp then
					local toheal = math.min(attacker:GetPhantomHealth(), math.min(self:Health(), damage * 0.25))
					attacker:SetHealth(math.min(attacker:Health() + toheal, attackermaxhp))
					attacker:SetPhantomHealth(attacker:GetPhantomHealth() - toheal)
				end

				if attacker:HasTrinket("sharpkit") then
					dmginfo:SetDamage(dmginfo:GetDamage() * (1 + self:GetFlatLegDamage()/75))
				end

				if wep.Culinary and attacker:IsSkillActive(SKILL_MASTERCHEF) and math.random(9) == 1 then
					self.ChefMarkOwner = attacker
					self.ChefMarkTime = CurTime() + 1
				end
			end
		end

		return not dmgbypass and self:CallZombieFunction1("ProcessDamage", dmginfo)
	end

	-- Opted for multiplicative.
	if attacker == self and dmgtype ~= DMG_CRUSH and dmgtype ~= DMG_FALL and self.SelfDamageMul then
		dmginfo:SetDamage(dmginfo:GetDamage() * self.SelfDamageMul)
	end
	if bit.band(dmgtype, DMG_ALWAYSGIB) ~= 0 and self.ExplosiveDamageTakenMul then
		dmginfo:SetDamage(dmginfo:GetDamage() * self.ExplosiveDamageTakenMul)
	end
	if bit.band(dmgtype, DMG_BURN) ~= 0 and self.FireDamageTakenMul then
		dmginfo:SetDamage(dmginfo:GetDamage() * self.FireDamageTakenMul)
	end

	if inflictor:IsValid() and (inflictor:IsPhysicsModel() or inflictor.IsPhysbox) and self:IsValidLivingHuman() then
		local damage = dmginfo:GetDamage()
		local forcedamp = self:HasTrinket("forcedamp")
		local noadj = attacker:IsValidLivingZombie() and attacker:GetZombieClassTable().NoAdjustPhysDamage

		if forcedamp or (attacker:IsValidLivingZombie() and not noadj) then
			damage = math.max(5, (math.log10(damage) * 26)-5)
		end
		if self.PhysicsDamageTakenMul then
			damage = damage * self.PhysicsDamageTakenMul
		end
		if damage >= 30 and not forcedamp and not noadj and inflictor ~= attacker then
			self:KnockDown(damage * 0.05)
		end

		dmginfo:SetDamage(damage)
	end

	if attacker:IsValid() and attacker:IsPlayer() and inflictor:IsValid() and attacker:Team() == TEAM_UNDEAD then
		if inflictor == attacker:GetActiveWeapon() then
			local damage = dmginfo:GetDamage()

			if self:IsBarricadeGhosting() then
				self:SetLegDamage(21 * (self.SlowEffTakenMul or 1))
			else
				local scale = inflictor.SlowDownScale or 1
				if damage >= 45 or scale > 1 then
					local dolegdamage = true
					if inflictor.SlowDownImmunityTime then
						if CurTime() < (self.SlowDownImmunityTime or 0) then
							dolegdamage = false
						else
							self.SlowDownImmunityTime = CurTime() + inflictor.SlowDownImmunityTime
						end
					end
					if dolegdamage then
						self:RawCapLegDamage(self:GetLegDamage() + CurTime() + damage * 0.04 * (inflictor.SlowDownScale or 1) * (self.SlowEffTakenMul or 1))
					end
				end
			end

			if bit.band(dmgtype, DMG_SLASH) ~= 0 or inflictor.IsMelee then
				if self.BarbedArmor and self.BarbedArmor > 0 then
					attacker:TakeSpecialDamage(self.BarbedArmor, DMG_SLASH, self, self)
					attacker:AddArmDamage(self.BarbedArmor)
				end

				if self.BarbedArmorPercent and self.BarbedArmorPercent > 0 then
					attacker:TakeSpecialDamage(damage * self.BarbedArmorPercent, DMG_SLASH, self, self)
				end

				if self:HasTrinket("reactiveflasher") and (not self.LastReactiveFlash or self.LastReactiveFlash + 75 < CurTime()) then
					attacker:ScreenFade(SCREENFADE.IN, nil, 1, 1)
					attacker:SetDSP(36)
					attacker:GiveStatus("disorientation", 2)

					self:EmitSound("weapons/flashbang/flashbang_explode2.wav")

					local effectdata = EffectData()
						effectdata:SetOrigin(self:GetPos())
					util.Effect("HelicopterMegaBomb", effectdata)

					self.LastReactiveFlash = CurTime()
					self.ReactiveFlashMessage = nil
				elseif self:HasTrinket("bleaksoul") and (not self.LastBleakSoul or self.LastBleakSoul + 35 < CurTime()) then
					attacker:GiveStatus("dimvision", 3)
					attacker:SetGroundEntity(nil)
					attacker:SetLocalVelocity((attacker:GetPos() - self:GetPos()):GetNormalized() * 450 + Vector(0, 0, 140))

					self:EmitSound("ambient/creatures/town_child_scream1.wav", 70, 60)
					self:EmitSound("npc/stalker/go_alert2a.wav", 70, 45, 0.25)

					self.LastBleakSoul = CurTime()
					self.BleakSoulMessage = nil
				end

				if self:HasTrinket("iceburst") and (not self.LastIceBurst or self.LastIceBurst + 40 < CurTime()) then
					attacker:AddLegDamageExt(17, attacker, attacker, SLOWTYPE_COLD)

					local effectdata = EffectData()
						effectdata:SetOrigin(self:GetPos())
					util.Effect("explosion_cold", effectdata)

					self.LastIceBurst = CurTime()
					self.IceBurstMessage = nil
				end

				if self.MeleeDamageTakenMul and not dmgbypass then
					dmginfo:SetDamage(dmginfo:GetDamage() * self.MeleeDamageTakenMul)
				end

				if self:IsSkillActive(SKILL_BACKPEDDLER) then
					self:AddLegDamage(8)
				end
			end

			if self.HasHemophilia and (damage >= 4 and dmgtype == 0 or bit.band(dmgtype, DMG_TAKE_BLEED) ~= 0) then
				local bleed = self:GiveStatus("bleed")
				if bleed and bleed:IsValid() then
					bleed:AddDamage(damage * 0.25)
					if attacker:IsValid() and attacker:IsPlayer() then
						bleed.Damager = attacker
					end
				end
			end
		elseif inflictor:IsProjectile() then
			if self.ProjDamageTakenMul and not dmgbypass then
				dmginfo:SetDamage(dmginfo:GetDamage() * self.ProjDamageTakenMul)
			end
		end
	end

	self.NextBloodArmorRegen = CurTime() + 5
	if self:GetBloodArmor() > 0 then
		local damage = dmginfo:GetDamage()
		if damage > 0 then
			if damage >= self:GetBloodArmor() and self:IsSkillActive(SKILL_BLOODLETTER) then
				local bleed = self:GiveStatus("bleed")
				if bleed and bleed:IsValid() then
					bleed:AddDamage(5)
					bleed.Damager = self
				end
			end

			local ratio = 0.5 + self.BloodArmorDamageReductionAdd + (self:IsSkillActive(SKILL_IRONBLOOD) and self:Health() <= self:GetMaxHealth() * 0.5 and 0.25 or 0)
			local absorb = math.min(self:GetBloodArmor(), damage * ratio)
			dmginfo:SetDamage(damage - absorb)
			self:SetBloodArmor(self:GetBloodArmor() - absorb)

			if attacker:IsValid() and attacker:IsPlayer() then
				local myteam = attacker:Team()
				local otherteam = P_Team(self)
				attacker.DamageDealt[myteam] = attacker.DamageDealt[myteam] + absorb

				if myteam == TEAM_UNDEAD and otherteam == TEAM_HUMAN then
					attacker:AddLifeHumanDamage(absorb)
				end
			end

			if damage > 20 and damage - absorb <= 0 then
				self:EmitSound("physics/flesh/flesh_strider_impact_bullet3.wav", 55)
			end
		end
	end

	if self:IsSkillActive(SKILL_BLOODLUST) and attacker:IsValid() and attacker:IsPlayer() and inflictor:IsValid() and attacker:Team() == TEAM_UNDEAD then
		self:SetPhantomHealth(math.min(self:GetPhantomHealth() + dmginfo:GetDamage() / 2, self:GetMaxHealth()))
	end

	if dmginfo:GetDamage() > 0 and not self:HasGodMode() then
		self.NextRegenTrinket = CurTime() + 12

		self.ShouldFlinch = true
	end
end

GM.TrinketRecharges = {
	reactiveflasher = {"ReactiveFlashMessage", "LastReactiveFlash", "Reactive Flasher", 75},
	bleaksoul = {"BleakSoulMessage", "LastBleakSoul", "Bleak Soul", 35},
	biocleanser = {"BioCleanserMessage", "LastBioCleanser", "Bio Cleanser", 20},
	iceburst = {"IceBurstMessage", "LastIceBurst", "Iceburst Shield", 40}
}

function meta:CheckTrinketRecharges()
	local time = CurTime()

	for trinket, data in pairs(GAMEMODE.TrinketRecharges) do
		local msg, last, name, delay = data[1], data[2], data[3], data[4]

		if self:HasTrinket(trinket) and not self[msg] and self[last] and time > self[last] + delay then
			self:CenterNotify(COLOR_ORANGE, translate.ClientFormat(self, "trinket_recharged", name))
			self:SendLua("surface.PlaySound(\"buttons/button5.wav\")")
			self[msg] = true
		end
	end
end

function meta:HasWon()
	if P_Team(self) == TEAM_HUMAN and self:GetObserverMode() == OBS_MODE_ROAMING then
		local target = self:GetObserverTarget()
		return target and target:IsValid() and target:GetClass() == "prop_obj_exit"
	end

	return false
end

function meta:GetBossZombieIndex()
	local bossclasses = {}
	for _, classtable in pairs(GAMEMODE.ZombieClasses) do
		if classtable.Boss then
			table.insert(bossclasses, classtable.Index)
		end
	end

	if #bossclasses == 0 then return -1 end

	local desired = self:GetInfo("zs_bossclass") or ""
	if GAMEMODE:IsBabyMode() then
		desired = "Giga Gore Child"
	elseif desired == "[RANDOM]" or desired == "" then
		desired = "Nightmare"
	end

	local bossindex
	for _, classindex in pairs(bossclasses) do
		local classtable = GAMEMODE.ZombieClasses[classindex]
		if string.lower(classtable.Name) == string.lower(desired) then
			bossindex = classindex
			break
		end
	end

	return bossindex or bossclasses[1]
end

function meta:ShouldReviveFrom(dmginfo, hullzplane)
	return not self.Revive
	and not dmginfo:GetInflictor().IsMelee and not dmginfo:GetInflictor().NoReviveFromKills
	and dmginfo:GetAttacker() ~= self and dmginfo:GetAttacker():IsPlayer()
	and dmginfo:GetDamageType() ~= DMG_ALWAYSGIB and dmginfo:GetDamageType() ~= DMG_BURN
	and (not hullzplane and (self:LastHitGroup() == HITGROUP_LEFTLEG or self:LastHitGroup() == HITGROUP_RIGHTLEG)
	or dmginfo:GetDamagePosition().z < self:LocalToWorld(Vector(0, 0, hullzplane)).z)
end

function meta:NearestArsenalCrateOwnedByOther()
	local pos = self:EyePos()

	local arseents = {}
	table.Add(arseents, ents.FindByClass("prop_arsenalcrate"))
	table.Add(arseents, ents.FindByClass("status_arsenalpack"))

	for _, ent in pairs(arseents) do
		local nearest = ent:NearestPoint(pos)
		local owner = ent.GetObjectOwner and ent:GetObjectOwner() or ent:GetOwner()
		if owner ~= self and owner:IsValidHuman() and pos:DistToSqr(nearest) <= 10000 and (WorldVisible(pos, nearest) or self:TraceLine(100).Entity == ent) then
			return ent
		end
	end
end

local OldLastHitGroup = meta.LastHitGroup
function meta:LastHitGroup()
	return self.m_LastHitGroupUnset and CurTime() <= self.m_LastHitGroupUnset and self.m_LastHitGroup or OldLastHitGroup(self)
end

function meta:SetLastHitGroup(hitgroup)
	self.m_LastHitGroup = hitgroup
	self.m_LastHitGroupUnset = CurTime() + 0.2
end

function meta:WasHitInHead()
	return self.m_LastHitInHead and CurTime() <= self.m_LastHitInHead
end

function meta:SetWasHitInHead()
	self.m_LastHitInHead = CurTime() + 0.2
end

function meta:SetPoints(points)
	self:SetDTInt(1, points)
end

function meta:SetBloodArmor(armor)
	self:SetDTInt(DT_PLAYER_INT_BLOODARMOR, armor)
end

function meta:WouldDieFrom(damage, hitpos)
	return self:Health() <= damage * GAMEMODE:GetZombieDamageScale(hitpos, self)
end

function meta:KnockDown(time)
	if P_Team(self) == TEAM_HUMAN then
		self:GiveStatus("knockdown", time or 3)
	end
end

function meta:FakeDeath(sequenceid, modelscale, length, start)
	for _, ent in pairs(ents.FindByClass("fakedeath")) do
		if ent:GetOwner() == self then
			ent:Remove()
		end
	end

	local ent = ents.Create("fakedeath")
	if ent:IsValid() then
		ent:SetOwner(self)
		ent:SetModel(self:GetModel())
		ent:SetSkin(self:GetSkin())
		ent:SetColor(self:GetColor())
		ent:SetMaterial(self:GetMaterial())
		ent:SetPos(self:GetPos() + Vector(0, 0, 64))
		ent:Spawn()
		ent:SetModelScale(modelscale or self:GetModelScale(), 0)

		ent:SetDeathSequence(sequenceid or 0)
		ent:SetDeathAngles(self:GetAngles())
		ent:SetDeathSequenceLength(length or 1)
		ent:SetDeathSequenceStart(start or 0)

		self:DeleteOnRemove(ent)
	end

	return ent
end

function meta:TrySpawnAsGoreChild(ent)
	if ent and ent:IsValid() and not ent.SpawnedOn and ent:GetSettled() then
		ent.SpawnedOn = true

		local ang = self:EyeAngles()
		ang.roll = 0
		ang.pitch = 0

		self.OldDeathClass = self.DeathClass
		self:SetZombieClassName(ent:GetClass() == "prop_thrownbaby" and "Gore Child" or "Shadow Child")
		self.DeathClass = nil
		self.DidntSpawnOnSpawnPoint = true
		self:UnSpectateAndSpawn()
		self.Master = ent:GetOwner()
		self.DeathClass = self.OldDeathClass
		self:SetPos(ent:GetPos())
		self:SetEyeAngles(ang)
		self:StartFeignDeath(true)
		if IsValid(self.FeignDeath) then
			self.FeignDeath:SetState(1)
			self.FeignDeath:SetDirection(math.random(2) == 1 and DIR_FORWARD or DIR_BACK)
		end

		ent:Remove()
	end
end

function meta:SendLifeStats()
	if self.LifeStatSend and self.LifeStatSend > CurTime() then return end
	self.LifeStatSend = CurTime() + 0.33

	net.Start("zs_lifestats")
		net.WriteUInt(math.ceil(self.LifeBarricadeDamage or 0), 16)
		net.WriteUInt(math.ceil(self.LifeHumanDamage or 0), 16)
		net.WriteUInt(self.LifeBrainsEaten or 0, 8)
	net.Send(self)
end

function meta:AddLifeBarricadeDamage(amount)
	self.LifeBarricadeDamage = self.LifeBarricadeDamage + amount
	self.WaveBarricadeDamage = self.WaveBarricadeDamage + amount

	if not self:Alive() and not self:GetZombieClassTable().NeverAlive then
		timer.Simple(0, function() if self:IsValid() then self:SendLifeStats() end end)
	end
end

function meta:AddLifeHumanDamage(amount)
	self.LifeHumanDamage = self.LifeHumanDamage + amount
	self.WaveHumanDamage = self.WaveHumanDamage + amount

	if not self:Alive() then
		timer.Simple(0, function() if self:IsValid() then self:SendLifeStats() end end)
	end
end

function meta:AddLifeBrainsEaten(amount)
	self.LifeBrainsEaten = self.LifeBrainsEaten + amount

	if not self:Alive() then
		timer.Simple(0, function() if self:IsValid() then self:SendLifeStats() end end)
	end
end

function meta:RemoveEphemeralStatuses()
	for _, status in pairs(ents.FindByClass("status_*")) do
		if status.Ephemeral and status:IsValid() and status:GetOwner() == self then
			status:Remove()
		end
	end
end

function meta:AddPoisonDamage(damage, attacker)
	--damage = math.ceil(damage)

	if damage > 0 then
		local status = self:GiveStatus("poison")
		if status and status:IsValid() then
			status:AddDamage(damage, attacker)
		end
	else
		local status = self:GetStatus("poison")
		if status and status:IsValid() then
			status:AddDamage(damage)
		end
	end
end

function meta:AddBleedDamage(damage, attacker)
	--damage = math.ceil(damage)

	if damage > 0 then
		local status = self:GiveStatus("bleed")
		if status and status:IsValid() then
			status:AddDamage(damage, attacker)
		end
	else
		local status = self:GiveStatus("bleed")
		if status and status:IsValid() then
			status:AddDamage(damage)
		end
	end
end

function meta:FloatingScore(victimorpos, effectname, frags, flags)
	if type(victimorpos) == "Vector" then
		net.Start("zs_floatscore_vec")
			net.WriteVector(victimorpos)
			net.WriteString(effectname)
			net.WriteInt(frags, 24)
			net.WriteUInt(flags, 8)
		net.Send(self)
	else
		net.Start("zs_floatscore")
			net.WriteEntity(victimorpos)
			net.WriteString(effectname)
			net.WriteInt(frags, 24)
			net.WriteUInt(flags, 8)
		net.Send(self)
	end
end

function meta:CollectDamageNumberSession(dmg, lastpos, hasplayer)
	self.DamageNumberTally = (self.DamageNumberTally or 0) + dmg
	self.DamageNumberLastPos = self.DamageNumberLastPos and ((self.DamageNumberLastPos + lastpos)/2) or lastpos
	self.DamageNumberHasPlayer = self.DamageNumberHasPlayer or hasplayer
end

function meta:StartDamageNumberSession()
	self.DamageNumberTally = 0
end

function meta:HasDamageNumberSession()
	return self.DamageNumberTally
end

function meta:PopDamageNumberSession()
	local tally, lastpos, hasplayer =
		self.DamageNumberTally,
		self.DamageNumberLastPos,
		self.DamageNumberHasPlayer

	self.DamageNumberTally = nil
	self.DamageNumberLastPos = nil
	self.DamageNumberHasPlayer = nil

	return tally, lastpos, hasplayer
end

function meta:MarkAsBadProfile()
	self.NoProfiling = true
end

function meta:CenterNotify(...)
	net.Start("zs_centernotify")
		net.WriteTable({...})
	net.Send(self)
end

function meta:TopNotify(...)
	net.Start("zs_topnotify")
		net.WriteTable({...})
	net.Send(self)
end

function meta:RefreshDynamicSpawnPoint()
	local target = self:GetObserverTarget()
	if (GAMEMODE:GetDynamicSpawning() and self:GetObserverMode() == OBS_MODE_CHASE and target and target:IsValid()) and
			(self.ZombieEscape and target:IsPlayer() and target:Team() == TEAM_UNDEAD
			or not self.ZombieEscape and (target.IsCreeperNest and target:GetNestBuilt() or target.MinionSpawn and target:GetSettled())
			or string.sub(target:GetClass(), 1, 12) == "info_player_") then
		self.ForceDynamicSpawn = target
		self.ForceSpawnAngles = self:EyeAngles()
	else
		self.ForceDynamicSpawn = nil
		self.ForceSpawnAngles = nil
	end
end

function meta:PushPackedItem(class, ...)
	if self.PackedItems and ... ~= nil then
		local packed = {...}

		self.PackedItems[class] = self.PackedItems[class] or {}

		table.insert(self.PackedItems[class], packed)
	end
end

function meta:PopPackedItem(class)
	if self.PackedItems and self.PackedItems[class] and self.PackedItems[class][1] ~= nil then
		local index = #self.PackedItems[class]
		local data = self.PackedItems[class][index]
		table.remove(self.PackedItems[class], index)

		return data
	end
end

function meta:ChangeToCrow()
	self.StartCrowing = nil

	local crowclass = GAMEMODE.ZombieClasses["Crow"]
	if not crowclass then return end

	local curclass = self.DeathClass or self:GetZombieClass()
	local crowindex = crowclass.Index
	self:SetZombieClass(crowindex)
	self:DoHulls(crowindex, TEAM_UNDEAD)

	self.DeathClass = nil
	self:UnSpectateAndSpawn()
	self.DeathClass = curclass
end

function meta:SelectRandomPlayerModel()
	self:SetModel(player_manager.TranslatePlayerModel(GAMEMODE.RandomPlayerModels[math.random(#GAMEMODE.RandomPlayerModels)]))
end

function meta:GiveEmptyWeapon(weptype)
	if not self:HasWeapon(weptype) then
		local wep = self:Give(weptype)
		if wep and wep:IsValid() and wep:IsWeapon() then
			wep:EmptyAll()
		end

		return wep
	end
end

local OldGive = meta.Give
function meta:Give(weptype, noammo)
	if P_Team(self) ~= TEAM_HUMAN then
		return OldGive(self, weptype, noammo)
	end

	local weps = self:GetWeapons()
	local autoswitch = #weps == 1 and weps[1]:IsValid() and weps[1].AutoSwitchFrom

	local ret = OldGive(self, weptype, noammo)

	if autoswitch then
		self:SelectWeapon(weptype)
	end

	return ret
end

function meta:StartFeignDeath(force)
	local feigndeath = self.FeignDeath
	if feigndeath and feigndeath:IsValid() then
		if CurTime() >= feigndeath:GetStateEndTime() then
			feigndeath:SetState(1)
			feigndeath:SetStateEndTime(CurTime() + 1.5)
		end
	elseif force or self:IsOnGround() and not self:IsPlayingTaunt() then
		local wep = self:GetActiveWeapon()
		if force or wep:IsValid() and not (wep.IsSwinging and wep:IsSwinging()) and CurTime() > wep:GetNextPrimaryFire() then
			if wep:IsValid() and wep.StopMoaning then
				wep:StopMoaning()
			end

			local status = self:GiveStatus("feigndeath")
			if status and status:IsValid() then
				status:SetStateEndTime(CurTime() + 1.5)
			end
		end
	end
end

function meta:UpdateLegDamage()
	net.Start("zs_legdamage")
		net.WriteFloat(self.LegDamage)
	net.Send(self)
end

function meta:UpdateArmDamage()
	net.Start("zs_armdamage")
		net.WriteFloat(self.ArmDamage)
	net.Send(self)
end

function meta:CoupleWith(plheadcrab)
	if self:GetZombieClassTable().Headcrab == plheadcrab:GetZombieClassTable().Name then
		local status = self:GiveStatus("headcrabcouple")
		if status:IsValid() then
			status:SetCouple(plheadcrab)
		end
	end
end

function meta:FixModelAngles(velocity)
	local eye = self:EyeAngles()
	self:SetLocalAngles(eye)
	self:SetPoseParameter("move_yaw", math.NormalizeAngle(velocity:Angle().yaw - eye.y))
end

function meta:RemoveAllStatus(bSilent, bInstant)
	if bInstant then
		for _, ent in pairs(ents.FindByClass("status_*")) do
			if not ent.NoRemoveOnDeath and ent:GetOwner() == self then
				ent:Remove()
			end
		end
	else
		for _, ent in pairs(ents.FindByClass("status_*")) do
			if not ent.NoRemoveOnDeath and ent:GetOwner() == self then
				ent.SilentRemove = bSilent
				ent:SetDie()
			end
		end
	end
end

function meta:RemoveStatus(sType, bSilent, bInstant, sExclude)
	local removed

	for _, ent in pairs(ents.FindByClass("status_"..sType)) do
		if ent:GetOwner() == self and not (sExclude and ent:GetClass() == "status_"..sExclude) then
			if bInstant then
				ent:Remove()
			else
				ent.SilentRemove = bSilent
				ent:SetDie()
			end
			removed = true
		end
	end

	return removed
end

function meta:GetStatus(sType)
	local ent = self["status_"..sType]
	if ent and ent:IsValid() and ent:GetOwner() == self then return ent end
end

function meta:GiveStatus(sType, fDie)
	local resistable = table.HasValue(GAMEMODE.ResistableStatuses, sType)

	if resistable and self:IsSkillActive(SKILL_HAEMOSTASIS) and self:GetBloodArmor() >= 2 then
		self:SetBloodArmor(self:GetBloodArmor() - 2)
		return
	end

	if resistable and self:HasTrinket("biocleanser") and (not self.LastBioCleanser or self.LastBioCleanser + 20 < CurTime()) then
		self.LastBioCleanser = CurTime()
		self.BioCleanserMessage = nil
	end

	local cur = self:GetStatus(sType)
	if cur then
		if fDie then
			cur:SetDie(fDie)
		end
		cur:SetPlayer(self, true)
		return cur
	else
		local ent = ents.Create("status_"..sType)
		if ent:IsValid() then
			ent:Spawn()
			if fDie then
				ent:SetDie(fDie)
			end
			ent:SetPlayer(self)
			return ent
		end
	end
end

function meta:UnSpectateAndSpawn()
	self:UnSpectate()
	self:Spawn()
end

function meta:SecondWind(pl)
	if self.Gibbed or self:Alive() or P_Team(self) ~= TEAM_UNDEAD then return end

	local pos = self:GetPos()
	local angles = self:EyeAngles()
	local lastattacker = self:GetLastAttacker()
	local dclass = self.DeathClass
	self.DeathClass = nil
	self.Revived = true
	self:UnSpectateAndSpawn()
	self.Revived = nil
	self.DeathClass = dclass
	self:SetLastAttacker(lastattacker)
	self:SetPos(pos)
	self:SetHealth(self:Health() * 0.2)
	self:SetEyeAngles(angles)

	self:CallZombieFunction0("OnSecondWind")
end

function meta:DropAll()
	self:DropAllWeapons()
	self:DropAllAmmo()
	self:DropAllInventoryItems()
end

local function CreateRagdoll(pl)
	if pl:IsValid() then pl:OldCreateRagdoll() end
end
local function SetModel(pl, mdl)
	if pl:IsValid() then
		pl:SetModel(mdl)
		timer.Simple(0, function() CreateRagdoll(pl) end)
	end
end

meta.OldCreateRagdoll = meta.OldCreateRagdoll or meta.CreateRagdoll
function meta:CreateRagdoll()
	local status = self.status_overridemodel
	if status and status:IsValid() then
		local mdl = status:GetModel()
		timer.Simple(0, function() SetModel(self, mdl) end)
		status:SetRenderMode(RENDERMODE_NONE)
	else
		self:OldCreateRagdoll()
	end
end

function meta:DropWeaponByType(class)
	if GAMEMODE.ZombieEscape then return end

	local wep = self:GetWeapon(class)
	if wep and wep:IsValid() and not wep.Undroppable then
		local ent = ents.Create("prop_weapon")
		if ent:IsValid() then
			ent:SetWeaponType(class)
			ent:Spawn()

			if wep.AmmoIfHas then
				local ammocount = wep:GetPrimaryAmmoCount()
				local desiredrop = math.min(ammocount, wep.Primary.ClipSize) - wep:Clip1()
				if desiredrop > 0 then
					wep:TakeCombinedPrimaryAmmo(desiredrop)
					wep:SetClip1(desiredrop)
				end
			end
			ent:SetClip1(wep:Clip1())
			ent:SetClip2(wep:Clip2())
			ent.DroppedTime = CurTime()

			self:StripWeapon(class)
			self:UpdateAltSelectedWeapon()

			return ent
		end
	end
end

function meta:DropAllWeapons()
	local vPos = self:GetPos()
	local vVel = self:GetVelocity()
	local zmax = self:OBBMaxs().z * 0.75
	for _, wep in pairs(self:GetWeapons()) do
		if wep:IsValid() then
			local ent = self:DropWeaponByType(wep:GetClass())
			if ent and ent:IsValid() then
				ent:SetPos(vPos + Vector(math.Rand(-16, 16), math.Rand(-16, 16), math.Rand(2, zmax)))
				ent:SetAngles(VectorRand():Angle())
				local phys = ent:GetPhysicsObject()
				if phys:IsValid() then
					phys:AddAngleVelocity(Vector(math.Rand(-720, 720), math.Rand(-720, 720), math.Rand(-720, 720)))
					phys:ApplyForceCenter(phys:GetMass() * (math.Rand(32, 328) * VectorRand():GetNormalized() + vVel))
				end
			end
		end
	end

	if GAMEMODE.ZombieEscape then
		local zewep = self:GetWeapon("weapon_elite")
		if zewep and zewep:IsValid() then
			self:DropWeapon(zewep)
		end
	end
end

function meta:DropAmmoByType(ammotype, amount)
	if GAMEMODE.ZombieEscape then return end

	local mycount = self:GetAmmoCount(ammotype)
	amount = math.min(mycount, amount or mycount)
	if not amount or amount <= 0 then return end

	local ent = ents.Create("prop_ammo")
	if ent:IsValid() then
		ent:SetAmmoType(ammotype)
		ent:SetAmmo(amount)
		ent:Spawn()
		ent.DroppedTime = CurTime()

		self:RemoveAmmo(amount, ammotype)

		return ent
	end
end

function meta:DropAllAmmo()
	local vPos = self:GetPos()
	local vVel = self:GetVelocity()
	local zmax = self:OBBMaxs().z * 0.75
	for ammotype in pairs(GAMEMODE.AmmoCache) do
		local ent = self:DropAmmoByType(ammotype)
		if ent and ent:IsValid() then
			ent:SetPos(vPos + Vector(math.Rand(-16, 16), math.Rand(-16, 16), math.Rand(2, zmax)))
			ent:SetAngles(VectorRand():Angle())
			local phys = ent:GetPhysicsObject()
			if phys:IsValid() then
				phys:AddAngleVelocity(Vector(math.Rand(-720, 720), math.Rand(-720, 720), math.Rand(-720, 720)))
				phys:ApplyForceCenter(phys:GetMass() * (math.Rand(32, 328) * VectorRand():GetNormalized() + vVel))
			end
		end
	end
end

function meta:Resupply(owner, obj)
	if GAMEMODE:GetWave() <= 0 then return end

	local stockpiling = self:IsSkillActive(SKILL_STOCKPILE)
	local stowage = self:IsSkillActive(SKILL_STOWAGE)

	if (stowage and (self.StowageCaches or 0) <= 0) or (not stowage and CurTime() < (self.NextResupplyUse or 0)) then
		self:CenterNotify(COLOR_RED, translate.ClientGet(self, "no_ammo_here"))
		return
	end

	if not stowage then
		self.NextResupplyUse = CurTime() + GAMEMODE.ResupplyBoxCooldown * (self.ResupplyDelayMul or 1) * (stockpiling and 2.12 or 1)

		net.Start("zs_nextresupplyuse")
			net.WriteFloat(self.NextResupplyUse)
		net.Send(self)
	else
		self.StowageCaches = self.StowageCaches - 1

		net.Start("zs_stowagecaches")
			net.WriteInt(self.StowageCaches, 8)
		net.Send(self)
	end

	local ammotype = self:GetResupplyAmmoType()
	local amount = GAMEMODE.AmmoCache[ammotype]

	for i = 1, stockpiling and not stowage and 2 or 1 do
		net.Start("zs_ammopickup")
			net.WriteUInt(amount, 16)
			net.WriteString(ammotype)
		net.Send(self)

		self:GiveAmmo(amount, ammotype)

		if self:IsSkillActive(SKILL_FORAGER) and math.random(4) == 1 and #GAMEMODE.Food > 0 then
			self:Give(GAMEMODE.Food[math.random(#GAMEMODE.Food)])
		end

		if self ~= owner and owner:IsValidHuman() then
			if obj:GetClass() == "prop_resupplybox" then
				owner.ResupplyBoxUsedByOthers = owner.ResupplyBoxUsedByOthers + 1
			end

			owner:AddPoints(0.15, nil, nil, true)

			net.Start("zs_commission")
				net.WriteEntity(obj)
				net.WriteEntity(self)
				net.WriteFloat(0.15)
			net.Send(owner)
		end
	end

	return true
end

-- Lets other players know about our maximum health.
meta.OldSetMaxHealth = meta.OldSetMaxHealth or FindMetaTable("Entity").SetMaxHealth
function meta:SetMaxHealth(num)
	num = math.ceil(num)
	self:SetDTInt(0, num)
	self:OldSetMaxHealth(num)
end

function meta:PointCashOut(ent, fmtype)
	if self.PointQueue >= 1 and P_Team(self) == TEAM_HUMAN then
		local points = self.PointQueue --math.floor(self.PointQueue)
		self.PointQueue = self.PointQueue - points

		self:AddPoints(points, ent or self.LastDamageDealtPos or vector_origin, fmtype)
	end
end

function meta:AddPoints(points, floatingscoreobject, fmtype, nomul)
	if gamemode.Call("IsEscapeDoorOpen") then return end

	if points > 0 and not nomul and self.PointIncomeMul then
		points = points * self.PointIncomeMul
	end

	-- This lets us add partial amounts of points (floats)
	local wholepoints = math.floor(points)
	local remainder = points - wholepoints
	if remainder > 0 then
		self.PointsRemainder = self.PointsRemainder + remainder
		local carryover = math.floor(self.PointsRemainder)
		wholepoints = wholepoints + carryover
		self.PointsRemainder = self.PointsRemainder - carryover
	end

	local absorb = self.PointsToAbsorb
	if absorb and absorb > 0 then
		wholepoints = math.max(wholepoints - absorb, 0)
		self.PointsToAbsorb = absorb - wholepoints

		if wholepoints <= 0 then return end
		self.PointsToAbsorb = nil
	end

	self:AddFrags(wholepoints)
	self:SetPoints(self:GetPoints() + wholepoints)

	if self.PointsVault then
		self.PointsVault = self.PointsVault + wholepoints * GAMEMODE.PointSaving
	end

	if floatingscoreobject then
		self:FloatingScore(floatingscoreobject, "floatingscore", wholepoints, fmtype or FM_NONE)
	end

	local xp = wholepoints
	if GAMEMODE.HumanXPMulti and GAMEMODE.HumanXPMulti >= 0 then
		xp = xp * GAMEMODE.HumanXPMulti
		local wholexp = math.floor(xp)
		local xpremainder = xp - wholexp
		if xpremainder > 0 then
			self.XPRemainder = self.XPRemainder + xpremainder
			local xpcarryover = math.floor(self.XPRemainder)
			xp = wholexp + xpcarryover
			self.XPRemainder = self.XPRemainder - xpcarryover
		end
	end

	self:AddZSXP(xp * (self.RedeemBonus and 1.15 or 1))

	gamemode.Call("PlayerPointsAdded", self, wholepoints)
end

function meta:TakePoints(points)
	self:SetPoints(self:GetPoints() - points)

	if self.PointsVault then
		self.PointsVault = self.PointsVault - points
	end
end

function meta:UpdateAllZombieClasses()
	for _, pl in pairs(player.GetAll()) do
		if pl ~= self and pl:Team() == TEAM_UNDEAD then
			local id = pl:GetZombieClass()
			if id and 0 < id then
				net.Start("zs_zclass")
					net.WriteEntity(pl)
					net.WriteUInt(id, 8)
				net.Send(self)
			end
		end
	end
end

function meta:CreateAmbience(class)
	class = "status_"..class

	for _, ent in pairs(ents.FindByClass(class)) do
		if ent:GetOwner() == self then return end
	end

	local ent = ents.Create(class)
	if ent:IsValid() then
		ent:SetPos(self:LocalToWorld(self:OBBCenter()))
		self[class] = ent
		ent:SetOwner(self)
		ent:SetParent(self)
		ent:Spawn()
	end
end

function meta:SetZombieClass(cl, onlyupdate, filter)
	if onlyupdate then
		net.Start("zs_zclass")
			net.WriteEntity(self)
			net.WriteUInt(cl, 8)
		if filter then
			net.Send(filter)
		else
			net.Broadcast()
		end

		return
	end

	self:CallZombieFunction0("SwitchedAway")

	local classtab = GAMEMODE.ZombieClasses[cl]
	if classtab then
		self.Class = cl
		if P_Team(self) == TEAM_UNDEAD then
			self:DoHulls(cl)
		end
		self:CallZombieFunction0("SwitchedTo")

		net.Start("zs_zclass")
			net.WriteEntity(self)
			net.WriteUInt(cl, 8)
		if filter then
			net.Send(filter)
		else
			net.Broadcast()
		end
	end
end

function meta:DoHulls(classid, teamid)
	teamid = teamid or P_Team(self)
	classid = classid or self:GetZombieClass()

	if teamid == TEAM_UNDEAD then
		local classtab = GAMEMODE.ZombieClasses[classid]
		if classtab then
			if self:Alive() then
				self:SetMoveType(classtab.MoveType or MOVETYPE_WALK)
			end

			if classtab.ModelScale then
				self:SetModelScale(classtab.ModelScale, 0)
			elseif self:GetModelScale() ~= DEFAULT_MODELSCALE then
				self:SetModelScale(DEFAULT_MODELSCALE, 0)
			end

			if not classtab.Hull or not classtab.HullDuck then
				self:ResetHull()
			end
			if classtab.ViewOffset then
				self:SetViewOffset(classtab.ViewOffset)
			elseif self:GetViewOffset() ~= DEFAULT_VIEW_OFFSET then
				self:SetViewOffset(DEFAULT_VIEW_OFFSET)
			end
			if classtab.ViewOffsetDucked then
				self:SetViewOffsetDucked(classtab.ViewOffsetDucked)
			elseif self:GetViewOffsetDucked() ~= DEFAULT_VIEW_OFFSET_DUCKED then
				self:SetViewOffsetDucked(DEFAULT_VIEW_OFFSET_DUCKED)
			end
			if classtab.HullDuck then
				self:SetHullDuck(classtab.HullDuck[1], classtab.HullDuck[2])
			end
			if classtab.Hull then
				self:SetHull(classtab.Hull[1], classtab.Hull[2])
			end
			if classtab.StepSize then
				self:SetStepSize(classtab.StepSize)
			elseif self:GetStepSize() ~= DEFAULT_STEP_SIZE then
				self:SetStepSize(DEFAULT_STEP_SIZE)
			end
			if classtab.JumpPower then
				self:SetJumpPower(classtab.JumpPower)
			elseif self:GetJumpPower() ~= DEFAULT_JUMP_POWER then
				self:SetJumpPower(DEFAULT_JUMP_POWER)
			end
			if classtab.Gravity then
				self:SetGravity(classtab.Gravity)
			elseif self:GetGravity() ~= 1 then
				self:SetGravity(1)
			end
			local bloodcolor = classtab.BloodColor or 0
			if self:GetBloodColor() ~= bloodcolor then
				self:SetBloodColor(bloodcolor)
			end

			self:DrawShadow(not classtab.NoShadow)
			self:SetRenderMode(classtab.RenderMode or RENDERMODE_NORMAL)

			self.NoCollideAll = classtab.NoCollideAll or (classtab.ModelScale or 1) ~= DEFAULT_MODELSCALE
			--self.NoCollideInside = classtab.NoCollideInside or (classtab.ModelScale or 1) ~= DEFAULT_MODELSCALE
			self.AllowTeamDamage = classtab.AllowTeamDamage
			self.NeverAlive = classtab.NeverAlive
			self.KnockbackScale = classtab.KnockbackScale
			local phys = self:GetPhysicsObject()
			if phys:IsValid() then
				phys:SetMass(classtab.Mass or DEFAULT_MASS)
			end
		end
	else
		self:SetModelScale(DEFAULT_MODELSCALE, 0)
		self:ResetHull()
		self:SetViewOffset(DEFAULT_VIEW_OFFSET)
		self:SetViewOffsetDucked(DEFAULT_VIEW_OFFSET_DUCKED)
		self:SetStepSize(DEFAULT_STEP_SIZE)
		self:SetJumpPower(DEFAULT_JUMP_POWER)
		self:SetGravity(1)
		self:SetBloodColor(0)

		self:DrawShadow(true)
		self:SetRenderMode(RENDERMODE_NORMAL)

		self.NoCollideAll = nil
		--self.NoCollideInside = nil
		self.AllowTeamDamage = nil
		self.NeverAlive = nil
		self.KnockbackScale = nil
		local phys = self:GetPhysicsObject()
		if phys:IsValid() then
			phys:SetMass(DEFAULT_MASS)
		end
	end

	net.Start("zs_dohulls")
		net.WriteEntity(self)
		net.WriteUInt(classid, 8)
		net.WriteBool(teamid == TEAM_UNDEAD)
	net.Broadcast()

	self:CollisionRulesChanged()
end

function meta:ChangeTeam(teamid)
	local oldteam = P_Team(self)
	if oldteam ~= teamid then
		gamemode.Call("PreOnPlayerChangedTeam", self, oldteam, teamid)
	end
	self:SetTeam(teamid)
	self:CollisionRulesChanged()
	if oldteam ~= teamid then
		gamemode.Call("OnPlayerChangedTeam", self, oldteam, teamid)
	end
end

function meta:Redeem(silent, noequip)
	if gamemode.Call("PrePlayerRedeemed", self) then return end

	self:RemoveStatus("overridemodel", false, true)

	self:KillSilent()

	self:ChangeTeam(TEAM_HUMAN)
	if not GAMEMODE.InitialVolunteers[self:UniqueID()] then
		self:AddZSXP(50 * (GAMEMODE.ZombieXPMulti or 1))
		self.RedeemBonus = true
	end
	if not noequip then self.m_PreRedeem = true end

	self:Spawn()

	self.m_PreRedeem = nil
	self:DoHulls()

	local frags = self:Frags()
	if frags < 0 then
		self:SetFrags(frags * 5)
	else
		self:SetFrags(0)
	end
	self:SetDeaths(0)

	--[[self.DeathClass = nil
	self:SetZombieClass(GAMEMODE.DefaultZombieClass)]]
	self.DeathClass = GAMEMODE.DefaultZombieClass

	self.SpawnedTime = CurTime()

	if not silent then
		net.Start("zs_playerredeemed")
			net.WriteEntity(self)
		net.Broadcast()
	end

	gamemode.Call("PostPlayerRedeemed", self)
end

function meta:RedeemNextFrame()
	timer.Simple(0, function()
		if IsValid(self) then
			self:CheckRedeem(true)
		end
	end)
end

local walltrace = {mask = MASK_SOLID_BRUSHONLY, mins = Vector(-8, -8, -8), maxs = Vector(8, 8, 8)}
function meta:ShouldCrouchJumpPunish()
	if not self:OnGround() and self:Crouching() and self:GetZombieClassTable().CrouchedWalkSpeed ~= 1 then
		local pos = self:WorldSpaceCenter()

		walltrace.start = pos
		walltrace.endpos = pos + self:GetForward() * 22

		return not util.TraceHull(walltrace).Hit
	end

	return false
end

function meta:TakeBrains(amount)
	self:AddFrags(-amount)
	self.BrainsEaten = self.BrainsEaten - 1
end

function meta:AddBrains(amount)
	self:AddFrags(amount)
	self.BrainsEaten = self.BrainsEaten + 1
	self:CheckRedeem()
end

meta.GetBrains = meta.Frags

function meta:CheckRedeem(instant)
	if not self:IsValid() or P_Team(self) ~= TEAM_UNDEAD
	or GAMEMODE:GetRedeemBrains() <= 0 or self:GetBrains() < GAMEMODE:GetRedeemBrains()
	or GAMEMODE.NoRedeeming or self.NoRedeeming or self:GetZombieClassTable().Boss then return end

	if GAMEMODE:GetWave() ~= GAMEMODE:GetNumberOfWaves() or not GAMEMODE.ObjectiveMap and GAMEMODE:GetNumberOfWaves() == 1 and CurTime() < GAMEMODE:GetWaveEnd() - 300 then
		if instant then
			self:Redeem()
		else
			self:RedeemNextFrame()
		end
	end
end

function meta:AntiGrief(dmginfo, overridenostrict)
	if GAMEMODE.GriefStrict and not overridenostrict then
		dmginfo:SetDamage(0)
		dmginfo:ScaleDamage(0)
		return
	end

	dmginfo:SetDamage(dmginfo:GetDamage() * GAMEMODE.GriefForgiveness)

	self:GivePenalty(math.ceil(dmginfo:GetDamage() * 0.5))
	self:ReflectDamage(dmginfo:GetDamage())
end

function meta:GivePenalty(amount)
	self.m_PenaltyCarry = (self.m_PenaltyCarry or 0) + amount * 0.1
	local frags = math.floor(self.m_PenaltyCarry)
	if frags > 0 then
		self.m_PenaltyCarry = self.m_PenaltyCarry - frags
		self:GivePointPenalty(frags)
	end
end

function meta:GivePointPenalty(amount)
	self:SetFrags(self:Frags() - amount)

	net.Start("zs_penalty")
		net.WriteUInt(amount, 16)
	net.Send(self)
end

function meta:ReflectDamage(damage)
	local frags = self:Frags()
	if frags < GAMEMODE.GriefReflectThreshold then
		self:TakeDamage(math.ceil(damage * frags * -0.05 * GAMEMODE.GriefDamageMultiplier))
	end
end

function meta:GiveWeaponByType(weapon, plyr, ammo)
	local wep = self:GetActiveWeapon()
	if not wep or not wep:IsValid() then return end

	if wep.NoTransfer then return end

	if ammo or wep.AmmoIfHas then
		if not wep.Primary then return end

		local ammotype = wep:ValidPrimaryAmmo()
		local ammocount = wep:GetPrimaryAmmoCount()
		if ammotype and ammocount then
			local desiredgive = math.min(ammocount, math.ceil((GAMEMODE.AmmoCache[ammotype] or wep.Primary.ClipSize) * (ammo and 5 or 1)))
			if desiredgive >= 1 then
				wep:TakeCombinedPrimaryAmmo(desiredgive)
				plyr:GiveAmmo(desiredgive, ammotype)

				net.Start("zs_ammogive")
					net.WriteUInt(desiredgive, 16)
					net.WriteString(ammotype)
					net.WriteEntity(plyr)
				net.Send(self)

				net.Start("zs_ammogiven")
					net.WriteUInt(desiredgive, 16)
					net.WriteString(ammotype)
					net.WriteEntity(self)
				net.Send(plyr)

				self:PlayGiveAmmoSound()
				self:RestartGesture(ACT_GMOD_GESTURE_ITEM_GIVE)
			end
		end
	end

	local primary = wep:ValidPrimaryAmmo()
	if primary and 0 < wep:Clip1() then
		self:GiveAmmo(wep:Clip1(), primary, true)
		wep:SetClip1(0)
	end
	local secondary = wep:ValidSecondaryAmmo()
	if secondary and 0 < wep:Clip2() then
		self:GiveAmmo(wep:Clip2(), secondary, true)
		wep:SetClip2(0)
	end

	self:StripWeapon(weapon:GetClass())
	self:UpdateAltSelectedWeapon()

	local wep2 = plyr:Give(weapon:GetClass())
	if wep2 and wep2:IsValid() then
		if wep2.Primary then
			primary = wep2:ValidPrimaryAmmo()
			if primary then
				wep2:SetClip1(0)
				plyr:RemoveAmmo(math.max(0, wep2.Primary.DefaultClip - wep2.Primary.ClipSize), primary)
			end
		end
		if wep2.Secondary then
			secondary = wep2:ValidSecondaryAmmo()
			if secondary then
				wep2:SetClip2(0)
				plyr:RemoveAmmo(math.max(0, wep2.Secondary.DefaultClip - wep2.Secondary.ClipSize), secondary)
			end
		end
	end
end

function meta:Gib()
	local pos = self:WorldSpaceCenter()

	local effectdata = EffectData()
		effectdata:SetEntity(self)
		effectdata:SetOrigin(pos)
	util.Effect("gib_player", effectdata, true, true)

	self.Gibbed = CurTime()

	timer.Simple(0, function() GAMEMODE:CreateGibs(pos, pos2) end)
end

function meta:GetLastAttacker()
	local ent = self.LastAttacker
	if ent and ent:IsValid() and CurTime() <= self.LastAttacked + 10 then
		return ent
	end
	--self:SetLastAttacker()
end

function meta:SetLastAttacker(ent)
	if ent then
		if ent ~= self then
			self.LastAttacker = ent
			self.LastAttacked = CurTime()
		end
	else
		self.LastAttacker = nil
		self.LastAttacked = nil
	end
end

meta.OldUnSpectate = meta.OldUnSpectate or meta.UnSpectate
function meta:UnSpectate()
	if self:GetObserverMode() ~= OBS_MODE_NONE then
		self:OldUnSpectate(obsm)
	end
end

local function nocollidetimer(self, timername)
	if self:IsValid() then
		for _, e in pairs(ents.FindInBox(self:WorldSpaceAABB())) do
			if e and e:IsValid() and e:IsPlayer() and e ~= self and GAMEMODE:ShouldCollide(self, e) then
				return
			end
		end

		self:SetCollisionGroup(COLLISION_GROUP_PLAYER)
	end

	timer.Remove(timername)
end

function meta:TemporaryNoCollide(force)
	if self:GetCollisionGroup() ~= COLLISION_GROUP_PLAYER and not force then return end

	for _, e in pairs(ents.FindInBox(self:WorldSpaceAABB())) do
		if e and e:IsValid() and e:IsPlayer() and e ~= self and GAMEMODE:ShouldCollide(self, e) then
			self:SetCollisionGroup(COLLISION_GROUP_DEBRIS_TRIGGER)

			local timername = "TemporaryNoCollide"..self:UniqueID()
			timer.Create(timername, 0, 0, function() nocollidetimer(self, timername) end)

			return
		end
	end

	self:SetCollisionGroup(COLLISION_GROUP_PLAYER)
end

function meta:PlayEyePainSound()
	local rf = RecipientFilter()
	rf:AddPAS(self:GetPos())
	net.Start("voice_eyepain")
	net.WriteEntity(self)
	net.Send(rf)
end

function meta:PlayGiveAmmoSound()
	local rf = RecipientFilter()
	rf:AddPAS(self:GetPos())
	net.Start("voice_giveammo")
	net.WriteEntity(self)
	net.Send(rf)
end

function meta:PlayDeathSound()
	local rf = RecipientFilter()
	rf:AddPAS(self:GetPos())
	net.Start("voice_death")
	net.WriteEntity(self)
	net.Send(rf)
end

function meta:PlayZombieDeathSound()
	local rf = RecipientFilter()
	rf:AddPAS(self:GetPos())
	net.Start("voice_zombiedeath")
	net.WriteEntity(self)
	net.Send(rf)
end

function meta:PlayPainSound()
	if CurTime() < self.NextPainSound then return end
	self.NextPainSound = CurTime() + 0.5

	local rf = RecipientFilter()
	rf:AddPAS(self:GetPos())
	net.Start("voice_pain")
	net.WriteEntity(self)
	net.WriteUInt(math.ceil(self:Health() / 25), 4)
	net.Send(rf)
end

function meta:PlayZombiePainSound()
	if CurTime() < self.NextPainSound then return end
	self.NextPainSound = CurTime() + 0.5

	local rf = RecipientFilter()
	rf:AddPAS(self:GetPos())
	net.Start("voice_zombiepain")
	net.WriteEntity(self)
	net.Send(rf)
end

function meta:DoSigilTeleport(target, from, corrupted)
	if not target then return end

	if corrupted == nil then corrupted = false end

	if from and not from:IsValid() or not from:IsWeapon() and self:GetPos():DistToSqr(from:GetPos()) > 16384 or from:IsWeapon() and self:GetActiveWeapon() ~= from then
		return
	end

	if self:IsValidLivingHuman() and target:IsValid() and corrupted == target:GetSigilCorrupted() then
		if CurTime() >= (self._NextSigilTeleportEffect or 0) then
			self._NextSigilTeleportEffect = CurTime() + 0.25

			local effect = corrupted and "corrupted_teleport" or "sigil_teleport"

			local effectdata = EffectData()
			effectdata:SetOrigin(self:WorldSpaceCenter())
			effectdata:SetEntity(self)
			util.Effect(effect, effectdata, true, true)
			effectdata:SetOrigin(target:WorldSpaceCenter())
			util.Effect(effect, effectdata, true, true)
		end

		local movepos = target:GetPos() % 2

		self:SetBarricadeGhosting(true, true)
		for i=1, 5 do
			self:SetPos(movepos)
			self:SetLocalPos(movepos)
		end
		hook.Add("Move", self, function(_, p, mv)
			if p == self then
				hook.Remove("Move", p)
				mv:SetOrigin(movepos)
			end
		end)

		for _, e in pairs(ents.FindInSphere(movepos, 64)) do
			if e:IsValidLivingZombie() then
				e:TemporaryNoCollide(true)
			end
		end

		if from and from:IsValid() and from:IsWeapon() then
			from:TakePrimaryAmmo(1)

			if from:GetPrimaryAmmoCount() <= 0 then
				self:StripWeapon(from:GetClass())
			end
		end
	end
end

local bossdrops = {
	"trinket_bleaksoul",
	"trinket_spiritess"
}

function meta:MakeBossDrop()
	local drop = table.Random(bossdrops)
	local inv = string.sub(drop, 1, 4) ~= "weap"

	local pos = self:LocalToWorld(self:OBBCenter())
	local ent = ents.Create(inv and "prop_invitem" or "prop_weapon")
	if ent:IsValid() then
		ent:SetPos(pos)
		ent:SetAngles(AngleRand())
		if inv then
			ent:SetInventoryItemType(drop)
		else
			ent:SetWeaponType(drop)
		end
		ent:Spawn()

		local phys = ent:GetPhysicsObject()
		if phys:IsValid() then
			phys:Wake()
			phys:SetVelocityInstantaneous(VectorRand():GetNormalized() * math.Rand(24, 100))
			phys:AddAngleVelocity(VectorRand() * 200)
		end
	end
end

function meta:UpdateAltSelectedWeapon()
	net.Start("zs_updatealtselwep")
	net.Send(self)
end

function meta:SendDeployableLostMessage(deployable)
	local deployableclass = deployable:GetClass()
	local deployableinfo = GAMEMODE.DeployableInfo[deployableclass]

	net.Start("zs_deployablelost")
		net.WriteString(deployableinfo.Name)
		net.WriteString(deployableinfo.WepClass)
	net.Send(self)
end

function meta:SendDeployableClaimedMessage(deployable)
	local deployableclass = deployable:GetClass()
	local deployableinfo = GAMEMODE.DeployableInfo[deployableclass]

	net.Start("zs_deployableclaim")
		net.WriteString(deployableinfo.Name)
		net.WriteString(deployableinfo.WepClass)
	net.Send(self)
end

function meta:SendDeployableOutOfAmmoMessage(deployable)
	local deployableclass = deployable:GetClass()
	local deployableinfo = GAMEMODE.DeployableInfo[deployableclass]

	net.Start("zs_deployableout")
		net.WriteString(deployableinfo.Name)
		net.WriteString(deployableinfo.WepClass)
	net.Send(self)
end

function meta:GetRandomStartingItem()
	local pool = {}

	if self:IsSkillActive(SKILL_PREPAREDNESS) and #GAMEMODE.Food > 0 then
		pool[#pool + 1] = GAMEMODE.Food[math.random(#GAMEMODE.Food)]
	end

	if self:IsSkillActive(SKILL_EQUIPPED) then
		pool[#pool + 1] = GAMEMODE.StarterTrinkets[math.random(#GAMEMODE.StarterTrinkets)]
	end

	if #pool > 0 then
		return pool[math.random(#pool)]
	end
end

function meta:PulseResonance(attacker, inflictor)
	-- Weird things happen with multishot weapons..

	timer.Create("PulseResonance" .. attacker:UniqueID(), 0.06, 1, function()
		if not attacker:IsValid() or not self:IsValid() then return end

		attacker.AccuPulse = 0

		local pos = self:WorldSpaceCenter()
		pos.z = pos.z + 16

		if attacker:IsValidLivingHuman() then
			util.BlastDamagePlayer(inflictor, attacker, pos, 100, 75, DMG_ALWAYSGIB, 0.95)
			for _, ent in pairs(util.BlastAlloc(inflictor, attacker, pos, 100 * (attacker.ExpDamageRadiusMul or 1))) do
				if ent:IsValidLivingPlayer() and gamemode.Call("PlayerShouldTakeDamage", ent, attacker) then
					ent:AddLegDamageExt(5, attacker, inflictor, SLOWTYPE_PULSE)
				end
			end
		end

		local effectdata = EffectData()
			effectdata:SetOrigin(pos)
			effectdata:SetNormal(attacker:GetShootPos())
		util.Effect("explosion_shockcore", effectdata)
	end)
end

function meta:CryogenicInduction(attacker, inflictor, damage)
	if self:Health() > self:GetMaxHealthEx() * (damage/100) or math.random(50) > damage then return end

	timer.Create("Cryogenic" .. attacker:UniqueID(), 0.06, 1, function()
		if not attacker:IsValid() or not self:IsValid() then return end

		local pos = self:WorldSpaceCenter()
		pos.z = pos.z + 16

		self:TakeSpecialDamage(self:Health() + 90, DMG_DIRECT, attacker, inflictor, pos)

		if attacker:IsValidLivingHuman() then
			util.BlastDamagePlayer(inflictor, attacker, pos, 100, self:GetMaxHealthEx() * 0.12, DMG_DROWN, 0.95)
			for _, ent in pairs(util.BlastAlloc(inflictor, attacker, pos, 100 * (attacker.ExpDamageRadiusMul or 1))) do
				if ent:IsValidLivingPlayer() and gamemode.Call("PlayerShouldTakeDamage", ent, attacker) then
					ent:AddLegDamageExt(6, attacker, inflictor, SLOWTYPE_COLD)
				end
			end
		end

		local effectdata = EffectData()
			effectdata:SetOrigin(pos)
			effectdata:SetNormal(attacker:GetShootPos())
		util.Effect("hit_ice", effectdata)
	end)
end

function meta:SetPhantomHealth(amount)
	self:SetDTFloat(DT_PLAYER_FLOAT_PHANTOMHEALTH, amount)
end

function meta:HasBarricadeExpert()
	return self:GetZSRemortLevel() > 0
end

function meta:BarricadeExpertPrecedence(otherpl)
	local mygrade, myexpert = self:GetZSRemortLevelGraded(), self:HasBarricadeExpert()
	local othergrade, otherexpert = otherpl:GetZSRemortLevelGraded(), otherpl:HasBarricadeExpert()

	if (myexpert and not otherexpert) or mygrade > othergrade then
		return 1
	elseif (not myexpert and not otherexpert) or (myexpert and mygrade == othergrade) then
		return 0
	end

	return -1
end