mirror of
https://github.com/lifestorm/wnsrc.git
synced 2025-12-16 21:33:46 +03:00
862 lines
27 KiB
Lua
862 lines
27 KiB
Lua
--[[
|
|
| This file was obtained through the combined efforts
|
|
| of Madbluntz & Plymouth Antiquarian Society.
|
|
|
|
|
| Credits: lifestorm, Gregory Wayne Rossel JR.,
|
|
| Maloy, DrPepper10 @ RIP, Atle!
|
|
|
|
|
| Visit for more: https://plymouth.thetwilightzone.ru/
|
|
--]]
|
|
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:OnPhysgunFreeze( weapon, phys, ent, player )
|
|
Desc: The physgun wants to freeze a prop
|
|
-----------------------------------------------------------]]
|
|
function GM:OnPhysgunFreeze( weapon, phys, ent, ply )
|
|
|
|
-- Non vphysics entity, we don't know how to handle that
|
|
if ( !IsValid( phys ) ) then return end
|
|
|
|
-- Object is already frozen (!?)
|
|
if ( !phys:IsMoveable() ) then return end
|
|
if ( ent:GetUnFreezable() ) then return end
|
|
|
|
phys:EnableMotion( false )
|
|
|
|
-- Add it to the player's frozen props
|
|
ply:AddFrozenPhysicsObject( ent, phys )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:OnPhysgunReload( weapon, player )
|
|
Desc: The physgun wants to freeze a prop
|
|
-----------------------------------------------------------]]
|
|
function GM:OnPhysgunReload( weapon, ply )
|
|
|
|
ply:PhysgunUnfreeze()
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerAuthed()
|
|
Desc: Player's STEAMID has been authed
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerAuthed( ply, SteamID, UniqueID )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerCanPickupWeapon()
|
|
Desc: Called when a player tries to pickup a weapon.
|
|
return true to allow the pickup.
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerCanPickupWeapon( ply, entity )
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerCanPickupItem()
|
|
Desc: Called when a player tries to pickup an item.
|
|
return true to allow the pickup.
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerCanPickupItem( ply, entity )
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:CanPlayerUnfreeze()
|
|
Desc: Can the player unfreeze this entity & physobject
|
|
-----------------------------------------------------------]]
|
|
function GM:CanPlayerUnfreeze( ply, entity, physobject )
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerDisconnected()
|
|
Desc: Player has disconnected from the server.
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerDisconnected( ply )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSay()
|
|
Desc: A player (or server) has used say. Return a string
|
|
for the player to say. Return an empty string if the
|
|
player should say nothing.
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSay( ply, text, teamonly )
|
|
|
|
return text
|
|
|
|
end
|
|
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerDeathThink( player )
|
|
Desc: Called when the player is waiting to respawn
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerDeathThink( pl )
|
|
|
|
if ( pl.NextSpawnTime && pl.NextSpawnTime > CurTime() ) then return end
|
|
|
|
if ( pl:IsBot() || pl:KeyPressed( IN_ATTACK ) || pl:KeyPressed( IN_ATTACK2 ) || pl:KeyPressed( IN_JUMP ) ) then
|
|
|
|
pl:Spawn()
|
|
|
|
end
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerUse( player, entity )
|
|
Desc: A player has attempted to use a specific entity
|
|
Return true if the player can use it
|
|
------------------------------------------------------------]]
|
|
function GM:PlayerUse( ply, entity )
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSilentDeath()
|
|
Desc: Called when a player dies silently
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSilentDeath( Victim )
|
|
|
|
Victim.NextSpawnTime = CurTime() + 2
|
|
Victim.DeathTime = CurTime()
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerDeath()
|
|
Desc: Called when a player dies.
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerDeath( ply, inflictor, attacker )
|
|
|
|
-- Don't spawn for at least 2 seconds
|
|
ply.NextSpawnTime = CurTime() + 2
|
|
ply.DeathTime = CurTime()
|
|
|
|
if ( IsValid( attacker ) && attacker:GetClass() == "trigger_hurt" ) then attacker = ply end
|
|
|
|
if ( IsValid( attacker ) && attacker:IsVehicle() && IsValid( attacker:GetDriver() ) ) then
|
|
attacker = attacker:GetDriver()
|
|
end
|
|
|
|
if ( !IsValid( inflictor ) && IsValid( attacker ) ) then
|
|
inflictor = attacker
|
|
end
|
|
|
|
-- Convert the inflictor to the weapon that they're holding if we can.
|
|
-- This can be right or wrong with NPCs since combine can be holding a
|
|
-- pistol but kill you by hitting you with their arm.
|
|
if ( IsValid( inflictor ) && inflictor == attacker && ( inflictor:IsPlayer() || inflictor:IsNPC() ) ) then
|
|
|
|
inflictor = inflictor:GetActiveWeapon()
|
|
if ( !IsValid( inflictor ) ) then inflictor = attacker end
|
|
|
|
end
|
|
|
|
player_manager.RunClass( ply, "Death", inflictor, attacker )
|
|
|
|
if ( attacker == ply ) then
|
|
|
|
self:SendDeathNotice( nil, "suicide", ply, 0 )
|
|
|
|
MsgAll( attacker:Nick() .. " suicided!\n" )
|
|
|
|
return end
|
|
|
|
if ( attacker:IsPlayer() ) then
|
|
|
|
self:SendDeathNotice( attacker, inflictor:GetClass(), ply, 0 )
|
|
|
|
MsgAll( attacker:Nick() .. " killed " .. ply:Nick() .. " using " .. inflictor:GetClass() .. "\n" )
|
|
|
|
return end
|
|
|
|
local flags = 0
|
|
if ( attacker:IsNPC() and attacker:Disposition( ply ) != D_HT ) then flags = flags + DEATH_NOTICE_FRIENDLY_ATTACKER end
|
|
|
|
self:SendDeathNotice( self:GetDeathNoticeEntityName( attacker ), inflictor:GetClass(), ply, 0 )
|
|
|
|
MsgAll( ply:Nick() .. " was killed by " .. attacker:GetClass() .. "\n" )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerInitialSpawn()
|
|
Desc: Called just before the player's first spawn
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerInitialSpawn( pl, transiton )
|
|
|
|
pl:SetTeam( TEAM_UNASSIGNED )
|
|
|
|
if ( GAMEMODE.TeamBased ) then
|
|
pl:ConCommand( "gm_showteam" )
|
|
end
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSpawnAsSpectator()
|
|
Desc: Player spawns as a spectator
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSpawnAsSpectator( pl )
|
|
|
|
pl:StripWeapons()
|
|
|
|
if ( pl:Team() == TEAM_UNASSIGNED ) then
|
|
|
|
pl:Spectate( OBS_MODE_FIXED )
|
|
return
|
|
|
|
end
|
|
|
|
pl:SetTeam( TEAM_SPECTATOR )
|
|
pl:Spectate( OBS_MODE_ROAMING )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSpawn()
|
|
Desc: Called when a player spawns
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSpawn( pl, transiton )
|
|
|
|
--
|
|
-- If the player doesn't have a team in a TeamBased game
|
|
-- then spawn him as a spectator
|
|
--
|
|
if ( self.TeamBased && ( pl:Team() == TEAM_SPECTATOR || pl:Team() == TEAM_UNASSIGNED ) ) then
|
|
|
|
self:PlayerSpawnAsSpectator( pl )
|
|
return
|
|
|
|
end
|
|
|
|
-- Stop observer mode
|
|
pl:UnSpectate()
|
|
|
|
player_manager.OnPlayerSpawn( pl, transiton )
|
|
player_manager.RunClass( pl, "Spawn" )
|
|
|
|
-- If we are in transition, do not touch player's weapons
|
|
if ( !transiton ) then
|
|
-- Call item loadout function
|
|
hook.Call( "PlayerLoadout", GAMEMODE, pl )
|
|
end
|
|
|
|
-- Set player model
|
|
hook.Call( "PlayerSetModel", GAMEMODE, pl )
|
|
|
|
pl:SetupHands()
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSetModel()
|
|
Desc: Set the player's model
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSetModel( pl )
|
|
|
|
player_manager.RunClass( pl, "SetModel" )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSetHandsModel()
|
|
Desc: Sets the player's view model hands model
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSetHandsModel( pl, ent )
|
|
|
|
local info = player_manager.RunClass( pl, "GetHandsModel" )
|
|
if ( !info ) then
|
|
local playermodel = player_manager.TranslateToPlayerModelName( pl:GetModel() )
|
|
info = player_manager.TranslatePlayerHands( playermodel )
|
|
end
|
|
|
|
if ( info ) then
|
|
ent:SetModel( info.model )
|
|
ent:SetSkin( info.matchBodySkin and pl:GetSkin() or info.skin )
|
|
ent:SetBodyGroups( info.body )
|
|
end
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerLoadout()
|
|
Desc: Give the player the default spawning weapons/ammo
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerLoadout( pl )
|
|
|
|
player_manager.RunClass( pl, "Loadout" )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSelectTeamSpawn( player )
|
|
Desc: Find a spawn point entity for this player's team
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSelectTeamSpawn( TeamID, pl )
|
|
|
|
local SpawnPoints = team.GetSpawnPoints( TeamID )
|
|
if ( !SpawnPoints || table.IsEmpty( SpawnPoints ) ) then return end
|
|
|
|
local ChosenSpawnPoint = nil
|
|
|
|
for i = 0, 6 do
|
|
|
|
ChosenSpawnPoint = table.Random( SpawnPoints )
|
|
if ( hook.Call( "IsSpawnpointSuitable", GAMEMODE, pl, ChosenSpawnPoint, i == 6 ) ) then
|
|
return ChosenSpawnPoint
|
|
end
|
|
|
|
end
|
|
|
|
return ChosenSpawnPoint
|
|
|
|
end
|
|
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:IsSpawnpointSuitable( player )
|
|
Desc: Find out if the spawnpoint is suitable or not
|
|
-----------------------------------------------------------]]
|
|
local spawnpointmin = Vector( -16, -16, 0 )
|
|
local spawnpointmax = Vector( 16, 16, 64 )
|
|
function GM:IsSpawnpointSuitable( pl, spawnpointent, bMakeSuitable )
|
|
|
|
local Pos = spawnpointent:GetPos()
|
|
|
|
-- Note that we're searching the default hull size here for a player in the way of our spawning.
|
|
-- This seems pretty rough, seeing as our player's hull could be different.. but it should do the job
|
|
-- (HL2DM kills everything within a 128 unit radius)
|
|
if ( pl:Team() == TEAM_SPECTATOR ) then return true end
|
|
|
|
local Blockers = 0
|
|
for k, v in ipairs( ents.FindInBox( Pos + spawnpointmin, Pos + spawnpointmax ) ) do
|
|
if ( IsValid( v ) && v != pl && v:GetClass() == "player" && v:Alive() ) then
|
|
|
|
Blockers = Blockers + 1
|
|
|
|
if ( bMakeSuitable ) then
|
|
v:Kill()
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
if ( bMakeSuitable ) then return true end
|
|
if ( Blockers > 0 ) then return false end
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSelectSpawn( player )
|
|
Desc: Find a spawn point entity for this player
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSelectSpawn( pl, transiton )
|
|
|
|
-- If we are in transition, do not reset player's position
|
|
if ( transiton ) then return end
|
|
|
|
if ( self.TeamBased ) then
|
|
|
|
local ent = self:PlayerSelectTeamSpawn( pl:Team(), pl )
|
|
if ( IsValid( ent ) ) then return ent end
|
|
|
|
end
|
|
|
|
-- Save information about all of the spawn points
|
|
-- in a team based game you'd split up the spawns
|
|
if ( !IsTableOfEntitiesValid( self.SpawnPoints ) ) then
|
|
|
|
self.LastSpawnPoint = 0
|
|
self.SpawnPoints = ents.FindByClass( "info_player_start" )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_deathmatch" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_combine" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_rebel" ) )
|
|
|
|
-- CS Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_counterterrorist" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_terrorist" ) )
|
|
|
|
-- DOD Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_axis" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_allies" ) )
|
|
|
|
-- (Old) GMod Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "gmod_player_start" ) )
|
|
|
|
-- TF Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_teamspawn" ) )
|
|
|
|
-- INS Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "ins_spawnpoint" ) )
|
|
|
|
-- AOC Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "aoc_spawnpoint" ) )
|
|
|
|
-- Dystopia Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "dys_spawn_point" ) )
|
|
|
|
-- PVKII Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_pirate" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_viking" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_knight" ) )
|
|
|
|
-- DIPRIP Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "diprip_start_team_blue" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "diprip_start_team_red" ) )
|
|
|
|
-- OB Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_red" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_blue" ) )
|
|
|
|
-- SYN Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_coop" ) )
|
|
|
|
-- ZPS Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_human" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_zombie" ) )
|
|
|
|
-- ZM Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_zombiemaster" ) )
|
|
|
|
-- FOF Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_fof" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_desperado" ) )
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_player_vigilante" ) )
|
|
|
|
-- L4D Maps
|
|
self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_survivor_rescue" ) )
|
|
-- Removing this one for the time being, c1m4_atrium has one of these in a box under the map
|
|
--self.SpawnPoints = table.Add( self.SpawnPoints, ents.FindByClass( "info_survivor_position" ) )
|
|
|
|
end
|
|
|
|
local Count = table.Count( self.SpawnPoints )
|
|
|
|
if ( Count == 0 ) then
|
|
Msg("[PlayerSelectSpawn] Error! No spawn points!\n")
|
|
return nil
|
|
end
|
|
|
|
-- If any of the spawnpoints have a MASTER flag then only use that one.
|
|
-- This is needed for single player maps.
|
|
for k, v in pairs( self.SpawnPoints ) do
|
|
|
|
if ( v:HasSpawnFlags( 1 ) && hook.Call( "IsSpawnpointSuitable", GAMEMODE, pl, v, true ) ) then
|
|
return v
|
|
end
|
|
|
|
end
|
|
|
|
local ChosenSpawnPoint = nil
|
|
|
|
-- Try to work out the best, random spawnpoint
|
|
for i = 1, Count do
|
|
|
|
ChosenSpawnPoint = table.Random( self.SpawnPoints )
|
|
|
|
if ( IsValid( ChosenSpawnPoint ) && ChosenSpawnPoint:IsInWorld() ) then
|
|
if ( ( ChosenSpawnPoint == pl:GetVar( "LastSpawnpoint" ) || ChosenSpawnPoint == self.LastSpawnPoint ) && Count > 1 ) then continue end
|
|
|
|
if ( hook.Call( "IsSpawnpointSuitable", GAMEMODE, pl, ChosenSpawnPoint, i == Count ) ) then
|
|
|
|
self.LastSpawnPoint = ChosenSpawnPoint
|
|
pl:SetVar( "LastSpawnpoint", ChosenSpawnPoint )
|
|
return ChosenSpawnPoint
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return ChosenSpawnPoint
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:WeaponEquip( weapon )
|
|
Desc: Player just picked up (or was given) weapon
|
|
-----------------------------------------------------------]]
|
|
function GM:WeaponEquip( weapon )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:ScalePlayerDamage( ply, hitgroup, dmginfo )
|
|
Desc: Scale the damage based on being shot in a hitbox
|
|
Return true to not take damage
|
|
-----------------------------------------------------------]]
|
|
function GM:ScalePlayerDamage( ply, hitgroup, dmginfo )
|
|
|
|
-- More damage if we're shot in the head
|
|
if ( hitgroup == HITGROUP_HEAD ) then
|
|
|
|
dmginfo:ScaleDamage( 2 )
|
|
|
|
end
|
|
|
|
-- Less damage if we're shot in the arms or legs
|
|
if ( hitgroup == HITGROUP_LEFTARM ||
|
|
hitgroup == HITGROUP_RIGHTARM ||
|
|
hitgroup == HITGROUP_LEFTLEG ||
|
|
hitgroup == HITGROUP_RIGHTLEG ||
|
|
hitgroup == HITGROUP_GEAR ) then
|
|
|
|
dmginfo:ScaleDamage( 0.25 )
|
|
|
|
end
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerDeathSound()
|
|
Desc: Return true to not play the default sounds
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerDeathSound()
|
|
return false
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:SetupPlayerVisibility()
|
|
Desc: Add extra positions to the player's PVS
|
|
-----------------------------------------------------------]]
|
|
function GM:SetupPlayerVisibility( pPlayer, pViewEntity )
|
|
--AddOriginToPVS( vector_position_here )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:OnDamagedByExplosion( ply, dmginfo)
|
|
Desc: Player has been hurt by an explosion
|
|
-----------------------------------------------------------]]
|
|
function GM:OnDamagedByExplosion( ply, dmginfo )
|
|
ply:SetDSP( 35, false )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:CanPlayerSuicide( ply )
|
|
Desc: Player typed KILL in the console. Can they kill themselves?
|
|
-----------------------------------------------------------]]
|
|
function GM:CanPlayerSuicide( ply )
|
|
return true
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:CanPlayerEnterVehicle( player, vehicle, role )
|
|
Desc: Return true if player can enter vehicle
|
|
-----------------------------------------------------------]]
|
|
function GM:CanPlayerEnterVehicle( ply, vehicle, role )
|
|
return true
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerEnteredVehicle( player, vehicle, role )
|
|
Desc: Player entered the vehicle fine
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerEnteredVehicle( ply, vehicle, role )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:CanExitVehicle()
|
|
Desc: If the player is allowed to leave the vehicle, return true
|
|
-----------------------------------------------------------]]
|
|
function GM:CanExitVehicle( vehicle, passenger )
|
|
return true
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerLeaveVehicle()
|
|
Desc: Player left the vehicle
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerLeaveVehicle( ply, vehicle )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSwitchFlashlight()
|
|
Desc: Return true to allow action
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSwitchFlashlight( ply, SwitchOn )
|
|
return ply:CanUseFlashlight()
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerCanJoinTeam( ply, teamid )
|
|
Desc: Allow mods/addons to easily determine whether a player
|
|
can join a team or not
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerCanJoinTeam( ply, teamid )
|
|
|
|
local TimeBetweenSwitches = GAMEMODE.SecondsBetweenTeamSwitches or 10
|
|
if ( ply.LastTeamSwitch && RealTime() - ply.LastTeamSwitch < TimeBetweenSwitches ) then
|
|
ply.LastTeamSwitch = ply.LastTeamSwitch + 1
|
|
ply:ChatPrint( Format( "Please wait %i more seconds before trying to change team again", ( TimeBetweenSwitches - ( RealTime() - ply.LastTeamSwitch ) ) + 1 ) )
|
|
return false
|
|
end
|
|
|
|
-- Already on this team!
|
|
if ( ply:Team() == teamid ) then
|
|
ply:ChatPrint( "You're already on that team" )
|
|
return false
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerRequestTeam()
|
|
Desc: Player wants to change team
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerRequestTeam( ply, teamid )
|
|
|
|
-- No changing teams if not teambased!
|
|
if ( !GAMEMODE.TeamBased ) then return end
|
|
|
|
-- This team isn't joinable
|
|
if ( !team.Joinable( teamid ) ) then
|
|
ply:ChatPrint( "You can't join that team" )
|
|
return end
|
|
|
|
-- This team isn't joinable
|
|
if ( !GAMEMODE:PlayerCanJoinTeam( ply, teamid ) ) then
|
|
-- Messages here should be outputted by this function
|
|
return end
|
|
|
|
GAMEMODE:PlayerJoinTeam( ply, teamid )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerJoinTeam()
|
|
Desc: Make player join this team
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerJoinTeam( ply, teamid )
|
|
|
|
local iOldTeam = ply:Team()
|
|
|
|
if ( ply:Alive() ) then
|
|
if ( iOldTeam == TEAM_SPECTATOR || iOldTeam == TEAM_UNASSIGNED ) then
|
|
ply:KillSilent()
|
|
else
|
|
ply:Kill()
|
|
end
|
|
end
|
|
|
|
ply:SetTeam( teamid )
|
|
ply.LastTeamSwitch = RealTime()
|
|
|
|
GAMEMODE:OnPlayerChangedTeam( ply, iOldTeam, teamid )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:OnPlayerChangedTeam( ply, oldteam, newteam )
|
|
-----------------------------------------------------------]]
|
|
function GM:OnPlayerChangedTeam( ply, oldteam, newteam )
|
|
|
|
-- Here's an immediate respawn thing by default. If you want to
|
|
-- re-create something more like CS or some shit you could probably
|
|
-- change to a spectator or something while dead.
|
|
if ( newteam == TEAM_SPECTATOR ) then
|
|
|
|
-- If we changed to spectator mode, respawn where we are
|
|
local Pos = ply:EyePos()
|
|
ply:Spawn()
|
|
ply:SetPos( Pos )
|
|
|
|
elseif ( oldteam == TEAM_SPECTATOR ) then
|
|
|
|
-- If we're changing from spectator, join the game
|
|
ply:Spawn()
|
|
|
|
else
|
|
|
|
-- If we're straight up changing teams just hang
|
|
-- around until we're ready to respawn onto the
|
|
-- team that we chose
|
|
|
|
end
|
|
|
|
PrintMessage( HUD_PRINTTALK, Format( "%s joined '%s'", ply:Nick(), team.GetName( newteam ) ) )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerSpray()
|
|
Desc: Return true to prevent player spraying
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerSpray( ply )
|
|
|
|
return false
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:OnPlayerHitGround()
|
|
Desc: Return true to disable default action
|
|
-----------------------------------------------------------]]
|
|
function GM:OnPlayerHitGround( ply, bInWater, bOnFloater, flFallSpeed )
|
|
|
|
-- Apply damage and play collision sound here
|
|
-- then return true to disable the default action
|
|
--MsgN( ply, bInWater, bOnFloater, flFallSpeed )
|
|
--return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:GetFallDamage()
|
|
Desc: return amount of damage to do due to fall
|
|
-----------------------------------------------------------]]
|
|
local mp_falldamage = GetConVar( "mp_falldamage" )
|
|
|
|
function GM:GetFallDamage( ply, flFallSpeed )
|
|
|
|
if ( mp_falldamage:GetBool() ) then -- realistic fall damage is on
|
|
return ( flFallSpeed - 526.5 ) * ( 100 / 396 ) -- the Source SDK value
|
|
end
|
|
|
|
return 10
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerCanSeePlayersChat()
|
|
Desc: Can this player see the other player's chat?
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerCanSeePlayersChat( strText, bTeamOnly, pListener, pSpeaker )
|
|
|
|
if ( bTeamOnly ) then
|
|
if ( !IsValid( pSpeaker ) || !IsValid( pListener ) ) then return false end
|
|
if ( pListener:Team() != pSpeaker:Team() ) then return false end
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
local sv_alltalk = GetConVar( "sv_alltalk" )
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerCanHearPlayersVoice()
|
|
Desc: Can this player see the other player's voice?
|
|
Returns 2 bools.
|
|
1. Can the player hear the other player
|
|
2. Can they hear them spacially
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerCanHearPlayersVoice( pListener, pTalker )
|
|
|
|
local alltalk = sv_alltalk:GetInt()
|
|
if ( alltalk >= 1 ) then return true, alltalk == 2 end
|
|
|
|
return pListener:Team() == pTalker:Team(), false
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:NetworkIDValidated()
|
|
Desc: Called when Steam has validated this as a valid player
|
|
-----------------------------------------------------------]]
|
|
function GM:NetworkIDValidated( name, steamid )
|
|
|
|
-- MsgN( "GM:NetworkIDValidated", name, steamid )
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerShouldTaunt( ply, actid )
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerShouldTaunt( ply, actid )
|
|
|
|
-- The default behaviour is to always let them act
|
|
-- Some gamemodes will obviously want to stop this for certain players by returning false
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerStartTaunt( ply, actid, length )
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerStartTaunt( ply, actid, length )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:AllowPlayerPickup( ply, object )
|
|
-----------------------------------------------------------]]
|
|
function GM:AllowPlayerPickup( ply, object )
|
|
|
|
-- Should the player be allowed to pick this object up (using ENTER)?
|
|
-- If no then return false. Default is HELL YEAH
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:PlayerDroppedWeapon()
|
|
Desc: Player has dropped a weapon
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerDroppedWeapon( ply, weapon )
|
|
end
|
|
|
|
--[[---------------------------------------------------------
|
|
These are buttons that the client is pressing. They're used
|
|
in Sandbox mode to control things like wheels, thrusters etc.
|
|
-----------------------------------------------------------]]
|
|
function GM:PlayerButtonDown( ply, btn ) end
|
|
function GM:PlayerButtonUp( ply, btn ) end
|
|
|
|
concommand.Add( "changeteam", function( pl, cmd, args ) hook.Call( "PlayerRequestTeam", GAMEMODE, pl, tonumber( args[ 1 ] ) ) end )
|
|
|
|
--[[---------------------------------------------------------
|
|
Name: gamemode:HandlePlayerArmorReduction()
|
|
Desc: Handle player armor reduction
|
|
-----------------------------------------------------------]]
|
|
function GM:HandlePlayerArmorReduction( ply, dmginfo )
|
|
|
|
-- If no armor, or special damage types, bypass armor
|
|
if ( ply:Armor() <= 0 || bit.band( dmginfo:GetDamageType(), DMG_FALL + DMG_DROWN + DMG_POISON + DMG_RADIATION ) != 0 ) then return end
|
|
|
|
local flBonus = 1.0 -- Each Point of Armor is worth 1/x points of health
|
|
local flRatio = 0.2 -- Armor Takes 80% of the damage
|
|
if ( GetConVar( "player_old_armor" ):GetBool() ) then
|
|
flBonus = 0.5
|
|
end
|
|
|
|
local flNew = dmginfo:GetDamage() * flRatio
|
|
local flArmor = (dmginfo:GetDamage() - flNew) * flBonus
|
|
|
|
if ( !GetConVar( "player_old_armor" ):GetBool() ) then
|
|
if ( flArmor < 0.1 ) then flArmor = 0 end -- Let's not have tiny amounts of damage reduce a lot of our armor
|
|
else if ( flArmor < 1.0 ) then flArmor = 1.0 end
|
|
end
|
|
|
|
-- Does this use more armor than we have?
|
|
if ( flArmor > ply:Armor() ) then
|
|
|
|
flArmor = ply:Armor() * ( 1 / flBonus )
|
|
flNew = dmginfo:GetDamage() - flArmor
|
|
ply:SetArmor( 0 )
|
|
|
|
else
|
|
ply:SetArmor( ply:Armor() - flArmor )
|
|
end
|
|
|
|
dmginfo:SetDamage( flNew )
|
|
|
|
end
|