carlsmei/wnsrc
1
0
Fork 0
mirror of https://github.com/lifestorm/wnsrc.git synced 2025-12-17 13:53:45 +03:00
Code Issues Packages Projects Releases Wiki Activity

Upload

Browse Source
This commit is contained in:
lifestorm
2024-08-04 23:54:45 +03:00
parent 8064ba84d8
commit 6a58f406b1
7522 changed files with 4011896 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
lua/includes/modules/ai_schedule.lua Normal file
View File

@@ -0,0 +1,108 @@
--[[
| 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/
--]]
-- Serverside only.
if ( CLIENT ) then return end
local setmetatable = setmetatable
local tostring = tostring
local table = table
local ai_task = ai_task
module( "ai_schedule" )
-- Define the Schedule object
local Schedule = {}
Schedule.__index = Schedule
--[[---------------------------------------------------------
Name: Init
Sets the object up. Called automatically from ai_schedule.new.
-----------------------------------------------------------]]
function Schedule:Init( _debugname_ )
self.DebugName = tostring( _debugname_ )
self.Tasks = {}
self.TaskCount = 0
end
--[[---------------------------------------------------------
Adds an engine task to the schedule
schd:EngTask( "TASK_TARGET_PLAYER", 0 )
-----------------------------------------------------------]]
function Schedule:EngTask( _taskname_, _taskdata_ )
local NewTask = ai_task.New()
NewTask:InitEngine( _taskname_, _taskdata_ )
self.TaskCount = table.insert( self.Tasks, NewTask )
end
--[[---------------------------------------------------------
Adds Lua NPC task to the schedule
schdChase:AddTask( "LookForPlayer", "AnyDataYouWant" )
will call the functions
NPC:TaskStart_LookForPlayer( "AnyDataYouWant" ) - once on start
NPC:Task_LookForPlayer( "AnyDataYouWant" ) - every think until TaskComplete
-----------------------------------------------------------]]
function Schedule:AddTask( _functionname_, _data_ )
local NewTask = ai_task.New()
NewTask:InitFunctionName( "TaskStart_" .. _functionname_, "Task_" .. _functionname_, _data_ )
self.TaskCount = table.insert( self.Tasks, NewTask )
end
--[[---------------------------------------------------------
The same as above but you get to specify the exact
function name to call
-----------------------------------------------------------]]
function Schedule:AddTaskEx( _start, _run, _data_ )
local NewTask = ai_task.New()
NewTask:InitFunctionName( _start, _run, _data_ )
self.TaskCount = table.insert( self.Tasks, NewTask )
end
function Schedule:NumTasks()
return self.TaskCount
end
function Schedule:GetTask( num )
return self.Tasks[ num ]
end
--[[---------------------------------------------------------
Create a new empty task (this is ai_schedule.New )
-----------------------------------------------------------]]
function New( debugname )
local pNewSchedule = {}
setmetatable( pNewSchedule, Schedule )
pNewSchedule:Init( debugname )
return pNewSchedule
end

133
lua/includes/modules/ai_task.lua Normal file
View File

@@ -0,0 +1,133 @@
--[[
| 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/
--]]
-- Serverside only.
if ( CLIENT ) then return end
local setmetatable = setmetatable
--local table = table
local ai = ai
module( "ai_task" )
--[[---------------------------------------------------------
ENUMs for which kind of task it is.
-----------------------------------------------------------]]
local TYPE_ENGINE = 1
local TYPE_FNAME = 2
--[[---------------------------------------------------------
Keep track of created tasks
UNDONE: There's no need for this right now.
-----------------------------------------------------------]]
--local Task_Index = {}
--[[---------------------------------------------------------
Task metatable
-----------------------------------------------------------]]
local Task = {}
Task.__index = Task
function Task:Init()
self.Type = nil
end
--[[---------------------------------------------------------
Creates an engine based task
-----------------------------------------------------------]]
function Task:InitEngine( _taskname_, _taskdata_ )
self.TaskName = _taskname_
self.TaskID = nil
self.TaskData = _taskdata_
self.Type = TYPE_ENGINE
end
--[[---------------------------------------------------------
Creates an engine based task
-----------------------------------------------------------]]
function Task:InitFunctionName( _start, _end, _taskdata_ )
self.StartFunctionName = _start
self.FunctionName = _end
self.TaskData = _taskdata_
self.Type = TYPE_FNAME
end
function Task:IsEngineType()
return ( self.Type == TYPE_ENGINE )
end
function Task:IsFNameType()
return ( self.Type == TYPE_FNAME )
end
function Task:Start( npc )
if ( self:IsFNameType() ) then self:Start_FName( npc ) return end
if ( self:IsEngineType() ) then
if ( !self.TaskID ) then self.TaskID = ai.GetTaskID( self.TaskName ) end
npc:StartEngineTask( self.TaskID, self.TaskData )
end
end
--[[---------------------------------------------------------
Start_FName (called from Task:Start)
-----------------------------------------------------------]]
function Task:Start_FName( npc )
if ( !self.StartFunctionName ) then return end
--if ( !npc[ self.StartFunctionName ] ) then return end
-- Run the start function. Safely.
npc[ self.StartFunctionName ]( npc, self.TaskData )
end
function Task:Run( npc )
if ( self:IsFNameType() ) then self:Run_FName( npc ) return end
if ( self:IsEngineType() ) then
npc:RunEngineTask( self.TaskID, self.TaskData )
end
end
function Task:Run_FName( npc )
if ( !self.FunctionName ) then return end
--if (!npc[ self.StartFunctionName ]) then return end
-- Run the start function. Safely.
npc[ self.FunctionName ]( npc, self.TaskData )
end
--[[---------------------------------------------------------
Create a new empty task (this is ai_task.New )
-----------------------------------------------------------]]
function New()
local pNewTask = {}
setmetatable( pNewTask, Task )
pNewTask:Init()
--table.insert( Task_Index, pNewTask )
return pNewTask
end

75
lua/includes/modules/ai_vj_schedule.lua Normal file
View File

@@ -0,0 +1,75 @@
--[[
| 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/
--]]
/*--------------------------------------------------
=============== VJ AI Schedule Module ===============
*** Copyright (c) 2012-2023 by DrVrej, All rights reserved. ***
No parts of this code or any of its contents may be reproduced, copied, modified or adapted,
without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
INFO: This is mostly Garry's code, except I improved and organized.
NOTES: This is server side only!
--------------------------------------------------*/
if CLIENT then return end
print("VJ Base A.I. module initialized!")
local setmetatable = setmetatable
local tostring = tostring
local table = table
require("ai_vj_task")
local ai_vj_task = ai_vj_task
module("ai_vj_schedule")
local Schedule = {}
Schedule.__index = Schedule
---------------------------------------------------------------------------------------------------------------------------------------------
function Schedule:Init(_debugname_)
self.DebugName = tostring(_debugname_)
self.Tasks = {}
self.TaskCount = 0
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Schedule:EngTask(_taskname_,_taskdata_)
local NewTask = ai_vj_task.New()
NewTask:InitEngine(_taskname_,_taskdata_)
table.insert(self.Tasks,NewTask)
self.TaskCount = self.TaskCount + 1
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Schedule:AddTask(_functionname_,_data_)
local NewTask = ai_vj_task.New()
NewTask:InitFunctionName("TaskStart_".._functionname_,"Task_".._functionname_,_data_)
table.insert(self.Tasks,NewTask)
//print(self.TaskCount.." AddTask has ran!")
self.TaskCount = self.TaskCount + 1 -- Or else it will make an error saying NumTasks is a nil value
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Schedule:AddTaskEx(_start,_run,_data_)
local NewTask = ai_vj_task.New()
NewTask:InitFunctionName(_start, _run, _data_)
table.insert(self.Tasks,NewTask)
self.TaskCount = self.TaskCount + 2 -- Or else it will make an error saying NumTasks is a nil value
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Schedule:NumTasks()
return self.TaskCount
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Schedule:GetTask(num)
return self.Tasks[num]
end
---------------------------------------------------------------------------------------------------------------------------------------------
function New(debugname)
local pNewSchedule = {}
setmetatable(pNewSchedule,Schedule)
pNewSchedule:Init(debugname)
return pNewSchedule
end

243
lua/includes/modules/ai_vj_task.lua Normal file
View File

@@ -0,0 +1,243 @@
--[[
| 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/
--]]
/*--------------------------------------------------
=============== VJ AI Task Module ===============
*** Copyright (c) 2012-2023 by DrVrej, All rights reserved. ***
No parts of this code or any of its contents may be reproduced, copied, modified or adapted,
without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
INFO: This is mostly Garry's code, except I improved and organized.
NOTES: This is server side only!
NOTES: A lot of the fix is from: https://github.com/garrynewman/garrysmod/pull/524
--------------------------------------------------*/
if CLIENT then return end
local setmetatable = setmetatable
local TaskList = {
["TASK_INVALID"] = 0,
["TASK_RESET_ACTIVITY"] = 1,
["TASK_WAIT"] = 2,
["TASK_ANNOUNCE_ATTACK"] = 3,
["TASK_WAIT_FACE_ENEMY"] = 4,
["TASK_WAIT_FACE_ENEMY_RANDOM"] = 5,
["TASK_WAIT_PVS"] = 6,
["TASK_SUGGEST_STATE"] = 7,
["TASK_TARGET_PLAYER"] = 8,
["TASK_SCRIPT_WALK_TO_TARGET"] = 9,
["TASK_SCRIPT_RUN_TO_TARGET"] = 10,
["TASK_SCRIPT_CUSTOM_MOVE_TO_TARGET"] = 11,
["TASK_MOVE_TO_TARGET_RANGE"] = 12,
["TASK_MOVE_TO_GOAL_RANGE"] = 13,
["TASK_MOVE_AWAY_PATH"] = 14,
["TASK_GET_PATH_AWAY_FROM_BEST_SOUND"] = 15,
["TASK_SET_GOAL"] = 16,
["TASK_GET_PATH_TO_GOAL"] = 17,
["TASK_GET_PATH_TO_ENEMY"] = 18,
["TASK_GET_PATH_TO_ENEMY_LKP"] = 19,
["TASK_GET_CHASE_PATH_TO_ENEMY"] = 20,
["TASK_GET_PATH_TO_ENEMY_LKP_LOS"] = 21,
["TASK_GET_PATH_TO_ENEMY_CORPSE"] = 22,
["TASK_GET_PATH_TO_PLAYER"] = 23,
["TASK_GET_PATH_TO_ENEMY_LOS"] = 24,
["TASK_GET_FLANK_RADIUS_PATH_TO_ENEMY_LOS"] = 25,
["TASK_GET_FLANK_ARC_PATH_TO_ENEMY_LOS"] = 26,
["TASK_GET_PATH_TO_RANGE_ENEMY_LKP_LOS"] = 27,
["TASK_GET_PATH_TO_TARGET"] = 28,
["TASK_GET_PATH_TO_TARGET_WEAPON"] = 29,
["TASK_CREATE_PENDING_WEAPON"] = 30,
["TASK_GET_PATH_TO_HINTNODE"] = 31,
["TASK_STORE_LASTPOSITION"] = 32,
["TASK_CLEAR_LASTPOSITION"] = 33,
["TASK_STORE_POSITION_IN_SAVEPOSITION"] = 34,
["TASK_STORE_BESTSOUND_IN_SAVEPOSITION"] = 35,
["TASK_STORE_BESTSOUND_REACTORIGIN_IN_SAVEPOSITION"] = 36,
["TASK_REACT_TO_COMBAT_SOUND"] = 37,
["TASK_STORE_ENEMY_POSITION_IN_SAVEPOSITION"] = 38,
["TASK_GET_PATH_TO_COMMAND_GOAL"] = 39,
["TASK_MARK_COMMAND_GOAL_POS"] = 40,
["TASK_CLEAR_COMMAND_GOAL"] = 41,
["TASK_GET_PATH_TO_LASTPOSITION"] = 42,
["TASK_GET_PATH_TO_SAVEPOSITION"] = 43,
["TASK_GET_PATH_TO_SAVEPOSITION_LOS"] = 44,
["TASK_GET_PATH_TO_RANDOM_NODE"] = 45,
["TASK_GET_PATH_TO_BESTSOUND"] = 46,
["TASK_GET_PATH_TO_BESTSCENT"] = 47,
["TASK_RUN_PATH"] = 48,
["TASK_WALK_PATH"] = 49,
["TASK_WALK_PATH_TIMED"] = 50,
["TASK_WALK_PATH_WITHIN_DIST"] = 51,
["TASK_WALK_PATH_FOR_UNITS"] = 52,
["TASK_RUN_PATH_FLEE"] = 53,
["TASK_RUN_PATH_TIMED"] = 54,
["TASK_RUN_PATH_FOR_UNITS"] = 55,
["TASK_RUN_PATH_WITHIN_DIST"] = 56,
["TASK_STRAFE_PATH"] = 57,
["TASK_CLEAR_MOVE_WAIT"] = 58,
["TASK_SMALL_FLINCH"] = 59,
["TASK_BIG_FLINCH"] = 60,
["TASK_DEFER_DODGE"] = 61,
["TASK_FACE_IDEAL"] = 62,
["TASK_FACE_REASONABLE"] = 63,
["TASK_FACE_PATH"] = 64,
["TASK_FACE_PLAYER"] = 65,
["TASK_FACE_ENEMY"] = 66,
["TASK_FACE_HINTNODE"] = 67,
["TASK_PLAY_HINT_ACTIVITY"] = 68,
["TASK_FACE_TARGET"] = 69,
["TASK_FACE_LASTPOSITION"] = 70,
["TASK_FACE_SAVEPOSITION"] = 71,
["TASK_FACE_AWAY_FROM_SAVEPOSITION"] = 72,
["TASK_SET_IDEAL_YAW_TO_CURRENT"] = 73,
["TASK_RANGE_ATTACK1"] = 74,
["TASK_RANGE_ATTACK2"] = 75,
["TASK_MELEE_ATTACK1"] = 76,
["TASK_MELEE_ATTACK2"] = 77,
["TASK_RELOAD"] = 78,
["TASK_SPECIAL_ATTACK1"] = 79,
["TASK_SPECIAL_ATTACK2"] = 80,
["TASK_FIND_HINTNODE"] = 81,
["TASK_FIND_LOCK_HINTNODE"] = 82,
["TASK_CLEAR_HINTNODE"] = 83,
["TASK_LOCK_HINTNODE"] = 84,
["TASK_SOUND_ANGRY"] = 85,
["TASK_SOUND_DEATH"] = 86,
["TASK_SOUND_IDLE"] = 87,
["TASK_SOUND_WAKE"] = 88,
["TASK_SOUND_PAIN"] = 89,
["TASK_SOUND_DIE"] = 90,
["TASK_SPEAK_SENTENCE"] = 91,
["TASK_WAIT_FOR_SPEAK_FINISH"] = 92,
["TASK_SET_ACTIVITY"] = 93,
["TASK_RANDOMIZE_FRAMERATE"] = 94,
["TASK_SET_SCHEDULE"] = 95,
["TASK_SET_FAIL_SCHEDULE"] = 96,
["TASK_SET_TOLERANCE_DISTANCE"] = 97,
["TASK_SET_ROUTE_SEARCH_TIME"] = 98,
["TASK_CLEAR_FAIL_SCHEDULE"] = 99,
["TASK_PLAY_SEQUENCE"] = 100,
["TASK_PLAY_PRIVATE_SEQUENCE"] = 101,
["TASK_PLAY_PRIVATE_SEQUENCE_FACE_ENEMY"] = 102,
["TASK_PLAY_SEQUENCE_FACE_ENEMY"] = 103,
["TASK_PLAY_SEQUENCE_FACE_TARGET"] = 104,
["TASK_FIND_COVER_FROM_BEST_SOUND"] = 105,
["TASK_FIND_COVER_FROM_ENEMY"] = 106,
["TASK_FIND_LATERAL_COVER_FROM_ENEMY"] = 107,
["TASK_FIND_BACKAWAY_FROM_SAVEPOSITION"] = 108,
["TASK_FIND_NODE_COVER_FROM_ENEMY"] = 109,
["TASK_FIND_NEAR_NODE_COVER_FROM_ENEMY"] = 110,
["TASK_FIND_FAR_NODE_COVER_FROM_ENEMY"] = 111,
["TASK_FIND_COVER_FROM_ORIGIN"] = 112,
["TASK_DIE"] = 113,
["TASK_WAIT_FOR_SCRIPT"] = 114,
["TASK_PUSH_SCRIPT_ARRIVAL_ACTIVITY"] = 115,
["TASK_PLAY_SCRIPT"] = 116,
["TASK_PLAY_SCRIPT_POST_IDLE"] = 117,
["TASK_ENABLE_SCRIPT"] = 118,
["TASK_PLANT_ON_SCRIPT"] = 119,
["TASK_FACE_SCRIPT"] = 120,
["TASK_PLAY_SCENE"] = 121,
["TASK_WAIT_RANDOM"] = 122,
["TASK_WAIT_INDEFINITE"] = 123,
["TASK_STOP_MOVING"] = 124,
["TASK_TURN_LEFT"] = 125,
["TASK_TURN_RIGHT"] = 126,
["TASK_REMEMBER"] = 127,
["TASK_FORGET"] = 128,
["TASK_WAIT_FOR_MOVEMENT"] = 129,
["TASK_WAIT_FOR_MOVEMENT_STEP"] = 130,
["TASK_WAIT_UNTIL_NO_DANGER_SOUND"] = 131,
["TASK_WEAPON_FIND"] = 132,
["TASK_WEAPON_PICKUP"] = 133,
["TASK_WEAPON_RUN_PATH"] = 134,
["TASK_WEAPON_CREATE"] = 135,
["TASK_ITEM_PICKUP"] = 136,
["TASK_ITEM_RUN_PATH"] = 137,
["TASK_USE_SMALL_HULL"] = 138,
["TASK_FALL_TO_GROUND"] = 139,
["TASK_WANDER"] = 140,
["TASK_FREEZE"] = 141,
["TASK_GATHER_CONDITIONS"] = 142,
["TASK_IGNORE_OLD_ENEMIES"] = 143,
["TASK_DEBUG_BREAK"] = 144,
["TASK_ADD_HEALTH"] = 145,
["TASK_ADD_GESTURE_WAIT"] = 146,
["TASK_ADD_GESTURE"] = 147,
["TASK_GET_PATH_TO_INTERACTION_PARTNER"] = 148,
["TASK_PRE_SCRIPT"] = 149,
}
GetTaskList = function(name) return TaskList[name] or TaskList[0] end
local GetTaskID = GetTaskList
---------------------------------------------------------------------------------------------------------------------------------------------
module("ai_vj_task")
local TYPE_ENGINE = 1
local TYPE_FNAME = 2
local Task = {}
Task.__index = Task
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:Init()
self.Type = nil
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:InitEngine(_taskname_, _taskdata_)
self.TaskName = _taskname_
self.TaskID = nil
self.TaskData = _taskdata_
self.Type = TYPE_ENGINE
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:InitFunctionName(_start, _end, _taskdata_)
self.StartFunctionName = _start
self.FunctionName = _end
self.TaskData = _taskdata_
self.Type = TYPE_FNAME
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:IsEngineType()
return self.Type == TYPE_ENGINE
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:IsFNameType()
return self.Type == TYPE_FNAME
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:Start(npc)
if (self:IsFNameType()) then self:Start_FName(npc) return end
if (self:IsEngineType()) then
if (!self.TaskID) then self.TaskID = GetTaskID(self.TaskName) end
npc:StartEngineTask(self.TaskID,self.TaskData or 0)
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:Start_FName(npc)
if (!self.StartFunctionName) then return end
npc[self.StartFunctionName](npc, self.TaskData)
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:Run(npc)
if (self:IsFNameType()) then self:Run_FName(npc) return end
if (self:IsEngineType()) then
npc:RunEngineTask(self.TaskID, self.TaskData or 0)
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
function Task:Run_FName(npc)
if (!self.FunctionName) then return end
npc[self.FunctionName](npc,self.TaskData)
end
---------------------------------------------------------------------------------------------------------------------------------------------
function New()
local pNewTask = {}
setmetatable(pNewTask, Task)
pNewTask:Init()
return pNewTask
end

68
lua/includes/modules/baseclass.lua Normal file
View File

@@ -0,0 +1,68 @@
--[[
| 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/
--]]
--
-- The baseclass module uses upvalues to give the impression of inheritence.
--
-- At the top of your class file add
--
-- DEFINE_BASECLASS( "base_class_name" )
--
-- Now the local variable BaseClass will be available.
-- ( in engine DEFINE_BASECLASS is replaced with "local BaseClass = baseclass.Get" )
--
-- Baseclasses are added using baseclass.Set - this is done automatically for:
--
-- > widgets
-- > panels
-- > drive modes
-- > entities
-- > weapons
--
-- Classes don't have to be created in any particular order. The system is
-- designed to work with whatever order the classes are defined.
--
-- The only caveat is that classnames must be unique.
-- eg Creating a panel and widget with the same name will cause problems.
--
module( "baseclass", package.seeall )
local BaseClassTable = {}
function Get( name )
if ( ENT ) then ENT.Base = name end
if ( SWEP ) then SWEP.Base = name end
BaseClassTable[name] = BaseClassTable[name] or {}
return BaseClassTable[name]
end
function Set( name, tab )
if ( !BaseClassTable[name] ) then
BaseClassTable[name] = tab
else
table.Merge( BaseClassTable[name], tab )
setmetatable( BaseClassTable[name], getmetatable(tab) )
end
BaseClassTable[name].ThisClass = name
end

251
lua/includes/modules/cleanup.lua Normal file
View File

@@ -0,0 +1,251 @@
--[[
| 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/
--]]
module( "cleanup", package.seeall )
local cleanup_types = {}
local function IsType( type )
for key, val in pairs( cleanup_types ) do
if ( val == type ) then return true end
end
return false
end
function Register( type )
if ( type == "all" ) then return end
for key, val in pairs( cleanup_types ) do
if val == type then return end
end
table.insert( cleanup_types, type )
end
function GetTable()
return cleanup_types
end
if ( SERVER ) then
local cleanup_list = {}
function GetList()
return cleanup_list
end
local function Save( save )
saverestore.WriteTable( cleanup_list, save )
end
local function Restore( restore )
cleanup_list = saverestore.ReadTable( restore )
end
saverestore.AddSaveHook( "CleanupTable", Save )
saverestore.AddRestoreHook( "CleanupTable", Restore )
function Add( pl, type, ent )
if ( !ent ) then return end
if ( !IsType( type ) ) then return end
local id = pl:UniqueID()
cleanup_list[ id ] = cleanup_list[ id ] or {}
cleanup_list[ id ][ type ] = cleanup_list[ id ][ type ] or {}
if ( !IsValid( ent ) ) then return end
table.insert( cleanup_list[ id ][ type ], ent )
end
function ReplaceEntity( from, to )
local ActionTaken = false
for _, PlayerTable in pairs( cleanup_list ) do
for _, TypeTable in pairs( PlayerTable ) do
for key, ent in pairs( TypeTable ) do
if ( ent == from ) then
TypeTable[ key ] = to
ActionTaken = true
end
end
end
end
return ActionTaken
end
function CC_Cleanup( pl, command, args )
if ( !IsValid( pl ) ) then return end
local id = pl:UniqueID()
if ( !cleanup_list[ id ] ) then return end
if ( !args[ 1 ] ) then
local count = 0
for key, val in pairs( cleanup_list[ id ] ) do
for _, ent in pairs( val ) do
if ( IsValid( ent ) ) then ent:Remove() end
count = count + 1
end
table.Empty( val )
end
-- Send tooltip command to client
if ( count > 0 ) then
pl:SendLua( "hook.Run('OnCleanup','all')" )
end
return
end
if ( !IsType( args[1] ) ) then return end
if ( !cleanup_list[id][ args[1] ] ) then return end
for key, ent in pairs( cleanup_list[id][ args[1] ] ) do
if ( IsValid( ent ) ) then ent:Remove() end
end
table.Empty( cleanup_list[id][ args[1] ] )
-- Send tooltip command to client
pl:SendLua( string.format( "hook.Run('OnCleanup',%q)", args[1] ) )
end
function CC_AdminCleanup( pl, command, args )
if ( IsValid( pl ) && !pl:IsAdmin() ) then return end
if ( !args[ 1 ] ) then
for key, ply in pairs( cleanup_list ) do
for _, type in pairs( ply ) do
for __, ent in pairs( type ) do
if ( IsValid( ent ) ) then ent:Remove() end
end
table.Empty( type )
end
end
game.CleanUpMap( false, nil, function()
-- Send tooltip command to client
if ( IsValid( pl ) ) then pl:SendLua( "hook.Run('OnCleanup','all')" ) end
end )
return
end
if ( !IsType( args[ 1 ] ) ) then return end
for key, ply in pairs( cleanup_list ) do
if ( ply[ args[ 1 ] ] != nil ) then
for id, ent in pairs( ply[ args[ 1 ] ] ) do
if ( IsValid( ent ) ) then ent:Remove() end
end
table.Empty( ply[ args[ 1 ] ] )
end
end
-- Send tooltip command to client
if ( IsValid( pl ) ) then pl:SendLua( string.format( "hook.Run('OnCleanup',%q)", args[1] ) ) end
end
concommand.Add( "gmod_cleanup", CC_Cleanup, nil, "", { FCVAR_DONTRECORD } )
concommand.Add( "gmod_admin_cleanup", CC_AdminCleanup, nil, "", { FCVAR_DONTRECORD } )
else
function UpdateUI()
local cleanup_types_s = {}
for id, val in pairs( cleanup_types ) do
cleanup_types_s[ language.GetPhrase( "Cleanup_" .. val ) ] = val
end
local Panel = controlpanel.Get( "User_Cleanup" )
if ( IsValid( Panel ) ) then
Panel:Clear()
Panel:AddControl( "Header", { Description = "#spawnmenu.utilities.cleanup.help" } )
Panel:Button( "#CleanupAll", "gmod_cleanup" )
for key, val in SortedPairs( cleanup_types_s ) do
Panel:Button( key, "gmod_cleanup", val )
end
end
local AdminPanel = controlpanel.Get( "Admin_Cleanup" )
if ( IsValid( AdminPanel ) ) then
AdminPanel:Clear()
AdminPanel:AddControl( "Header", { Description = "#spawnmenu.utilities.cleanup.help" } )
AdminPanel:Button( "#CleanupAll", "gmod_admin_cleanup" )
for key, val in SortedPairs( cleanup_types_s ) do
AdminPanel:Button( key, "gmod_admin_cleanup", val )
end
end
end
hook.Add( "PostReloadToolsMenu", "BuildCleanupUI", UpdateUI )
end

85
lua/includes/modules/concommand.lua Normal file
View File

@@ -0,0 +1,85 @@
--[[
| 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/
--]]
local AddConsoleCommand = AddConsoleCommand
local string = string
local Msg = Msg
--[[---------------------------------------------------------
Name: concommand
Desc: A module to take care of the registration and calling
of Lua console commands.
-----------------------------------------------------------]]
module( "concommand" )
local CommandList = {}
local CompleteList = {}
--[[---------------------------------------------------------
Name: concommand.GetTable( )
Desc: Returns the table of console commands and auto complete
-----------------------------------------------------------]]
function GetTable()
return CommandList, CompleteList
end
--[[---------------------------------------------------------
Name: concommand.Add( name, func, completefunc )
Desc: Register a new console command
-----------------------------------------------------------]]
function Add( name, func, completefunc, help, flags )
local LowerName = string.lower( name )
CommandList[ LowerName ] = func
CompleteList[ LowerName ] = completefunc
AddConsoleCommand( name, help, flags )
end
--[[---------------------------------------------------------
Name: concommand.Remove( name )
Desc: Removes a console command
-----------------------------------------------------------]]
function Remove( name )
local LowerName = string.lower( name )
CommandList[ LowerName ] = nil
CompleteList[ LowerName ] = nil
end
--[[---------------------------------------------------------
Name: concommand.Run( )
Desc: Called by the engine when an unknown console command is run
-----------------------------------------------------------]]
function Run( player, command, arguments, argumentsStr )
local LowerCommand = string.lower( command )
if ( CommandList[ LowerCommand ] != nil ) then
CommandList[ LowerCommand ]( player, command, arguments, argumentsStr )
return true
end
Msg( "Unknown command: " .. command .. "\n" )
return false
end
--[[---------------------------------------------------------
Name: concommand.AutoComplete( )
Desc: Returns a table for the autocompletion
-----------------------------------------------------------]]
function AutoComplete( command, argumentsStr, arguments )
local LowerCommand = string.lower( command )
if ( CompleteList[ LowerCommand ] != nil ) then
return CompleteList[ LowerCommand ]( command, argumentsStr, arguments )
end
end

1678
lua/includes/modules/constraint.lua Normal file
View File

File diff suppressed because it is too large Load Diff

163
lua/includes/modules/construct.lua Normal file
View File

@@ -0,0 +1,163 @@
--[[
| 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/
--]]
local ents = ents
local SERVER = SERVER
local duplicator = duplicator
local numpad = numpad
local Msg = Msg
local IsValid = IsValid
module( "construct" )
if SERVER then
function SetPhysProp( Player, Entity, BoneID, Bone, Data )
if ( !IsValid( Bone ) ) then
Bone = Entity:GetPhysicsObjectNum( BoneID )
if ( !IsValid( Bone ) ) then
Msg( "SetPhysProp: Error applying attributes to invalid physics object!\n" )
return
end
end
if ( Data.GravityToggle != nil ) then Bone:EnableGravity( Data.GravityToggle ) end
if ( Data.Material != nil ) then Bone:SetMaterial( Data.Material ) end
-- todo: Rename/Implement
--[[
if ( Data.motionb != nil ) then Bone:EnableMotion( Data.motionb ) end
if ( Data.mass != nil ) then Bone:SetMass( Data.mass ) end
if ( Data.dragb != nil ) then Bone:EnableDrag( Data.dragb ) end
if ( Data.drag != nil ) then Bone:SetDragCoefficient( Data.drag ) end
if ( Data.buoyancy != nil ) then Bone:SetBuoyancyRatio( Data.buoyancy ) end
if ( Data.rotdamping != nil ) then Bone:SetDamping( PhysBone:GetSpeedDamping(), Data.rotdamping ) end
if ( Data.speeddamping != nil ) then Bone:SetDamping( Data.speeddamping, PhysBone:GetRotDamping() ) end
--]]
-- HACK HACK
-- If we don't do this the prop will be motion enabled and will
-- slide through the world with no gravity.
if ( !Bone:IsMoveable() ) then
Bone:EnableMotion( true )
Bone:EnableMotion( false )
end
duplicator.StoreBoneModifier( Entity, BoneID, "physprops", Data )
end
duplicator.RegisterBoneModifier( "physprops", SetPhysProp )
local function MagnetOff( pl, magnet )
if ( !IsValid( magnet ) ) then return false end
if ( magnet:GetTable().toggle != 0 ) then return true end
magnet:Fire( "TurnOff", "" , 0 )
return true
end
local function MagnetOn( pl, magnet )
if ( !IsValid( magnet ) ) then return false end
if ( magnet:GetTable().toggle != 0 ) then
magnet:GetTable().toggle_state = !magnet:GetTable().toggle_state
if ( magnet:GetTable().toggle_state ) then
magnet:Fire( "TurnOn", "" , 0 )
else
magnet:Fire( "TurnOff", "" , 0 )
end
return true
end
magnet:Fire( "TurnOn", "" , 0 )
return true
end
numpad.Register( "MagnetOff", MagnetOff )
numpad.Register( "MagnetOn", MagnetOn )
function Magnet( pl, pos, angle, model, material, key, maxobjects, strength, nopull, allowrot, alwayson, toggle, Vel, aVel, frozen )
local magnet = ents.Create( "phys_magnet" )
magnet:SetPos( pos )
magnet:SetAngles( angle )
magnet:SetModel( model )
if ( material ) then magnet:SetMaterial( material ) end
local spawnflags = 4
if ( nopull && nopull > 0 ) then spawnflags = spawnflags - 4 end -- no pull required: remove the suck flag
if ( allowrot && allowrot > 0 ) then spawnflags = spawnflags + 8 end
if ( maxobjects ) then magnet:SetKeyValue( "maxobjects", maxobjects ) end
if ( strength ) then magnet:SetKeyValue( "forcelimit", strength ) end
magnet:SetKeyValue( "overridescript", "surfaceprop,metal")
magnet:SetKeyValue( "massScale", 0 )
magnet:Activate()
magnet:Spawn()
if ( IsValid( magnet:GetPhysicsObject() ) ) then
local Phys = magnet:GetPhysicsObject()
if ( Vel ) then Phys:SetVelocity( Vel ) end
if ( aVel ) then Phys:AddAngleVelocity( aVel ) end
Phys:EnableMotion( frozen != true )
end
if ( alwayson && alwayson > 0 ) then
magnet:Input( "TurnOn", nil, nil, nil )
else
magnet:Input( "TurnOff", nil, nil, nil )
end
local mtable = {
Model = model,
material = material,
key = key,
maxobjects = maxobjects,
strength = strength,
nopull = nopull,
allowrot = allowrot,
alwayson = alwayson,
toggle = toggle
}
magnet:SetTable( mtable )
if ( key ) then
numpad.OnDown( pl, key, "MagnetOn", magnet )
numpad.OnUp( pl, key, "MagnetOff", magnet )
end
return magnet
end
duplicator.RegisterEntityClass( "phys_magnet", Magnet, "Pos", "Ang", "Model", "material", "key", "maxobjects", "strength", "nopull", "allowrot", "alwayson", "toggle", "Vel", "aVel", "frozen" )
end

57
lua/includes/modules/controlpanel.lua Normal file
View File

@@ -0,0 +1,57 @@
--[[
| 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/
--]]
local ControlPanels = {}
module( "controlpanel", package.seeall )
-- A hack for a very annoying race condition where spawnmenu_reload deletes the controlpanels on the next frame
-- But some panels are updated "this" frame after spawnmenu reloaded
local function ShouldReCreate( pnl )
if ( !IsValid( pnl ) || pnl:IsMarkedForDeletion() ) then return true end
local p = pnl
-- Can't use IsValid because it's false for marked for deletion panels
while ( IsValid( p ) && p:GetParent() != nil ) do
if ( p:GetParent():IsMarkedForDeletion() ) then return true end
p = p:GetParent()
end
return false
end
function Get( name )
if ( ShouldReCreate( ControlPanels[ name ] ) ) then
local cp = vgui.Create( "ControlPanel" )
if ( !cp ) then
debug.Trace()
Error( "controlpanel.Get() - Error creating a ControlPanel!\nYou're calling this function too early! Call it in a hook!\n" )
return nil
end
cp:SetVisible( false )
cp.Name = name
ControlPanels[ name ] = cp
end
return ControlPanels[ name ]
end
function Clear()
ControlPanels = {}
end

143
lua/includes/modules/cookie.lua Normal file
View File

@@ -0,0 +1,143 @@
--[[
| 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/
--]]
if ( !sql.TableExists( "cookies" ) ) then
sql.Query( "CREATE TABLE IF NOT EXISTS cookies ( key TEXT NOT NULL PRIMARY KEY, value TEXT );" )
end
module( "cookie", package.seeall )
local CachedEntries = {}
local BufferedWrites = {}
local BufferedDeletes = {}
local function GetCache( key )
if ( BufferedDeletes[ key ] ) then return nil end
local entry = CachedEntries[ key ]
if ( entry == nil || SysTime() > entry[ 1 ] ) then
local name = SQLStr( key )
local val = sql.QueryValue( "SELECT value FROM cookies WHERE key = " .. name )
if !val then
return false
end
CachedEntries[ key ] = { SysTime() + 30, val }
end
return CachedEntries[ key ][ 2 ]
end
local function FlushCache()
CachedEntries = {}
BufferedWrites = {}
BufferedDeletes = {}
end
local function CommitToSQLite()
sql.Begin()
for k, v in pairs( BufferedWrites ) do
sql.Query( "INSERT OR REPLACE INTO cookies ( key, value ) VALUES ( " .. SQLStr( k ) .. ", " .. SQLStr( v ) .. " )" )
end
for k, v in pairs( BufferedDeletes ) do
sql.Query( "DELETE FROM cookies WHERE key = " .. SQLStr( k ) )
end
BufferedWrites = {}
BufferedDeletes = {}
sql.Commit()
end
local function ScheduleCommit()
timer.Create( "Cookie_CommitToSQLite", 0.1, 1, CommitToSQLite )
end
local function SetCache( key, value )
if ( value == nil ) then return Delete( key ) end
if CachedEntries[ key ] then
CachedEntries[ key ][ 1 ] = SysTime() + 30
CachedEntries[ key ][ 2 ] = value
else
CachedEntries[ key ] = { SysTime() + 30, value }
end
BufferedWrites[ key ] = value
ScheduleCommit()
end
-- Get a String Value
function GetString( name, default )
local val = GetCache( name )
if ( !val ) then return default end
return val
end
-- Get a Number Value
function GetNumber( name, default )
local val = GetCache( name )
if ( !val ) then return default end
return tonumber( val )
end
-- Delete a Value
function Delete( name )
CachedEntries[ name ] = nil
BufferedWrites[ name ] = nil
BufferedDeletes[ name ] = true
ScheduleCommit()
end
-- Set a Value
function Set( name, value )
SetCache( name, value )
end
hook.Add( "ShutDown", "SaveCookiesOnShutdown", CommitToSQLite )
if ( !CLIENT_DLL ) then return end
concommand.Add( "lua_cookieclear", function( ply, command, arguments )
sql.Query( "DELETE FROM cookies" )
FlushCache()
end )

157
lua/includes/modules/cvars.lua Normal file
View File

@@ -0,0 +1,157 @@
--[[
| 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/
--]]
local table = table
local type = type
local istable = istable
local isstring = isstring
local assert = assert
local format = string.format
local GetConVar = GetConVar
--[[---------------------------------------------------------
Name: cvar
Desc: Callbacks when cvars change
-----------------------------------------------------------]]
module( "cvars" )
local ConVars = {}
--[[---------------------------------------------------------
Name: GetConVarCallbacks
Desc: Returns a table of the given ConVars callbacks
-----------------------------------------------------------]]
function GetConVarCallbacks( name, createIfNotFound )
local tab = ConVars[ name ]
if ( createIfNotFound and !tab ) then
tab = {}
ConVars[ name ] = tab
end
return tab
end
--[[---------------------------------------------------------
Name: OnConVarChanged
Desc: Called by the engine
-----------------------------------------------------------]]
function OnConVarChanged( name, old, new )
local tab = GetConVarCallbacks( name )
if ( !tab ) then return end
for i = 1, #tab do
local callback = tab[ i ]
if ( istable( callback ) ) then
callback[ 1 ]( name, old, new )
else
callback( name, old, new )
end
end
end
--[[---------------------------------------------------------
Name: AddChangeCallback
Desc: Adds a callback to be called when convar changes
-----------------------------------------------------------]]
function AddChangeCallback( name, func, identifier )
if ( identifier ) then
assert( isstring( identifier ), format( "bad argument #%i (string expected, got %s)", 3, type( identifier ) ) )
end
local tab = GetConVarCallbacks( name, true )
if ( !identifier ) then
table.insert( tab, func )
return
end
for i = 1, #tab do
local callback = tab[ i ]
if ( istable( callback ) and callback[ 2 ] == identifier ) then
callback[ 1 ] = func
return
end
end
table.insert( tab, { func, identifier } )
end
--[[---------------------------------------------------------
Name: RemoveChangeCallback
Desc: Removes callback with identifier
-----------------------------------------------------------]]
function RemoveChangeCallback( name, identifier )
if ( identifier ) then
assert( isstring( identifier ), format( "bad argument #%i (string expected, got %s)", 2, type( identifier ) ) )
end
local tab = GetConVarCallbacks( name, true )
for i = 1, #tab do
local callback = tab[ i ]
if ( istable( callback ) and callback[ 2 ] == identifier ) then
table.remove( tab, i )
break
end
end
end
--[[---------------------------------------------------------
Name: String
Desc: Retrieves console variable as a string
-----------------------------------------------------------]]
function String( name, default )
local convar = GetConVar( name )
if ( convar ~= nil ) then
return convar:GetString()
end
return default
end
--[[---------------------------------------------------------
Name: Number
Desc: Retrieves console variable as a number
-----------------------------------------------------------]]
function Number( name, default )
local convar = GetConVar( name )
if ( convar ~= nil ) then
return convar:GetFloat()
end
return default
end
--[[---------------------------------------------------------
Name: Bool
Desc: Retrieves console variable as a boolean
-----------------------------------------------------------]]
function Bool( name, default )
local convar = GetConVar( name )
if ( convar ~= nil ) then
return convar:GetBool()
end
return default
end

324
lua/includes/modules/draw.lua Normal file
View File

@@ -0,0 +1,324 @@
--[[
| 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/
--]]
local string = string
local surface = surface
local math = math
local Color = Color
local tostring = tostring
local color_white = color_white
module( "draw" )
--[[---------------------------------------------------------
Constants used for text alignment.
These must be the same values as in the markup module.
-----------------------------------------------------------]]
TEXT_ALIGN_LEFT = 0
TEXT_ALIGN_CENTER = 1
TEXT_ALIGN_RIGHT = 2
TEXT_ALIGN_TOP = 3
TEXT_ALIGN_BOTTOM = 4
--[[---------------------------------------------------------
Textures we use to get shit done
-----------------------------------------------------------]]
local tex_corner8 = surface.GetTextureID( "gui/corner8" )
local tex_corner16 = surface.GetTextureID( "gui/corner16" )
local tex_corner32 = surface.GetTextureID( "gui/corner32" )
local tex_corner64 = surface.GetTextureID( "gui/corner64" )
local tex_corner512 = surface.GetTextureID( "gui/corner512" )
local tex_white = surface.GetTextureID( "vgui/white" )
local CachedFontHeights = {}
--[[---------------------------------------------------------
Name: GetFontHeight( font )
Desc: Returns the height of a single line
-----------------------------------------------------------]]
function GetFontHeight( font )
if ( CachedFontHeights[ font ] != nil ) then
return CachedFontHeights[ font ]
end
surface.SetFont( font )
local w, h = surface.GetTextSize( "W" )
CachedFontHeights[ font ] = h
return h
end
--[[---------------------------------------------------------
Name: SimpleText(text, font, x, y, colour)
Desc: Simple "draw text at position function"
color is a table with r/g/b/a elements
-----------------------------------------------------------]]
function SimpleText( text, font, x, y, colour, xalign, yalign )
text = tostring( text )
font = font or "DermaDefault"
x = x or 0
y = y or 0
xalign = xalign or TEXT_ALIGN_LEFT
yalign = yalign or TEXT_ALIGN_TOP
surface.SetFont( font )
local w, h = surface.GetTextSize( text )
if ( xalign == TEXT_ALIGN_CENTER ) then
x = x - w / 2
elseif ( xalign == TEXT_ALIGN_RIGHT ) then
x = x - w
end
if ( yalign == TEXT_ALIGN_CENTER ) then
y = y - h / 2
elseif ( yalign == TEXT_ALIGN_BOTTOM ) then
y = y - h
end
surface.SetTextPos( math.ceil( x ), math.ceil( y ) )
if ( colour != nil ) then
surface.SetTextColor( colour.r, colour.g, colour.b, colour.a )
else
surface.SetTextColor( 255, 255, 255, 255 )
end
surface.DrawText( text )
return w, h
end
--[[---------------------------------------------------------
Name: SimpleTextOutlined( text, font, x, y, colour, xalign, yalign, outlinewidth, outlinecolour )
Desc: Simple draw text at position, but this will expand newlines and tabs.
color is a table with r/g/b/a elements
-----------------------------------------------------------]]
function SimpleTextOutlined(text, font, x, y, colour, xalign, yalign, outlinewidth, outlinecolour)
local steps = ( outlinewidth * 2 ) / 3
if ( steps < 1 ) then steps = 1 end
for _x = -outlinewidth, outlinewidth, steps do
for _y = -outlinewidth, outlinewidth, steps do
SimpleText( text, font, x + _x, y + _y, outlinecolour, xalign, yalign )
end
end
return SimpleText( text, font, x, y, colour, xalign, yalign )
end
--[[---------------------------------------------------------
Name: DrawText(text, font, x, y, colour, align )
Desc: Simple draw text at position, but this will expand newlines and tabs.
color is a table with r/g/b/a elements
-----------------------------------------------------------]]
local gmatch = string.gmatch
local find = string.find
local ceil = math.ceil
local GetTextSize = surface.GetTextSize
local max = math.max
function DrawText( text, font, x, y, colour, xalign )
if ( font == nil ) then font = "DermaDefault" end
if ( text != nil ) then text = tostring( text ) end
if ( x == nil ) then x = 0 end
if ( y == nil ) then y = 0 end
local curX = x
local curY = y
local curString = ""
surface.SetFont( font )
local sizeX, lineHeight = GetTextSize( "\n" )
local tabWidth = 50
for str in gmatch( text, "[^\n]*" ) do
if #str > 0 then
if find( str, "\t" ) then -- there's tabs, some more calculations required
for tabs, str2 in gmatch( str, "(\t*)([^\t]*)" ) do
curX = ceil( ( curX + tabWidth * max( #tabs - 1, 0 ) ) / tabWidth ) * tabWidth
if #str2 > 0 then
SimpleText( str2, font, curX, curY, colour, xalign )
local w, _ = GetTextSize( str2 )
curX = curX + w
end
end
else -- there's no tabs, this is easy
SimpleText( str, font, curX, curY, colour, xalign )
end
else
curX = x
curY = curY + ( lineHeight / 2 )
end
end
end
--[[---------------------------------------------------------
Name: RoundedBox( bordersize, x, y, w, h, color )
Desc: Draws a rounded box - ideally bordersize will be 8 or 16
Usage: color is a table with r/g/b/a elements
-----------------------------------------------------------]]
function RoundedBox( bordersize, x, y, w, h, color )
return RoundedBoxEx( bordersize, x, y, w, h, color, true, true, true, true )
end
--[[---------------------------------------------------------
Name: RoundedBox( bordersize, x, y, w, h, color )
Desc: Draws a rounded box - ideally bordersize will be 8 or 16
Usage: color is a table with r/g/b/a elements
-----------------------------------------------------------]]
function RoundedBoxEx( bordersize, x, y, w, h, color, tl, tr, bl, br )
surface.SetDrawColor( color.r, color.g, color.b, color.a )
-- Do not waste performance if they don't want rounded corners
if ( bordersize <= 0 ) then
surface.DrawRect( x, y, w, h )
return
end
x = math.Round( x )
y = math.Round( y )
w = math.Round( w )
h = math.Round( h )
bordersize = math.min( math.Round( bordersize ), math.floor( w / 2 ), math.floor( h / 2 ) )
-- Draw as much of the rect as we can without textures
surface.DrawRect( x + bordersize, y, w - bordersize * 2, h )
surface.DrawRect( x, y + bordersize, bordersize, h - bordersize * 2 )
surface.DrawRect( x + w - bordersize, y + bordersize, bordersize, h - bordersize * 2 )
local tex = tex_corner8
if ( bordersize > 8 ) then tex = tex_corner16 end
if ( bordersize > 16 ) then tex = tex_corner32 end
if ( bordersize > 32 ) then tex = tex_corner64 end
if ( bordersize > 64 ) then tex = tex_corner512 end
surface.SetTexture( tex )
if ( tl ) then
surface.DrawTexturedRectUV( x, y, bordersize, bordersize, 0, 0, 1, 1 )
else
surface.DrawRect( x, y, bordersize, bordersize )
end
if ( tr ) then
surface.DrawTexturedRectUV( x + w - bordersize, y, bordersize, bordersize, 1, 0, 0, 1 )
else
surface.DrawRect( x + w - bordersize, y, bordersize, bordersize )
end
if ( bl ) then
surface.DrawTexturedRectUV( x, y + h -bordersize, bordersize, bordersize, 0, 1, 1, 0 )
else
surface.DrawRect( x, y + h - bordersize, bordersize, bordersize )
end
if ( br ) then
surface.DrawTexturedRectUV( x + w - bordersize, y + h - bordersize, bordersize, bordersize, 1, 1, 0, 0 )
else
surface.DrawRect( x + w - bordersize, y + h - bordersize, bordersize, bordersize )
end
end
--[[---------------------------------------------------------
Name: WordBox( bordersize, x, y, font, color, font, color, fontcolor, xalign, yalign )
Desc: Draws a rounded box - ideally bordersize will be 8 or 16
Usage: color is a table with r/g/b/a elements
-----------------------------------------------------------]]
function WordBox( bordersize, x, y, text, font, color, fontcolor, xalign, yalign )
surface.SetFont( font )
local w, h = surface.GetTextSize( text )
if ( xalign == TEXT_ALIGN_CENTER ) then
x = x - ( bordersize + w / 2 )
elseif ( xalign == TEXT_ALIGN_RIGHT ) then
x = x - ( bordersize * 2 + w )
end
if ( yalign == TEXT_ALIGN_CENTER ) then
y = y - ( bordersize + h / 2 )
elseif ( yalign == TEXT_ALIGN_BOTTOM ) then
y = y - ( bordersize * 2 + h )
end
RoundedBox( bordersize, x, y, w+bordersize * 2, h+bordersize * 2, color )
surface.SetTextColor( fontcolor.r, fontcolor.g, fontcolor.b, fontcolor.a )
surface.SetTextPos( x + bordersize, y + bordersize )
surface.DrawText( text )
return w + bordersize * 2, h + bordersize * 2
end
--[[---------------------------------------------------------
Name: Text( table )
Desc: Draws text from a table
-----------------------------------------------------------]]
function Text( tab )
return SimpleText( tab.text, tab.font, tab.pos[ 1 ], tab.pos[ 2 ], tab.color, tab.xalign, tab.yalign )
end
--[[---------------------------------------------------------
Name: TextShadow( table )
Desc: Draws text from a table
-----------------------------------------------------------]]
function TextShadow( tab, distance, alpha )
alpha = alpha or 200
local color = tab.color
local pos = tab.pos
tab.color = Color( 0, 0, 0, alpha )
tab.pos = { pos[ 1 ] + distance, pos[ 2 ] + distance }
Text( tab )
tab.color = color
tab.pos = pos
return Text( tab )
end
--[[---------------------------------------------------------
Name: TexturedQuad( table )
Desc: pawrapper
-----------------------------------------------------------]]
function TexturedQuad( tab )
local color = tab.color or color_white
surface.SetTexture( tab.texture )
surface.SetDrawColor( color.r, color.g, color.b, color.a )
surface.DrawTexturedRect( tab.x, tab.y, tab.w, tab.h )
end
function NoTexture()
surface.SetTexture( tex_white )
end

251
lua/includes/modules/drive.lua Normal file
View File

@@ -0,0 +1,251 @@
--[[
| 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/
--]]
local IsValid = IsValid
local setmetatable = setmetatable
local SERVER = SERVER
local util = util
local ErrorNoHalt = ErrorNoHalt
local baseclass = baseclass
local LocalPlayer = LocalPlayer
module( "drive" )
local Type = {}
function Register( name, table, base )
Type[ name ] = table
--
-- If we have a base method then hook
-- it up in the meta table
--
if ( base ) then
Type[ base ] = Type[ base ] or baseclass.Get( base )
setmetatable( Type[ name ], { __index = Type[ base ] } )
end
if ( SERVER ) then
util.AddNetworkString( name )
end
--
-- drive methods cooperate with the baseclass system
-- /lua/includes/modules/baseclass.lua
--
baseclass.Set( name, Type[ name ] )
end
function PlayerStartDriving( ply, ent, mode )
local method = Type[mode]
if ( !method ) then ErrorNoHalt( "Unknown drive type " .. ( mode ) .. "!\n" ) return end
local id = util.NetworkStringToID( mode )
ply:SetDrivingEntity( ent, id )
end
function PlayerStopDriving( ply )
ply:SetDrivingEntity( nil )
end
function GetMethod( ply )
--
-- Not driving, return immediately
--
if ( !ply:IsDrivingEntity() ) then return end
local ent = ply:GetDrivingEntity()
local modeid = ply:GetDrivingMode()
--
-- Entity is invalid or mode isn't set - return out
--
if ( !IsValid( ent ) || modeid == 0 ) then return end
--
-- Have we already got a drive method? If so then reuse.
--
local method = ply.m_CurrentDriverMethod
if ( method && method.Entity == ent && method.ModeID == modeid ) then return method end
--
-- No method - lets create one. Get the string from the modeid.
--
local modename = util.NetworkIDToString( modeid )
if ( !modename ) then return end
--
-- Get that type. Fail if we don't have the type.
--
local type = Type[ modename ]
if ( !type ) then return end
local method = {}
method.Entity = ent
method.Player = ply
method.ModeID = modeid
setmetatable( method, { __index = type } )
ply.m_CurrentDriverMethod = method
method:Init()
return method
end
function DestroyMethod( pl )
if ( !IsValid( pl ) ) then return end
pl.m_CurrentDriverMethod = nil
end
--
-- Called when the player first
-- starts driving this entity
--
function Start( ply, ent )
if ( SERVER ) then
-- Set this to the ent's view entity
ply:SetViewEntity( ent )
-- Save the player's eye angles
ply.m_PreDriveEyeAngles = ply:EyeAngles()
ply.m_PreDriveObserveMode = ply:GetObserverMode()
-- Lock the player's eye angles to our angles
local ang = ent:GetAngles()
ply:SetEyeAngles( ang )
-- Hide the controlling player's world model
ply:DrawWorldModel( false )
end
end
--
-- Clientside, the client creates the cmd (usercommand)
-- from their input device (mouse, keyboard) and then
-- it's sent to the server. Restrict view angles here :)
--
function CreateMove( cmd )
local method = GetMethod( LocalPlayer() )
if ( !method ) then return end
method:SetupControls( cmd )
return true
end
--
-- Optionally alter the view
--
function CalcView( ply, view )
local method = GetMethod( ply )
if ( !method ) then return end
method:CalcView( view )
return true
end
--
-- The user command is received by the server and then
-- converted into a move. This is also run clientside
-- when in multiplayer, for prediction to work.
--
function StartMove( ply, mv, cmd )
local method = GetMethod( ply )
if ( !method ) then return end
method:StartMove( mv, cmd )
return true
end
--
-- The move is executed here.
--
function Move( ply, mv )
local method = GetMethod( ply )
if ( !method ) then return end
method:Move( mv )
return true
end
--
-- The move is finished. Copy mv back into the target.
--
function FinishMove( ply, mv )
local method = GetMethod( ply )
if ( !method ) then return end
method:FinishMove( mv )
if ( method.StopDriving ) then
PlayerStopDriving( ply )
end
return true
end
--
-- Player has stopped driving the entity
--
function End( ply, ent )
--
-- If the player is valid then set the view entity to nil
--
if ( SERVER && IsValid( ply ) ) then
if ( ply.m_PreDriveEyeAngles != nil ) then
ply:SetEyeAngles( ply.m_PreDriveEyeAngles )
ply.m_PreDriveEyeAngles = nil
end
if ( ply.m_PreDriveObserveMode != nil ) then
ply:SetObserverMode( ply.m_PreDriveObserveMode )
ply.m_PreDriveObserveMode = nil
end
ply:SetViewEntity( nil )
-- Show the controlling player's world model
ply:DrawWorldModel( true )
end
DestroyMethod( ply )
end

1034
lua/includes/modules/duplicator.lua Normal file
View File

File diff suppressed because it is too large Load Diff

87
lua/includes/modules/effects.lua Normal file
View File

@@ -0,0 +1,87 @@
--[[
| 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/
--]]
local ents = ents
local pairs = pairs
local ipairs = ipairs
local string = string
local table = table
--[[---------------------------------------------------------
Name: effects
Desc: Engine effects hooking
-----------------------------------------------------------]]
module( "effects" )
local EffectList = {}
function Register( t, name )
name = string.lower( name )
local old = EffectList[ name ]
EffectList[ name ] = t
--
-- If we're reloading this entity class
-- then refresh all the existing entities.
--
if ( old != nil ) then
--
-- For each entity using this class
--
for _, entity in ipairs( ents.FindByClass( name ) ) do
--
-- Replace the contents with this entity table
--
table.Merge( entity, t )
end
end
end
function Create( name, retval )
name = string.lower( name )
--Msg( "Create.. ".. name .. "\n" )
if ( EffectList[ name ] == nil ) then return nil end
local NewEffect = retval or {}
for k, v in pairs( EffectList[ name ] ) do
NewEffect[ k ] = v
end
table.Merge( NewEffect, EffectList[ "base" ] )
return NewEffect
end
function GetList()
local result = {}
for k, v in pairs( EffectList ) do
table.insert( result, v )
end
return result
end

93
lua/includes/modules/gamemode.lua Normal file
View File

@@ -0,0 +1,93 @@
--[[
| 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/
--]]
local gmod = gmod
local Msg = Msg
local hook = hook
local table = table
local baseclass = baseclass
--[[---------------------------------------------------------
Name: gamemode
Desc: A module to manage gamemodes
-----------------------------------------------------------]]
module( "gamemode" )
local GameList = {}
--[[---------------------------------------------------------
Name: RegisterGamemode( table, string )
Desc: Used to register your gamemode with the engine
-----------------------------------------------------------]]
function Register( t, name, derived )
local CurrentGM = gmod.GetGamemode()
if ( CurrentGM ) then
if ( CurrentGM.FolderName == name ) then
table.Merge( CurrentGM, t )
Call( "OnReloaded" );
end
if ( CurrentGM.BaseClass && CurrentGM.BaseClass.FolderName == name ) then
table.Merge( CurrentGM.BaseClass, t )
Call( "OnReloaded" );
end
end
-- This gives the illusion of inheritence
if ( name != "base" ) then
local basetable = Get( derived )
if ( basetable ) then
t = table.Inherit( t, basetable )
else
Msg( "Warning: Couldn't find derived gamemode (", derived, ")\n" )
end
end
GameList[ name ] = t
--
-- Using baseclass for gamemodes kind of sucks, because
-- the base gamemode is called "base" - and they have to all be unique.
-- so here we prefix the gamemode name with "gamemode_" - and when using
-- DEFINE_BASECLASS you're expected to do the same.
--
baseclass.Set( "gamemode_" .. name, t )
end
--[[---------------------------------------------------------
Name: Get( string )
Desc: Get a gamemode by name.
-----------------------------------------------------------]]
function Get( name )
return GameList[ name ]
end
--[[---------------------------------------------------------
Name: Call( name, args )
Desc: Calls a gamemode function
-----------------------------------------------------------]]
function Call( name, ... )
local CurrentGM = gmod.GetGamemode()
-- If the gamemode function doesn't exist just return false
if ( CurrentGM && CurrentGM[name] == nil ) then return false end
return hook.Call( name, CurrentGM, ... )
end

169
lua/includes/modules/halo.lua Normal file
View File

@@ -0,0 +1,169 @@
--[[
| 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/
--]]
module( "halo", package.seeall )
local mat_Copy = Material( "pp/copy" )
local mat_Add = Material( "pp/add" )
local mat_Sub = Material( "pp/sub" )
local rt_Store = render.GetScreenEffectTexture( 0 )
local rt_Blur = render.GetScreenEffectTexture( 1 )
local List = {}
local RenderEnt = NULL
function Add( entities, color, blurx, blury, passes, add, ignorez )
if ( table.IsEmpty( entities ) ) then return end
if ( add == nil ) then add = true end
if ( ignorez == nil ) then ignorez = false end
local t =
{
Ents = entities,
Color = color,
BlurX = blurx or 2,
BlurY = blury or 2,
DrawPasses = passes or 1,
Additive = add,
IgnoreZ = ignorez
}
table.insert( List, t )
end
function RenderedEntity()
return RenderEnt
end
function Render( entry )
local rt_Scene = render.GetRenderTarget()
-- Store a copy of the original scene
render.CopyRenderTargetToTexture( rt_Store )
-- Clear our scene so that additive/subtractive rendering with it will work later
if ( entry.Additive ) then
render.Clear( 0, 0, 0, 255, false, true )
else
render.Clear( 255, 255, 255, 255, false, true )
end
-- Render colored props to the scene and set their pixels high
cam.Start3D()
render.SetStencilEnable( true )
render.SuppressEngineLighting( true )
cam.IgnoreZ( entry.IgnoreZ )
render.SetStencilWriteMask( 1 )
render.SetStencilTestMask( 1 )
render.SetStencilReferenceValue( 1 )
render.SetStencilCompareFunction( STENCIL_ALWAYS )
render.SetStencilPassOperation( STENCIL_REPLACE )
render.SetStencilFailOperation( STENCIL_KEEP )
render.SetStencilZFailOperation( STENCIL_KEEP )
for k, v in pairs( entry.Ents ) do
if ( !IsValid( v ) or v:GetNoDraw() ) then continue end
RenderEnt = v
v:DrawModel()
end
RenderEnt = NULL
render.SetStencilCompareFunction( STENCIL_EQUAL )
render.SetStencilPassOperation( STENCIL_KEEP )
-- render.SetStencilFailOperation( STENCIL_KEEP )
-- render.SetStencilZFailOperation( STENCIL_KEEP )
cam.Start2D()
surface.SetDrawColor( entry.Color )
surface.DrawRect( 0, 0, ScrW(), ScrH() )
cam.End2D()
cam.IgnoreZ( false )
render.SuppressEngineLighting( false )
render.SetStencilEnable( false )
cam.End3D()
-- Store a blurred version of the colored props in an RT
render.CopyRenderTargetToTexture( rt_Blur )
render.BlurRenderTarget( rt_Blur, entry.BlurX, entry.BlurY, 1 )
-- Restore the original scene
render.SetRenderTarget( rt_Scene )
mat_Copy:SetTexture( "$basetexture", rt_Store )
mat_Copy:SetString( "$color", "1 1 1" )
mat_Copy:SetString( "$alpha", "1" )
render.SetMaterial( mat_Copy )
render.DrawScreenQuad()
-- Draw back our blured colored props additively/subtractively, ignoring the high bits
render.SetStencilEnable( true )
render.SetStencilCompareFunction( STENCIL_NOTEQUAL )
-- render.SetStencilPassOperation( STENCIL_KEEP )
-- render.SetStencilFailOperation( STENCIL_KEEP )
-- render.SetStencilZFailOperation( STENCIL_KEEP )
if ( entry.Additive ) then
mat_Add:SetTexture( "$basetexture", rt_Blur )
render.SetMaterial( mat_Add )
else
mat_Sub:SetTexture( "$basetexture", rt_Blur )
render.SetMaterial( mat_Sub )
end
for i = 0, entry.DrawPasses do
render.DrawScreenQuad()
end
render.SetStencilEnable( false )
-- Return original values
render.SetStencilTestMask( 0 )
render.SetStencilWriteMask( 0 )
render.SetStencilReferenceValue( 0 )
end
hook.Add( "PostDrawEffects", "RenderHalos", function()
hook.Run( "PreDrawHalos" )
if ( #List == 0 ) then return end
for k, v in ipairs( List ) do
Render( v )
end
List = {}
end )

286
lua/includes/modules/hook.lua Normal file
View File

@@ -0,0 +1,286 @@
--[[
| 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/
--]]
local gmod = gmod
local pairs = pairs
local setmetatable = setmetatable
local isstring = isstring
local isnumber = isnumber
local isbool = isbool
local isfunction = isfunction
local insert = table.insert
local IsValid = IsValid
local type = type
local ErrorNoHaltWithStack = ErrorNoHaltWithStack
-- I just do this so glua-lint doesn't rage at me
do
_G.HOOK_MONITOR_HIGH = -2
_G.HOOK_HIGH = -1
_G.HOOK_NORMAL = 0
_G.HOOK_LOW = 1
_G.HOOK_MONITOR_LOW = 2
end
local HOOK_MONITOR_HIGH = HOOK_MONITOR_HIGH
local HOOK_HIGH = HOOK_HIGH
local HOOK_NORMAL = HOOK_NORMAL
local HOOK_LOW = HOOK_LOW
local HOOK_MONITOR_LOW = HOOK_MONITOR_LOW
module("hook")
local events = {}
local function find_hook(event, name)
for i = 1, event.n, 4 do
local _name = event[i]
if _name and _name == name then
return i
end
end
end
--[[
we are making a new event table so we don't mess up anything
when adding/removing hooks while hook.Call is running, this is how it works:
1- When (adding/removing a hook)/(editing a hook priority), we create a new event table to avoid messing up hook.Call call order if it's running,
and the old event table will be shadowed and can only be accessed from hook.Call if it's running
2- We make old event table have __index method to make sure if any hook got removed/edited we (stop it from running)/(run the new function)
]]
local function copy_event(event, event_name)
local new_event = {}
do
for i = 1, event.n do
local v = event[i]
if v then
insert(new_event, v)
end
end
new_event.n = #new_event
end
-- we use proxies here just to make __index work
-- https://stackoverflow.com/a/3122136
local proxy = {}
do
for i = 1, event.n do
proxy[i] = event[i]
event[i] = nil
end
proxy.n = event.n
event.n = nil
end
setmetatable(event, {
__index = function(_, key)
-- make event.n work
if isstring(key) then
return proxy[key]
end
local name = proxy[key - 1]
if not name then return end
local parent = events[event_name]
-- if hook got removed then don't run it
local pos = find_hook(parent, name)
if not pos then return end
-- if hook priority changed then it should be treated as a new hook, don't run it
if parent[pos + 3 --[[priority]]] ~= proxy[key + 2 --[[priority]]] then return end
return parent[pos + 1]
end
})
return new_event
end
--[[---------------------------------------------------------
Name: Add
Args: string hookName, any identifier, function func
Desc: Add a hook to listen to the specified event.
-----------------------------------------------------------]]
function Add(event_name, name, func, priority)
if not isstring(event_name) then ErrorNoHaltWithStack("bad argument #1 to 'Add' (string expected, got " .. type(event_name) .. ")") return end
if not isfunction(func) then ErrorNoHaltWithStack("bad argument #3 to 'Add' (function expected, got " .. type(func) .. ")") return end
local notValid = name == nil or isnumber(name) or isbool(name) or isfunction(name) or not name.IsValid or not IsValid(name)
if not isstring(name) and notValid then ErrorNoHaltWithStack("bad argument #2 to 'Add' (string expected, got " .. type(name) .. ")") return end
local real_func = func
if not isstring(name) then
func = function(...)
local isvalid = name.IsValid
if isvalid and isvalid(name) then
return real_func(name, ...)
end
Remove(event_name, name)
end
end
if not isnumber(priority) then
priority = HOOK_NORMAL
elseif priority < HOOK_MONITOR_HIGH then
priority = HOOK_MONITOR_HIGH
elseif priority > HOOK_MONITOR_LOW then
priority = HOOK_MONITOR_LOW
end
-- disallow returning in monitor hooks
if priority == HOOK_MONITOR_HIGH or priority == HOOK_MONITOR_LOW then
local _func = func
func = function(...)
_func(...)
end
end
local event = events[event_name]
if not event then
event = {
n = 0,
}
events[event_name] = event
end
local pos
if event then
local _pos = find_hook(event, name)
-- if hook exists and priority changed then remove the old one because it has to be treated as a new hook
if _pos and event[_pos + 3] ~= priority then
Remove(event_name, name)
else
-- just update the hook here because nothing changed but the function
pos = _pos
end
end
event = events[event_name]
if pos then
event[pos + 1] = func
event[pos + 2] = real_func
return
end
if priority == HOOK_MONITOR_LOW then
local n = event.n
event[n + 1] = name
event[n + 2] = func
event[n + 3] = real_func
event[n + 4] = priority
else
local event_pos = 4
for i = 4, event.n, 4 do
local _priority = event[i]
if priority < _priority then
if i < event_pos then
event_pos = i
end
elseif priority >= _priority then
event_pos = i + 4
end
end
insert(event, event_pos - 3, name)
insert(event, event_pos - 2, func)
insert(event, event_pos - 1, real_func)
insert(event, event_pos, priority)
end
event.n = event.n + 4
end
--[[---------------------------------------------------------
Name: Remove
Args: string hookName, identifier
Desc: Removes the hook with the given indentifier.
-----------------------------------------------------------]]
function Remove(event_name, name)
local event = events[event_name]
if not event then return end
local pos = find_hook(event, name)
if pos then
event[pos] = nil --[[name]]
event[pos + 1] = nil --[[func]]
event[pos + 2] = nil --[[real_func]]
event[pos + 3] = nil --[[priority]]
end
events[event_name] = copy_event(event, event_name)
end
--[[---------------------------------------------------------
Name: GetTable
Desc: Returns a table of all hooks.
-----------------------------------------------------------]]
function GetTable()
local new_events = {}
for event_name, event in pairs(events) do
local hooks = {}
for i = 1, event.n, 4 do
local name = event[i]
if name then
hooks[name] = event[i + 2] --[[real_func]]
end
end
new_events[event_name] = hooks
end
return new_events
end
--[[---------------------------------------------------------
Name: Call
Args: string hookName, table gamemodeTable, vararg args
Desc: Calls hooks associated with the hook name.
-----------------------------------------------------------]]
function Call(event_name, gm, ...)
local event = events[event_name]
if event then
local i, n = 2, event.n
::loop::
local func = event[i]
if func then
local a, b, c, d, e, f = func(...)
if a ~= nil then
return a, b, c, d, e, f
end
end
i = i + 4
if i <= n then
goto loop
end
end
--
-- Call the gamemode function
--
if not gm then return end
local GamemodeFunction = gm[event_name]
if not GamemodeFunction then return end
return GamemodeFunction(gm, ...)
end
--[[---------------------------------------------------------
Name: Run
Args: string hookName, vararg args
Desc: Calls hooks associated with the hook name.
-----------------------------------------------------------]]
function Run(name, ...)
return Call(name, gmod and gmod.GetGamemode() or nil, ...)
end

117
lua/includes/modules/http.lua Normal file
View File

@@ -0,0 +1,117 @@
--[[
| 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/
--]]
local HTTP = HTTP
--[[---------------------------------------------------------
HTTP Module. Interaction with HTTP.
-----------------------------------------------------------]]
module( "http" )
--[[---------------------------------------------------------
Get the contents of a webpage.
Callback should be
function callback( (args optional), contents, size )
-----------------------------------------------------------]]
function Fetch( url, onsuccess, onfailure, header )
local request = {
url = url,
method = "get",
headers = header or {},
success = function( code, body, headers )
if ( !onsuccess ) then return end
onsuccess( body, body:len(), headers, code )
end,
failed = function( err )
if ( !onfailure ) then return end
onfailure( err )
end
}
local success = HTTP( request )
if ( !success && onfailure ) then onfailure( "HTTP failed" ) end
end
function Post( url, params, onsuccess, onfailure, header )
local request = {
url = url,
method = "post",
parameters = params,
headers = header or {},
success = function( code, body, headers )
if ( !onsuccess ) then return end
onsuccess( body, body:len(), headers, code )
end,
failed = function( err )
if ( !onfailure ) then return end
onfailure( err )
end
}
local success = HTTP( request )
if ( !success && onfailure ) then onfailure( "HTTP failed" ) end
end
--[[
Or use HTTP( table )
local request = {
url = "http://pastebin.com/raw.php?i=3jsf50nL",
method = "post",
parameters = {
id = "548",
country = "England"
}
success = function( code, body, headers )
Msg( "Request Successful\n" )
Msg( "Code: ", code, "\n" )
Msg( "Body Length:\n", body:len(), "\n" )
Msg( "Body:\n", body, "\n" )
PrintTable( headers )
end,
failed = function( reason )
Msg( "Request failed: ", reason, "\n" )
end
}
HTTP( request )
--]]

215
lua/includes/modules/killicon.lua Normal file
View File

@@ -0,0 +1,215 @@
--[[
| 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/
--]]
-- Globals that we need
local surface = surface
local Msg = Msg
local Color = Color
local Material = Material
--[[---------------------------------------------------------
Name: killicon
Desc: Stores and serves killicons for deathnotice
-----------------------------------------------------------]]
module( "killicon" )
local Icons = {}
local TYPE_FONT = 0
local TYPE_MATERIAL = 1
local TYPE_MATERIAL_UV = 2
function AddFont( name, font, character, color, heightScale )
Icons[name] = {
type = TYPE_FONT,
font = font,
character = character,
color = color or Color( 255, 80, 0 ),
-- Correct certain icons
heightScale = heightScale
}
end
function Add( name, material, color )
Icons[name] = {
type = TYPE_MATERIAL,
material = Material( material ),
color = color or Color( 255, 255, 255 )
}
end
function AddTexCoord( name, material, color, x, y, w, h )
Icons[name] = {
type = TYPE_MATERIAL_UV,
material = Material( material ),
color = color,
tex_x = x,
tex_y = y,
tex_w = w,
tex_h = h
}
end
function AddAlias( name, alias )
Icons[name] = Icons[alias]
end
function Exists( name )
return Icons[name] != nil
end
function GetSize( name, dontEqualizeHeight )
if ( !Icons[name] ) then
Msg( "Warning: killicon not found '" .. name .. "'\n" )
Icons[name] = Icons["default"]
end
local t = Icons[name]
-- Check the cache
if ( t.size ) then
-- Maintain the old behavior
if ( !dontEqualizeHeight ) then return t.size.adj_w, t.size.adj_h end
return t.size.w, t.size.h
end
local w, h = 0, 0
if ( t.type == TYPE_FONT ) then
surface.SetFont( t.font )
w, h = surface.GetTextSize( t.character )
if ( t.heightScale ) then h = h * t.heightScale end
elseif ( t.type == TYPE_MATERIAL ) then
w, h = t.material:Width(), t.material:Height()
elseif ( t.type == TYPE_MATERIAL_UV ) then
w = t.tex_w
h = t.tex_h
end
t.size = {}
t.size.w = w or 32
t.size.h = h or 32
-- Height adjusted behavior
if ( t.type == TYPE_FONT ) then
t.size.adj_w, t.size.adj_h = surface.GetTextSize( t.character )
-- BUG: This is not same height as the texture icons, and we cannot change it beacuse backwards compability
else
surface.SetFont( "HL2MPTypeDeath" )
local _, fh = surface.GetTextSize( "0" )
fh = fh * 0.75 -- Fudge it slightly
-- Resize, maintaining aspect ratio
t.size.adj_w = w * ( fh / h )
t.size.adj_h = fh
end
-- Maintain the old behavior
if ( !dontEqualizeHeight ) then return t.size.adj_w, t.size.adj_h end
return w, h
end
local function DrawInternal( x, y, name, alpha, noCorrections, dontEqualizeHeight )
alpha = alpha or 255
if ( !Icons[name] ) then
Msg( "Warning: killicon not found '" .. name .. "'\n" )
Icons[name] = Icons["default"]
end
local t = Icons[name]
local w, h = GetSize( name, dontEqualizeHeight )
if ( !noCorrections ) then x = x - w * 0.5 end
if ( t.type == TYPE_FONT ) then
-- HACK: Default font killicons are anchored to the top, so correct for it
if ( noCorrections && !dontEqualizeHeight ) then
local _, h2 = GetSize( name, !dontEqualizeHeight )
y = y + ( h - h2 ) / 2
end
if ( !noCorrections ) then y = y - h * 0.1 end
surface.SetTextPos( x, y )
surface.SetFont( t.font )
surface.SetTextColor( t.color.r, t.color.g, t.color.b, alpha )
surface.DrawText( t.character )
end
if ( t.type == TYPE_MATERIAL ) then
if ( !noCorrections ) then y = y - h * 0.3 end
surface.SetMaterial( t.material )
surface.SetDrawColor( t.color.r, t.color.g, t.color.b, alpha )
surface.DrawTexturedRect( x, y, w, h )
end
if ( t.type == TYPE_MATERIAL_UV ) then
if ( !noCorrections ) then y = y - h * 0.3 end
local tw = t.material:Width()
local th = t.material:Height()
surface.SetMaterial( t.material )
surface.SetDrawColor( t.color.r, t.color.g, t.color.b, alpha )
surface.DrawTexturedRectUV( x, y, w, h, t.tex_x / tw, t.tex_y / th, ( t.tex_x + t.tex_w ) / tw, ( t.tex_y + t.tex_h ) / th )
end
end
-- Old function with weird vertical adjustments
function Draw( x, y, name, alpha )
DrawInternal( x, y, name, alpha )
end
-- The new function that doesn't have the weird vertical adjustments
function Render( x, y, name, alpha, dontEqualizeHeight )
DrawInternal( x, y, name, alpha, true, dontEqualizeHeight )
end
local Color_Icon = Color( 255, 80, 0, 255 )
Add( "default", "HUD/killicons/default", Color_Icon )
AddAlias( "suicide", "default" )

76
lua/includes/modules/list.lua Normal file
View File

@@ -0,0 +1,76 @@
--[[
| 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/
--]]
local table = table
local pairs = pairs
module( "list" )
local Lists = {}
function Get( listid )
return table.Copy( GetForEdit( listid ) )
end
function GetForEdit( listid, nocreate )
local list = Lists[ listid ]
if ( !nocreate && list == nil ) then
list = {}
Lists[ listid ] = list
end
return list
end
function GetTable()
return table.GetKeys( Lists )
end
function Set( listid, key, value )
GetForEdit( listid )[ key ] = value
end
function Add( listid, value )
return table.insert( GetForEdit( listid ), value )
end
function Contains( listid, value )
local list = Lists[ listid ]
if ( list == nil ) then return false end
for k, v in pairs( list ) do
if ( v == value ) then return true end
end
return false
end
function HasEntry( listid, key )
local list = Lists[ listid ]
return list != nil && list[ key ] != nil
end

568
lua/includes/modules/markup.lua Normal file
View File

@@ -0,0 +1,568 @@
--[[
| 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/
--]]
local string = string
local table = table
local surface = surface
local tostring = tostring
local ipairs = ipairs
local setmetatable = setmetatable
local tonumber = tonumber
local math = math
local utf8 = utf8
local _Color = Color
local MarkupObject = {}
MarkupObject.__index = MarkupObject
debug.getregistry().MarkupObject = MarkupObject
module("markup")
--[[---------------------------------------------------------
Name: Constants used for text alignment.
These must be the same values as in the draw module.
-----------------------------------------------------------]]
TEXT_ALIGN_LEFT = 0
TEXT_ALIGN_CENTER = 1
TEXT_ALIGN_RIGHT = 2
TEXT_ALIGN_TOP = 3
TEXT_ALIGN_BOTTOM = 4
--[[---------------------------------------------------------
Name: Color(Color(r, g, b, a))
Desc: Convenience function which converts a Color object into a string
which can be used in the <color=r,g,b,a></color> tag
e.g. Color(255, 0, 0, 150) -> 255,0,0,150
Color(255, 0, 0) -> 255,0,0
Color(255, 0, 0, 255) -> 255,0,0
Usage: markup.Color(Color(r, g, b, a))
-----------------------------------------------------------]]
function Color( col )
return
col.r .. "," ..
col.g .. "," ..
col.b ..
-- If the alpha value is 255, we don't need to include it in the <color> tag, so just omit it:
( col.a == 255 and "" or ( "," .. col.a ) )
end
local Color = _Color
--[[---------------------------------------------------------
Name: Temporary information used when building text frames.
-----------------------------------------------------------]]
local colour_stack = { Color( 255, 255, 255 ) }
local font_stack = { "DermaDefault" }
local blocks = {}
local colourmap = {
-- it's all black and white
["black"] = Color( 0, 0, 0 ),
["white"] = Color( 255, 255, 255 ),
-- it's greys
["dkgrey"] = Color( 64, 64, 64 ),
["grey"] = Color( 128, 128, 128 ),
["ltgrey"] = Color( 192, 192, 192 ),
-- account for speeling mistakes
["dkgray"] = Color( 64, 64, 64 ),
["gray"] = Color( 128, 128, 128 ),
["ltgray"] = Color( 192, 192, 192 ),
-- normal colours
["red"] = Color( 255, 0, 0 ),
["green"] = Color( 0, 255, 0 ),
["blue"] = Color( 0, 0, 255 ),
["yellow"] = Color( 255, 255, 0 ),
["purple"] = Color( 255, 0, 255 ),
["cyan"] = Color( 0, 255, 255 ),
["turq"] = Color( 0, 255, 255 ),
-- dark variations
["dkred"] = Color( 128, 0, 0 ),
["dkgreen"] = Color( 0, 128, 0 ),
["dkblue"] = Color( 0, 0, 128 ),
["dkyellow"] = Color( 128, 128, 0 ),
["dkpurple"] = Color( 128, 0, 128 ),
["dkcyan"] = Color( 0, 128, 128 ),
["dkturq"] = Color( 0, 128, 128 ),
-- light variations
["ltred"] = Color( 255, 128, 128 ),
["ltgreen"] = Color( 128, 255, 128 ),
["ltblue"] = Color( 128, 128, 255 ),
["ltyellow"] = Color( 255, 255, 128 ),
["ltpurple"] = Color( 255, 128, 255 ),
["ltcyan"] = Color( 128, 255, 255 ),
["ltturq"] = Color( 128, 255, 255 ),
}
--[[---------------------------------------------------------
Name: colourMatch(c)
Desc: Match a colour name to an rgb value.
Usage: ** INTERNAL ** Do not use!
-----------------------------------------------------------]]
local function colourMatch( c )
return colourmap[ string.lower( c ) ]
end
--[[---------------------------------------------------------
Name: ExtractParams(p1,p2,p3)
Desc: This function is used to extract the tag information.
Usage: ** INTERNAL ** Do not use!
-----------------------------------------------------------]]
local function ExtractParams( p1, p2, p3 )
if ( string.sub( p1, 1, 1 ) == "/" ) then
local tag = string.sub( p1, 2 )
if ( tag == "color" or tag == "colour" ) then
table.remove( colour_stack )
elseif ( tag == "font" or tag == "face" ) then
table.remove( font_stack )
end
else
if ( p1 == "color" or p1 == "colour" ) then
local rgba = colourMatch( p2 )
if ( rgba == nil ) then
rgba = Color( 255, 255, 255, 255 )
local x = { "r", "g", "b", "a" }
local n = 1
for k, v in string.gmatch( p2, "(%d+),?" ) do
rgba[ x[ n ] ] = tonumber( k )
n = n + 1
end
end
table.insert( colour_stack, rgba )
elseif ( p1 == "font" or p1 == "face" ) then
table.insert( font_stack, tostring( p2 ) )
end
end
end
--[[---------------------------------------------------------
Name: CheckTextOrTag(p)
Desc: This function places data in the "blocks" table
depending of if p is a tag, or some text
Usage: ** INTERNAL ** Do not use!
-----------------------------------------------------------]]
local function CheckTextOrTag( p )
if ( p == "" ) then return end
if ( p == nil ) then return end
if ( string.sub( p, 1, 1 ) == "<" ) then
string.gsub( p, "<([/%a]*)=?([^>]*)", ExtractParams )
else
local text_block = {}
text_block.text = p
text_block.colour = colour_stack[ #colour_stack ]
text_block.font = font_stack[ #font_stack ]
table.insert( blocks, text_block )
end
end
--[[---------------------------------------------------------
Name: ProcessMatches(p1,p2,p3)
Desc: CheckTextOrTag for 3 parameters. Called by string.gsub
Usage: ** INTERNAL ** Do not use!
-----------------------------------------------------------]]
local function ProcessMatches( p1, p2, p3 )
if ( p1 ) then CheckTextOrTag( p1 ) end
if ( p2 ) then CheckTextOrTag( p2 ) end
if ( p3 ) then CheckTextOrTag( p3 ) end
end
--[[---------------------------------------------------------
Name: MarkupObject:GetWidth()
Desc: Returns the width of a markup block
Usage: ml:GetWidth()
-----------------------------------------------------------]]
function MarkupObject:GetWidth()
return self.totalWidth
end
--[[---------------------------------------------------------
Name: MarkupObject:GetMaxWidth()
Desc: Returns the maximum width of a markup block
Usage: ml:GetMaxWidth()
-----------------------------------------------------------]]
function MarkupObject:GetMaxWidth()
return self.maxWidth or self.totalWidth
end
--[[---------------------------------------------------------
Name: MarkupObject:GetHeight()
Desc: Returns the height of a markup block
Usage: ml:GetHeight()
-----------------------------------------------------------]]
function MarkupObject:GetHeight()
return self.totalHeight
end
function MarkupObject:Size()
return self.totalWidth, self.totalHeight
end
--[[---------------------------------------------------------
Name: MarkupObject:Draw(xOffset, yOffset, halign, valign, alphaoverride)
Desc: Draw the markup text to the screen as position xOffset, yOffset.
Halign and Valign can be used to align the text relative to its offset.
Alphaoverride can be used to override the alpha value of the text-colour.
textAlign can be used to align the actual text inside of its bounds.
Usage: MarkupObject:Draw(100, 100)
-----------------------------------------------------------]]
function MarkupObject:Draw( xOffset, yOffset, halign, valign, alphaoverride, textAlign )
for i, blk in ipairs( self.blocks ) do
local y = yOffset + ( blk.height - blk.thisY ) + blk.offset.y
local x = xOffset
if ( halign == TEXT_ALIGN_CENTER ) then x = x - ( self.totalWidth / 2 )
elseif ( halign == TEXT_ALIGN_RIGHT ) then x = x - self.totalWidth
end
x = x + blk.offset.x
if ( valign == TEXT_ALIGN_CENTER ) then y = y - ( self.totalHeight / 2 )
elseif ( valign == TEXT_ALIGN_BOTTOM ) then y = y - self.totalHeight
end
local alpha = blk.colour.a
if ( alphaoverride ) then alpha = alphaoverride end
surface.SetFont( blk.font )
surface.SetTextColor( blk.colour.r, blk.colour.g, blk.colour.b, alpha )
surface.SetTextPos( x, y )
if ( textAlign ~= TEXT_ALIGN_LEFT ) then
local lineWidth = self.lineWidths[ blk.offset.y ]
if ( lineWidth ) then
if ( textAlign == TEXT_ALIGN_CENTER ) then
surface.SetTextPos( x + ( ( self.totalWidth - lineWidth ) / 2 ), y )
elseif ( textAlign == TEXT_ALIGN_RIGHT ) then
surface.SetTextPos( x + ( self.totalWidth - lineWidth ), y )
end
end
end
surface.DrawText( blk.text )
end
end
--[[---------------------------------------------------------
Name: Escape(str)
Desc: Converts a string to its escaped, markup-safe equivalent
Usage: markup.Escape("<font=Default>The font will remain unchanged & these < > & symbols will also appear normally</font>")
-----------------------------------------------------------]]
local escapeEntities, unescapeEntities = {
["&"] = "&amp;",
["<"] = "&lt;",
[">"] = "&gt;"
}, {
["&amp;"] = "&",
["&lt;"] = "<",
["&gt;"] = ">"
}
function Escape( str )
return ( string.gsub( tostring( str ), "[&<>]", escapeEntities ) )
end
--[[---------------------------------------------------------
Name: Parse(ml, maxwidth)
Desc: Parses the pseudo-html markup language, and creates a
MarkupObject, which can be used to the draw the
text to the screen. Valid tags are: font and colour.
\n and \t are also available to move to the next line,
or insert a tab character.
Maxwidth can be used to make the text wrap to a specific
width and allows for text alignment (e.g. centering) inside
the bounds.
Usage: markup.Parse("<font=Default>changed font</font>\n<colour=255,0,255,255>changed colour</colour>")
-----------------------------------------------------------]]
function Parse( ml, maxwidth )
ml = utf8.force( ml ) -- Ensure we have valid UTF-8 data
colour_stack = { Color( 255, 255, 255 ) }
font_stack = { "DermaDefault" }
blocks = {}
if ( !string.find( ml, "<" ) ) then
ml = ml .. "<nop>"
end
string.gsub( ml, "([^<>]*)(<[^>]+.)([^<>]*)", ProcessMatches )
local xOffset = 0
local yOffset = 0
local xSize = 0
local xMax = 0
local thisMaxY = 0
local new_block_list = {}
local ymaxes = {}
local lineWidths = {}
local lineHeight = 0
for i, blk in ipairs( blocks ) do
surface.SetFont( blk.font )
blk.text = string.gsub( blk.text, "(&.-;)", unescapeEntities )
local thisY = 0
local curString = ""
for j, c in utf8.codes( blk.text ) do
local ch = utf8.char( c )
if ( ch == "\n" ) then
if ( thisY == 0 ) then
thisY = lineHeight
thisMaxY = lineHeight
else
lineHeight = thisY
end
if ( string.len( curString ) > 0 ) then
local x1 = surface.GetTextSize( curString )
local new_block = {
text = curString,
font = blk.font,
colour = blk.colour,
thisY = thisY,
thisX = x1,
offset = {
x = xOffset,
y = yOffset
}
}
table.insert( new_block_list, new_block )
if ( xOffset + x1 > xMax ) then
xMax = xOffset + x1
end
end
xOffset = 0
xSize = 0
yOffset = yOffset + thisMaxY
thisY = 0
curString = ""
thisMaxY = 0
elseif ( ch == "\t" ) then
if ( string.len( curString ) > 0 ) then
local x1 = surface.GetTextSize( curString )
local new_block = {
text = curString,
font = blk.font,
colour = blk.colour,
thisY = thisY,
thisX = x1,
offset = {
x = xOffset,
y = yOffset
}
}
table.insert( new_block_list, new_block )
if ( xOffset + x1 > xMax ) then
xMax = xOffset + x1
end
end
curString = ""
local xOldSize = xSize
xSize = 0
local xOldOffset = xOffset
xOffset = math.ceil( ( xOffset + xOldSize ) / 50 ) * 50
if ( xOffset == xOldOffset ) then
xOffset = xOffset + 50
if ( maxwidth and xOffset > maxwidth ) then
-- Needs a new line
if ( thisY == 0 ) then
thisY = lineHeight
thisMaxY = lineHeight
else
lineHeight = thisY
end
xOffset = 0
yOffset = yOffset + thisMaxY
thisY = 0
thisMaxY = 0
end
end
else
local x, y = surface.GetTextSize( ch )
if ( x == nil ) then return end
if ( maxwidth and maxwidth > x ) then
if ( xOffset + xSize + x >= maxwidth ) then
-- need to: find the previous space in the curString
-- if we can't find one, take off the last character
-- and insert as a new block, incrementing the y etc
local lastSpacePos = string.len( curString )
for k = 1,string.len( curString ) do
local chspace = string.sub( curString, k, k )
if ( chspace == " " ) then
lastSpacePos = k
end
end
local previous_block = new_block_list[ #new_block_list ]
local wrap = lastSpacePos == string.len( curString ) && lastSpacePos > 0
if ( previous_block and previous_block.text:match(" $") and wrap and surface.GetTextSize( blk.text ) < maxwidth ) then
-- If the block was preceded by a space, wrap the block onto the next line first, as we can probably fit it there
local trimmed, trimCharNum = previous_block.text:gsub(" +$", "")
if ( trimCharNum > 0 ) then
previous_block.text = trimmed
previous_block.thisX = surface.GetTextSize( previous_block.text )
end
else
if ( wrap ) then
-- If the block takes up multiple lines (and has no spaces), split it up
local sequenceStartPos = utf8.offset( curString, 0, lastSpacePos )
ch = string.match( curString, utf8.charpattern, sequenceStartPos ) .. ch
j = utf8.offset( curString, 1, sequenceStartPos )
curString = string.sub( curString, 1, sequenceStartPos - 1 )
else
-- Otherwise, strip the trailing space and start a new line
ch = string.sub( curString, lastSpacePos + 1 ) .. ch
j = lastSpacePos + 1
curString = string.sub( curString, 1, math.max( lastSpacePos - 1, 0 ) )
end
local m = 1
while string.sub( ch, m, m ) == " " do
m = m + 1
end
ch = string.sub( ch, m )
local x1,y1 = surface.GetTextSize( curString )
if ( y1 > thisMaxY ) then
thisMaxY = y1
ymaxes[ yOffset ] = thisMaxY
lineHeight = y1
end
local new_block = {
text = curString,
font = blk.font,
colour = blk.colour,
thisY = thisY,
thisX = x1,
offset = {
x = xOffset,
y = yOffset
}
}
table.insert( new_block_list, new_block )
if ( xOffset + x1 > xMax ) then
xMax = xOffset + x1
end
curString = ""
end
xOffset = 0
xSize = 0
x, y = surface.GetTextSize( ch )
yOffset = yOffset + thisMaxY
thisY = 0
thisMaxY = 0
end
end
curString = curString .. ch
thisY = y
xSize = xSize + x
if ( y > thisMaxY ) then
thisMaxY = y
ymaxes[ yOffset ] = thisMaxY
lineHeight = y
end
end
end
if ( string.len( curString ) > 0 ) then
local x1 = surface.GetTextSize( curString )
local new_block = {
text = curString,
font = blk.font,
colour = blk.colour,
thisY = thisY,
thisX = x1,
offset = {
x = xOffset,
y = yOffset
}
}
table.insert( new_block_list, new_block )
lineHeight = thisY
if ( xOffset + x1 > xMax ) then
xMax = xOffset + x1
end
xOffset = xOffset + x1
end
xSize = 0
end
local totalHeight = 0
for i, blk in ipairs( new_block_list ) do
blk.height = ymaxes[ blk.offset.y ]
if ( blk.offset.y + blk.height > totalHeight ) then
totalHeight = blk.offset.y + blk.height
end
lineWidths[ blk.offset.y ] = math.max( lineWidths[ blk.offset.y ] or 0, blk.offset.x + blk.thisX )
end
return setmetatable( {
totalHeight = totalHeight,
totalWidth = xMax,
maxWidth = maxwidth,
lineWidths = lineWidths,
blocks = new_block_list
}, MarkupObject )
end

88
lua/includes/modules/matproxy.lua Normal file
View File

@@ -0,0 +1,88 @@
--[[
| 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/
--]]
module( "matproxy", package.seeall )
ProxyList = {}
ActiveList = {}
--
-- Called by engine, returns true if we're overriding a proxy
--
function ShouldOverrideProxy( name )
return ProxyList[ name ] != nil
end
--
-- Called to add a new proxy (see lua/matproxy/ for examples)
--
function Add( tbl )
if ( !tbl.name ) then return end
if ( !tbl.bind ) then return end
local bReloading = ProxyList[ tbl.name ] != nil
ProxyList[ tbl.name ] = tbl
--
-- If we're reloading then reload all the active entries that use this proxy
--
if ( bReloading ) then
for k, v in pairs( ActiveList ) do
if ( tbl.name != v.name ) then continue end
Msg( "Reloading: ", v.Material, "\n" )
Init( tbl.name, k, v.Material, v.Values )
end
end
end
--
-- Called by the engine from OnBind
--
function Call( name, mat, ent )
local proxy = ActiveList[ name ]
if ( !proxy ) then return end
if ( !proxy.bind ) then return end
proxy:bind( mat, ent )
end
--
-- Called by the engine from OnBind
--
function Init( name, uname, mat, values )
local proxy = ProxyList[ name ]
if ( !proxy ) then return end
ActiveList[ uname ] = table.Copy( proxy )
local active_proxy = ActiveList[ uname ]
if ( !active_proxy.init ) then return end
active_proxy:init( mat, values )
-- Store these incase we reload
active_proxy.Values = values
active_proxy.Material = mat
end

49
lua/includes/modules/menubar.lua Normal file
View File

@@ -0,0 +1,49 @@
--[[
| 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/
--]]
menubar = {}
function menubar.Init()
menubar.Control = vgui.Create( "DMenuBar" )
menubar.Control:Dock( TOP )
menubar.Control:SetVisible( false )
hook.Run( "PopulateMenuBar", menubar.Control )
end
function menubar.ParentTo( pnl )
// I don't like this
if ( !IsValid( menubar.Control ) ) then
menubar.Init()
end
menubar.Control:SetParent( pnl )
menubar.Control:MoveToBack()
menubar.Control:SetHeight( 30 )
menubar.Control:SetVisible( true )
end
function menubar.IsParent( pnl )
return menubar.Control:GetParent() == pnl
end
hook.Add( "OnGamemodeLoaded", "CreateMenuBar", function()
menubar.Init()
end )

13
lua/includes/modules/momo.lua Normal file
View File

@@ -0,0 +1,13 @@
--[[
| 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/
--]]
AddCSLuaFile()
print("MOMO MODULE DEPRECATED!")

163
lua/includes/modules/niknaks.lua Normal file
View File

@@ -0,0 +1,163 @@
--[[
| 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/
--]]
-- Copyright © 2022-2072, Nak, https://steamcommunity.com/id/Nak2/
-- All Rights Reserved. Not allowed to be reuploaded.
AddCSLuaFile()
-- Make sure to use the newest version of NikNaks.
local version = 0.36
if NikNaks and NikNaks.Version > version then return end
local file_Find, MsgC, unpack, rawget = file.Find, MsgC, unpack, rawget
NikNaks = {}
NikNaks.net = {}
NikNaks.Version = version
NikNaks.Authors = "Nak"
MsgN("Loading NikNaks: " .. NikNaks.Version)
NikNaks.__metatables = {}
do
---A simply Msg function for NikNaks
function NikNaks.Msg( ... )
local a = {...}
if #a < 1 then return end
MsgC(NikNaks.REALM_COLOR,"[NN] ", unpack(a), "\n")
end
end
---Auto includes, runs and AddCSLuaFile files using their prefix.
function NikNaks.AutoInclude( str )
local path = str
if string.find(str,"/") then
path = string.GetFileFromFilename(str)
end
local _type
if path ~= "shared.lua" then
_type = string.sub(path,0,3)
else
_type = "sh_"
end
if SERVER then
if _type == "cl_" or _type == "sh_" then
AddCSLuaFile(str)
end
if _type ~= "cl_" then
return include(str)
end
elseif _type ~= "sv_" then
return pcall(include, str)
end
end
---Autp includes, runs and AddCSLuaFile a folder by the files prefix.
function NikNaks.AutoIncludeFolder( str )
for _,fil in ipairs(file_Find(str .. "/*.lua","LUA")) do
NikNaks.AutoInclude(str .. "/" .. fil)
end
end
-- A simple scope-script
do
local g = _G
local envs = {}
local env = {}
local getfenv, setfenv, source = getfenv, setfenv, jit.util.funcinfo( NikNaks.AutoInclude )["source"]
local NikNaks = NikNaks
local function createEnv( tab, source )
local t = {}
setmetatable(t, { __index = function(k, v)
return rawget(NikNaks, v) or tab[v]
end,
__newindex = function( t, k, v)
rawset( _G, k, v )
end})
envs[ tab ] = t
return t
end
-- Patches any tables with names that share _G
--NikNaks._source = source:lower():match("addons/(.-)/")
NikNaks._source = "niknak"
local function using()
local _env = getfenv( 2 )
if _env ~= _GEnv then -- Make sure it isn't our env
-- Create new env and apply it
setfenv(2, envs[_env] or createEnv( _env, NikNaks._source ))
else
-- Ignore for now.
-- error("Can't apply enviroment to self")
end
end
setmetatable(NikNaks,{
__call = function( _, ...) return using( ... ) end
})
end
--[[
For safty reasons, we're won't use AutoInclude or AutoIncludeFolder. These should be hardcoded.
]]
--- @class BSPObject
local meta = {}
meta.__index = meta
meta.__tostring = function( self ) return string.format( "BSP Map [ %s ]", self._mapfile ) end
meta.MetaName = "BSP"
NikNaks.__metatables["BSP"] = meta
NikNaks._Source = "niknak"
NikNaks.AutoInclude("niknaks/modules/sh_enums.lua")
NikNaks.AutoInclude("niknaks/modules/sh_util_extended.lua")
NikNaks.AutoInclude("niknaks/modules/sh_file_extended.lua")
NikNaks.AutoInclude("niknaks/modules/sh_timedelta.lua")
NikNaks.AutoInclude("niknaks/modules/sh_datetime.lua")
NikNaks.AutoInclude("niknaks/modules/sh_color_extended.lua")
NikNaks.AutoInclude("niknaks/modules/sh_model_extended.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bitbuffer.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_module.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_entities.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_faces.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_leafs.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_brushes.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_pvspas.lua")
NikNaks.AutoInclude("niknaks/modules/sh_bsp_staticprops.lua")
NikNaks.AutoInclude("niknaks/modules/sh_pathfind_module.lua")
NikNaks.AutoInclude("niknaks/modules/sh_ain_module.lua")
NikNaks.AutoInclude("niknaks/framework/sh_localbsp.lua")
NikNaks.AutoInclude("niknaks/framework/sh_epath.lua")
-- Patch table to ref _G
do
local g = _G
for key, val in pairs( NikNaks ) do
if not istable( val ) then continue end
if not _G[key] then continue end
--if not NikNaks._source:find("niknak") then continue end
setmetatable(val, { __index = function(k, v)
return rawget(k, v) or g[key][v]
end})
end
end
-- Post Init. This is a safety option, as using traces and other functions before InitPostEntity can cause crash.
if _NIKNAKS_POSTENTITY then
NikNaks.PostInit = true
timer.Simple(1, NikNaks._LoadPathOptions )
else
hook.Add("NikNaks._LoadPathOptions", "wait", function()
NikNaks.PostInit = true
NikNaks._LoadPathOptions()
hook.Remove("NikNaks._LoadPathOptions", "wait")
end)
end
-- return NikNaks -- Doesn't work for require :C

304
lua/includes/modules/notification.lua Normal file
View File

@@ -0,0 +1,304 @@
--[[
| 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/
--]]
surface.CreateFont( "GModNotify", {
font = "Arial",
size = 21,
weight = 0
} )
NOTIFY_GENERIC = 0
NOTIFY_ERROR = 1
NOTIFY_UNDO = 2
NOTIFY_HINT = 3
NOTIFY_CLEANUP = 4
module( "notification", package.seeall )
local NoticeMaterial = {}
NoticeMaterial[ NOTIFY_GENERIC ] = Material( "vgui/notices/generic" )
NoticeMaterial[ NOTIFY_ERROR ] = Material( "vgui/notices/error" )
NoticeMaterial[ NOTIFY_UNDO ] = Material( "vgui/notices/undo" )
NoticeMaterial[ NOTIFY_HINT ] = Material( "vgui/notices/hint" )
NoticeMaterial[ NOTIFY_CLEANUP ] = Material( "vgui/notices/cleanup" )
local Notices = {}
function AddProgress( uid, text, frac )
if ( IsValid( Notices[ uid ] ) ) then
Notices[ uid ].StartTime = SysTime()
Notices[ uid ].Length = -1
Notices[ uid ]:SetText( text )
Notices[ uid ]:SetProgress( frac )
return
end
local parent = nil
if ( GetOverlayPanel ) then parent = GetOverlayPanel() end
local Panel = vgui.Create( "NoticePanel", parent )
Panel.StartTime = SysTime()
Panel.Length = -1
Panel.VelX = -5
Panel.VelY = 0
Panel.fx = ScrW() + 200
Panel.fy = ScrH()
Panel:SetAlpha( 255 )
Panel:SetText( text )
Panel:SetPos( Panel.fx, Panel.fy )
Panel:SetProgress( frac )
Notices[ uid ] = Panel
end
function Kill( uid )
if ( !IsValid( Notices[ uid ] ) ) then return end
Notices[ uid ].StartTime = SysTime()
Notices[ uid ].Length = 0.8
end
function AddLegacy( text, type, length )
local parent = nil
if ( GetOverlayPanel ) then parent = GetOverlayPanel() end
local Panel = vgui.Create( "NoticePanel", parent )
Panel.StartTime = SysTime()
Panel.Length = math.max( length, 0 )
Panel.VelX = -5
Panel.VelY = 0
Panel.fx = ScrW() + 200
Panel.fy = ScrH()
Panel:SetAlpha( 255 )
Panel:SetText( text )
Panel:SetLegacyType( type )
Panel:SetPos( Panel.fx, Panel.fy )
table.insert( Notices, Panel )
end
-- This is ugly because it's ripped straight from the old notice system
local function UpdateNotice( pnl, total_h )
local x = pnl.fx
local y = pnl.fy
local w = pnl:GetWide() + 16
local h = pnl:GetTall() + 4
local ideal_y = ScrH() - 150 - h - total_h
local ideal_x = ScrW() - w - 20
local timeleft = pnl.StartTime - ( SysTime() - pnl.Length )
if ( pnl.Length < 0 ) then timeleft = 1 end
-- Cartoon style about to go thing
if ( timeleft < 0.7 ) then
ideal_x = ideal_x - 50
end
-- Gone!
if ( timeleft < 0.2 ) then
ideal_x = ideal_x + w * 2
end
local spd = RealFrameTime() * 15
y = y + pnl.VelY * spd
x = x + pnl.VelX * spd
local dist = ideal_y - y
pnl.VelY = pnl.VelY + dist * spd * 1
if ( math.abs( dist ) < 2 && math.abs( pnl.VelY ) < 0.1 ) then pnl.VelY = 0 end
dist = ideal_x - x
pnl.VelX = pnl.VelX + dist * spd * 1
if ( math.abs( dist ) < 2 && math.abs( pnl.VelX ) < 0.1 ) then pnl.VelX = 0 end
-- Friction.. kind of FPS independant.
pnl.VelX = pnl.VelX * ( 0.95 - RealFrameTime() * 8 )
pnl.VelY = pnl.VelY * ( 0.95 - RealFrameTime() * 8 )
pnl.fx = x
pnl.fy = y
-- If the panel is too high up (out of screen), do not update its position. This lags a lot when there are lot of panels outside of the screen
if ( ideal_y > -ScrH() ) then
pnl:SetPos( pnl.fx, pnl.fy )
end
return total_h + h
end
local function Update()
if ( !Notices ) then return end
local h = 0
for key, pnl in pairs( Notices ) do
h = UpdateNotice( pnl, h )
end
for k, Panel in pairs( Notices ) do
if ( !IsValid( Panel ) || Panel:KillSelf() ) then Notices[ k ] = nil end
end
end
hook.Add( "Think", "NotificationThink", Update )
local PANEL = {}
function PANEL:Init()
self:DockPadding( 3, 3, 3, 3 )
self.Label = vgui.Create( "DLabel", self )
self.Label:Dock( FILL )
self.Label:SetFont( "GModNotify" )
self.Label:SetTextColor( color_white )
self.Label:SetExpensiveShadow( 1, Color( 0, 0, 0, 200 ) )
self.Label:SetContentAlignment( 5 )
self:SetBackgroundColor( Color( 20, 20, 20, 255 * 0.6 ) )
end
function PANEL:SetText( txt )
self.Label:SetText( txt )
self:SizeToContents()
end
function PANEL:SizeToContents()
self.Label:SizeToContents()
local width, tall = self.Label:GetSize()
tall = math.max( tall, 32 ) + 6
width = width + 20
if ( IsValid( self.Image ) ) then
width = width + 32 + 8
local x = ( tall - 36 ) / 2
self.Image:DockMargin( 0, x, 0, x )
end
if ( self.Progress ) then
tall = tall + 10
self.Label:DockMargin( 0, 0, 0, 10 )
end
self:SetSize( width, tall )
self:InvalidateLayout()
end
function PANEL:SetLegacyType( t )
self.Image = vgui.Create( "DImageButton", self )
self.Image:SetMaterial( NoticeMaterial[ t ] )
self.Image:SetSize( 32, 32 )
self.Image:Dock( LEFT )
self.Image:DockMargin( 0, 0, 8, 0 )
self.Image.DoClick = function()
self.StartTime = 0
end
self:SizeToContents()
end
function PANEL:Paint( w, h )
local shouldDraw = !( LocalPlayer && IsValid( LocalPlayer() ) && IsValid( LocalPlayer():GetActiveWeapon() ) && LocalPlayer():GetActiveWeapon():GetClass() == "gmod_camera" )
if ( IsValid( self.Label ) ) then self.Label:SetVisible( shouldDraw ) end
if ( IsValid( self.Image ) ) then self.Image:SetVisible( shouldDraw ) end
if ( !shouldDraw ) then return end
self.BaseClass.Paint( self, w, h )
if ( !self.Progress ) then return end
local boxX, boxY = 10, self:GetTall() - 13
local boxW, boxH = self:GetWide() - 20, 5
local boxInnerW = boxW - 2
surface.SetDrawColor( 0, 100, 0, 150 )
surface.DrawRect( boxX, boxY, boxW, boxH )
surface.SetDrawColor( 0, 50, 0, 255 )
surface.DrawRect( boxX + 1, boxY + 1, boxW - 2, boxH - 2 )
local w = math.ceil( boxInnerW * 0.25 )
local x = math.fmod( math.floor( SysTime() * 200 ), boxInnerW + w ) - w
if ( self.ProgressFrac ) then
x = 0
w = math.ceil( boxInnerW * self.ProgressFrac )
end
if ( x + w > boxInnerW ) then w = math.ceil( boxInnerW - x ) end
if ( x < 0 ) then
w = w + x
x = 0
end
surface.SetDrawColor( 0, 255, 0, 255 )
surface.DrawRect( boxX + 1 + x, boxY + 1, w, boxH - 2 )
end
function PANEL:SetProgress( frac )
self.Progress = true
self.ProgressFrac = frac
self:SizeToContents()
end
function PANEL:KillSelf()
-- Infinite length
if ( self.Length < 0 ) then return false end
if ( self.StartTime + self.Length < SysTime() ) then
self:Remove()
return true
end
return false
end
vgui.Register( "NoticePanel", PANEL, "DPanel" )

255
lua/includes/modules/numpad.lua Normal file
View File

@@ -0,0 +1,255 @@
--[[
| 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/
--]]
--[[---------------------------------------------------------
This module was primarily developed to enable toolmodes
to share the numpad.
Scripted Entities can add functions to be excecuted when
a certain key on the numpad is pressed or released.
-----------------------------------------------------------]]
if ( !SERVER ) then return end
local tonumber = tonumber
local pairs = pairs
local unpack = unpack
local table = table
local saverestore = saverestore
local math = math
local IsValid = IsValid
local type = type
local ErrorNoHaltWithStack = ErrorNoHaltWithStack
module( "numpad" )
local functions = {}
local keys_in = {}
local keys_out = {}
local lastindex = 1
local button_fired = false
function FromButton()
return button_fired == true
end
local function Save( save )
saverestore.WriteTable( keys_in, save )
saverestore.WriteTable( keys_out, save )
saverestore.WriteVar( lastindex, save )
end
local function Restore( restore )
keys_in = saverestore.ReadTable( restore )
keys_out = saverestore.ReadTable( restore )
lastindex = saverestore.ReadVar( restore )
end
saverestore.AddSaveHook( "NumpadModule", Save )
saverestore.AddRestoreHook( "NumpadModule", Restore )
--[[---------------------------------------------------------
Returns a unique index based on a player.
-----------------------------------------------------------]]
local function GetPlayerIndex( ply )
if ( !IsValid( ply ) ) then return 0 end
return ply:SteamID64()
end
--[[---------------------------------------------------------
Fires the impulse to the child functions
-----------------------------------------------------------]]
local function FireImpulse( tab, pl, idx )
if ( idx == nil ) then
idx = GetPlayerIndex( pl )
end
if ( !tab ) then return end
if ( !tab[ idx ] ) then return end
for k, v in pairs( tab[ idx ] ) do
local func = functions[ v.name ]
local retval = func( pl, unpack( v.arg ) )
-- Remove hook
if ( retval == false ) then
tab[ idx ][ k ] = nil
end
end
end
--[[---------------------------------------------------------
Console Command
-----------------------------------------------------------]]
function Activate( pl, num, bIsButton )
local key = math.Clamp( tonumber( num ), 0, 256 )
-- Hack. Kinda. Don't call it again until the key has been lifted.
-- When holding down 9 or 3 on the numpad it will repeat. Ignore that.
if ( IsValid( pl ) ) then
pl.keystate = pl.keystate or {}
if ( pl.keystate[ key ] ) then return end
pl.keystate[ key ] = true
end
button_fired = bIsButton
FireImpulse( keys_in[ key ], pl, nil )
-- And fire `all`
FireImpulse( keys_in[ key ], pl, 0 )
button_fired = false
end
--[[---------------------------------------------------------
Console Command
-----------------------------------------------------------]]
function Deactivate( pl, num, bIsButton )
local key = math.Clamp( tonumber( num ) , 0, 256 )
if ( IsValid( pl ) ) then
pl.keystate = pl.keystate or {}
pl.keystate[ key ] = nil
end
button_fired = bIsButton
FireImpulse( keys_out[ key ], pl, nil )
-- And fire `all`
FireImpulse( keys_out[ key ], pl, 0 )
button_fired = false
end
--[[---------------------------------------------------------
Toggle
-----------------------------------------------------------]]
function Toggle( pl, num )
local key = math.Clamp( tonumber( num ), 0, 256 )
pl.keystate = pl.keystate or {}
if ( pl.keystate[ key ] ) then return Deactivate( pl, num ) end
return Activate( pl, num )
end
--[[---------------------------------------------------------
Adds an impulse to to the specified table
-----------------------------------------------------------]]
local function AddImpulse( table, ply, impulse )
lastindex = lastindex + 1
local idx = GetPlayerIndex( ply )
table[ idx ] = table[ idx ] or {}
table[ idx ][ lastindex ] = impulse
return lastindex
end
--[[---------------------------------------------------------
Adds a function to call when ply presses key
-----------------------------------------------------------]]
function OnDown( ply, key, name, ... )
if ( !key || key ~= key ) then ErrorNoHaltWithStack( "bad argument #2 to 'numpad.OnDown' (number expected, got ", type( key ), ")" ) return end
keys_in[ key ] = keys_in[ key ] or {}
local impulse = {}
impulse.name = name
impulse.arg = { ... }
table.insert( impulse.arg, GetPlayerIndex( ply ) )
return AddImpulse( keys_in[ key ], ply, impulse )
end
--[[---------------------------------------------------------
Adds a function to call when ply releases key
-----------------------------------------------------------]]
function OnUp( ply, key, name, ... )
if ( !key || key ~= key ) then ErrorNoHaltWithStack( "bad argument #2 to 'numpad.OnUp' (number expected, got ", type( key ), ")" ) return end
keys_out[ key ] = keys_out[ key ] or {}
local impulse = {}
impulse.name = name
impulse.arg = { ... }
table.insert( impulse.arg, GetPlayerIndex( ply ) )
return AddImpulse( keys_out[ key ], ply, impulse )
end
--[[---------------------------------------------------------
Removes key from tab (by unique index)
-----------------------------------------------------------]]
local function RemoveFromKeyTable( tab, idx )
for k, v_key in pairs( tab ) do
for k_, v_player in pairs( v_key ) do
if ( v_player[ idx ] != nil ) then
v_player[ idx ] = nil
end
end
end
end
--[[---------------------------------------------------------
Removes key (by unique index)
-----------------------------------------------------------]]
function Remove( idx )
if ( !idx ) then return end
RemoveFromKeyTable( keys_out, idx )
RemoveFromKeyTable( keys_in, idx )
end
--[[---------------------------------------------------------
Register a function
-----------------------------------------------------------]]
function Register( name, func )
functions[ name ] = func
end

1192
lua/includes/modules/pk_pills.lua Normal file
View File

File diff suppressed because it is too large Load Diff

467
lua/includes/modules/player_manager.lua Normal file
View File

@@ -0,0 +1,467 @@
--[[
| 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/
--]]
local ErrorNoHalt = ErrorNoHalt
local baseclass = baseclass
local setmetatable = setmetatable
local SERVER = SERVER
local string = string
local table = table
local util = util
module( "player_manager" )
-- Stores a table of valid player models
local ModelList = {}
local ModelListRev = {}
local HandNames = {}
--[[---------------------------------------------------------
Utility to add models to the acceptable model list
-----------------------------------------------------------]]
function AddValidModel( name, model )
ModelList[ name ] = model
ModelListRev[ string.lower( model ) ] = name
end
--
-- Valid hands
--
function AddValidHands( name, model, skin, body, matchBodySkin )
HandNames[ name ] = { model = model, skin = skin or 0, body = body or "0000000", matchBodySkin = matchBodySkin or false }
end
--[[---------------------------------------------------------
Return list of all valid player models
-----------------------------------------------------------]]
function AllValidModels( )
return ModelList
end
--[[---------------------------------------------------------
Translate the simple name of a model
into the full model name
-----------------------------------------------------------]]
function TranslatePlayerModel( name )
if ( ModelList[ name ] != nil ) then
return ModelList[ name ]
end
return "models/player/kleiner.mdl"
end
-- Translate from the full model name to simple model name
function TranslateToPlayerModelName( model )
model = string.lower( model )
if ( ModelListRev[ model ] != nil ) then
return ModelListRev[ model ]
end
return "kleiner"
end
--
-- Translate hands based on model
--
function TranslatePlayerHands( name )
if ( HandNames[ name ] != nil ) then
return HandNames[ name ]
end
return { model = "models/weapons/c_arms_citizen.mdl", skin = 0, body = "100000000" }
end
--[[---------------------------------------------------------
Compile a list of valid player models
-----------------------------------------------------------]]
AddValidModel( "alyx", "models/player/alyx.mdl" )
AddValidHands( "alyx", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "barney", "models/player/barney.mdl" )
AddValidHands( "barney", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "breen", "models/player/breen.mdl" )
AddValidHands( "breen", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "charple", "models/player/charple.mdl" )
AddValidHands( "charple", "models/weapons/c_arms_citizen.mdl", 2, "0000000" )
AddValidModel( "chell", "models/player/p2_chell.mdl" )
AddValidHands( "chell", "models/weapons/c_arms_chell.mdl", 0, "0000000" )
AddValidModel( "corpse", "models/player/corpse1.mdl" )
AddValidHands( "corpse", "models/weapons/c_arms_citizen.mdl", 2, "0000000" )
AddValidModel( "combine", "models/player/combine_soldier.mdl" )
AddValidHands( "combine", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "combineprison", "models/player/combine_soldier_prisonguard.mdl" )
AddValidHands( "combineprison", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "combineelite", "models/player/combine_super_soldier.mdl" )
AddValidHands( "combineelite", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "eli", "models/player/eli.mdl" )
AddValidHands( "eli", "models/weapons/c_arms_citizen.mdl", 1, "0000000" )
AddValidModel( "gman", "models/player/gman_high.mdl" )
AddValidHands( "gman", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "kleiner", "models/player/kleiner.mdl" )
AddValidHands( "kleiner", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "monk", "models/player/monk.mdl" )
AddValidHands( "monk", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "mossman", "models/player/mossman.mdl" )
AddValidHands( "mossman", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "mossmanarctic", "models/player/mossman_arctic.mdl" )
AddValidHands( "mossmanarctic", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "odessa", "models/player/odessa.mdl" )
AddValidHands( "odessa", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "police", "models/player/police.mdl" )
AddValidHands( "police", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "policefem", "models/player/police_fem.mdl" )
AddValidHands( "policefem", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "magnusson", "models/player/magnusson.mdl" )
AddValidHands( "magnusson", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "stripped", "models/player/soldier_stripped.mdl" )
AddValidHands( "stripped", "models/weapons/c_arms_hev.mdl", 2, "0000000" )
AddValidModel( "zombie", "models/player/zombie_classic.mdl" )
AddValidHands( "zombie", "models/weapons/c_arms_citizen.mdl", 2, "0000000" )
AddValidModel( "zombiefast", "models/player/zombie_fast.mdl" )
AddValidHands( "zombiefast", "models/weapons/c_arms_citizen.mdl", 2, "0000000" )
AddValidModel( "female01", "models/player/Group01/female_01.mdl" )
AddValidHands( "female01", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "female02", "models/player/Group01/female_02.mdl" )
AddValidHands( "female02", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "female03", "models/player/Group01/female_03.mdl" )
AddValidHands( "female03", "models/weapons/c_arms_citizen.mdl", 1, "0000000" )
AddValidModel( "female04", "models/player/Group01/female_04.mdl" )
AddValidHands( "female04", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "female05", "models/player/Group01/female_05.mdl" )
AddValidHands( "female05", "models/weapons/c_arms_citizen.mdl", 1, "0000000" )
AddValidModel( "female06", "models/player/Group01/female_06.mdl" )
AddValidHands( "female06", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "female07", "models/player/Group03/female_01.mdl" )
AddValidHands( "female07", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "female08", "models/player/Group03/female_02.mdl" )
AddValidHands( "female08", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "female09", "models/player/Group03/female_03.mdl" )
AddValidHands( "female09", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "female10", "models/player/Group03/female_04.mdl" )
AddValidHands( "female10", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "female11", "models/player/Group03/female_05.mdl" )
AddValidHands( "female11", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "female12", "models/player/Group03/female_06.mdl" )
AddValidHands( "female12", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male01", "models/player/Group01/male_01.mdl" )
AddValidHands( "male01", "models/weapons/c_arms_citizen.mdl", 1, "0000000" )
AddValidModel( "male02", "models/player/Group01/male_02.mdl" )
AddValidHands( "male02", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male03", "models/player/Group01/male_03.mdl" )
AddValidHands( "male03", "models/weapons/c_arms_citizen.mdl", 1, "0000000" )
AddValidModel( "male04", "models/player/Group01/male_04.mdl" )
AddValidHands( "male04", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male05", "models/player/Group01/male_05.mdl" )
AddValidHands( "male05", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male06", "models/player/Group01/male_06.mdl" )
AddValidHands( "male06", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male07", "models/player/Group01/male_07.mdl" )
AddValidHands( "male07", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male08", "models/player/Group01/male_08.mdl" )
AddValidHands( "male08", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male09", "models/player/Group01/male_09.mdl" )
AddValidHands( "male09", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "male10", "models/player/Group03/male_01.mdl" )
AddValidHands( "male10", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "male11", "models/player/Group03/male_02.mdl" )
AddValidHands( "male11", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male12", "models/player/Group03/male_03.mdl" )
AddValidHands( "male12", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "male13", "models/player/Group03/male_04.mdl" )
AddValidHands( "male13", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male14", "models/player/Group03/male_05.mdl" )
AddValidHands( "male14", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male15", "models/player/Group03/male_06.mdl" )
AddValidHands( "male15", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male16", "models/player/Group03/male_07.mdl" )
AddValidHands( "male16", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male17", "models/player/Group03/male_08.mdl" )
AddValidHands( "male17", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "male18", "models/player/Group03/male_09.mdl" )
AddValidHands( "male18", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "medic01", "models/player/Group03m/male_01.mdl" )
AddValidHands( "medic01", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "medic02", "models/player/Group03m/male_02.mdl" )
AddValidHands( "medic02", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic03", "models/player/Group03m/male_03.mdl" )
AddValidHands( "medic03", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "medic04", "models/player/Group03m/male_04.mdl" )
AddValidHands( "medic04", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic05", "models/player/Group03m/male_05.mdl" )
AddValidHands( "medic05", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "medic06", "models/player/Group03m/male_06.mdl" )
AddValidHands( "medic06", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic07", "models/player/Group03m/male_07.mdl" )
AddValidHands( "medic07", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic08", "models/player/Group03m/male_08.mdl" )
AddValidHands( "medic08", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic09", "models/player/Group03m/male_09.mdl" )
AddValidHands( "medic09", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic10", "models/player/Group03m/female_01.mdl" )
AddValidHands( "medic10", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "medic11", "models/player/Group03m/female_02.mdl" )
AddValidHands( "medic11", "models/weapons/c_arms_refugee.mdl", 0, "0000000" )
AddValidModel( "medic12", "models/player/Group03m/female_03.mdl" )
AddValidHands( "medic12", "models/weapons/c_arms_refugee.mdl", 1, "0000000" )
AddValidModel( "medic13", "models/player/Group03m/female_04.mdl" )
AddValidHands( "medic13", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "medic14", "models/player/Group03m/female_05.mdl" )
AddValidHands( "medic14", "models/weapons/c_arms_refugee.mdl", 0, "0100000" )
AddValidModel( "medic15", "models/player/Group03m/female_06.mdl" )
AddValidHands( "medic15", "models/weapons/c_arms_refugee.mdl", 1, "0100000" )
AddValidModel( "refugee01", "models/player/Group02/male_02.mdl" )
AddValidHands( "refugee01", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "refugee02", "models/player/Group02/male_04.mdl" )
AddValidHands( "refugee02", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "refugee03", "models/player/Group02/male_06.mdl" )
AddValidHands( "refugee03", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "refugee04", "models/player/Group02/male_08.mdl" )
AddValidHands( "refugee04", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
--
-- Game specific player models! (EP2, CSS, DOD)
-- Moving them to here since we're now shipping all required files / fallbacks
AddValidModel( "magnusson", "models/player/magnusson.mdl" )
AddValidHands( "magnusson", "models/weapons/c_arms_citizen.mdl", 0, "0000000" )
AddValidModel( "skeleton", "models/player/skeleton.mdl" )
AddValidHands( "skeleton", "models/weapons/c_arms_citizen.mdl", 2, "0000000" )
AddValidModel( "zombine", "models/player/zombie_soldier.mdl" )
AddValidHands( "zombine", "models/weapons/c_arms_combine.mdl", 0, "0000000" )
AddValidModel( "hostage01", "models/player/hostage/hostage_01.mdl" )
AddValidModel( "hostage02", "models/player/hostage/hostage_02.mdl" )
AddValidModel( "hostage03", "models/player/hostage/hostage_03.mdl" )
AddValidModel( "hostage04", "models/player/hostage/hostage_04.mdl" )
AddValidModel( "css_arctic", "models/player/arctic.mdl" )
AddValidHands( "css_arctic", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_gasmask", "models/player/gasmask.mdl" )
AddValidHands( "css_gasmask", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_guerilla", "models/player/guerilla.mdl" )
AddValidHands( "css_guerilla", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_leet", "models/player/leet.mdl" )
AddValidHands( "css_leet", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_phoenix", "models/player/phoenix.mdl" )
AddValidHands( "css_phoenix", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_riot", "models/player/riot.mdl" )
AddValidHands( "css_riot", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_swat", "models/player/swat.mdl" )
AddValidHands( "css_swat", "models/weapons/c_arms_cstrike.mdl", 0, "10000000" )
AddValidModel( "css_urban", "models/player/urban.mdl" )
AddValidHands( "css_urban", "models/weapons/c_arms_cstrike.mdl", 7, "10000000" )
AddValidModel( "dod_german", "models/player/dod_german.mdl" )
AddValidHands( "dod_german", "models/weapons/c_arms_dod.mdl", 0, "10000000" )
AddValidModel( "dod_american", "models/player/dod_american.mdl" )
AddValidHands( "dod_american", "models/weapons/c_arms_dod.mdl", 1, "10000000" )
--
-- Player Class Stuff
--
local Type = {}
function GetPlayerClasses()
return table.Copy( Type )
end
local function LookupPlayerClass( ply )
local id = ply:GetClassID()
if ( id == 0 ) then return end
--
-- Check the cache
--
local plyClass = ply.m_CurrentPlayerClass
if ( plyClass && plyClass.Player == ply ) then
if ( plyClass.ClassID == id && plyClass.Func ) then return plyClass end -- current class is still good, behave normally
if ( plyClass.ClassChanged ) then plyClass:ClassChanged() end -- the class id changed, remove the old class
end
--
-- No class, lets create one
--
local classname = util.NetworkIDToString( id )
if ( !classname ) then return end
--
-- Get that type. Fail if we don't have the type.
--
local t = Type[ classname ]
if ( !t ) then return end
local newClass = {
Player = ply,
ClassID = id,
Func = function() end
}
setmetatable( newClass, { __index = t } )
ply.m_CurrentPlayerClass = newClass
-- TODO: We probably want to reset previous DTVar stuff on the player
newClass.Player:InstallDataTable()
newClass:SetupDataTables()
newClass:Init()
return newClass
end
function RegisterClass( name, tab, base )
Type[ name ] = tab
--
-- If we have a base method then hook
-- it up in the meta table
--
if ( base ) then
if ( !Type[ name ] ) then ErrorNoHalt( "RegisterClass - deriving " .. name .. " from unknown class " .. base .. "!\n" ) end
setmetatable( Type[ name ], { __index = Type[ base ] } )
end
if ( SERVER ) then
util.AddNetworkString( name )
end
--
-- drive methods cooperate with the baseclass system
-- /lua/includes/modules/baseclass.lua
--
baseclass.Set( name, Type[ name ] )
end
function SetPlayerClass( ply, classname )
if ( !Type[ classname ] ) then ErrorNoHalt( "SetPlayerClass - attempt to use unknown player class " .. classname .. "!\n" ) end
local id = util.NetworkStringToID( classname )
ply:SetClassID( id )
-- Initialize the player class so the datatable and everything is set up
-- This probably could be done better
LookupPlayerClass( ply )
end
function GetPlayerClass( ply )
local id = ply:GetClassID()
if ( id == 0 ) then return end
return util.NetworkIDToString( id )
end
function GetPlayerClassTable( ply )
local id = ply:GetClassID()
if ( id == 0 ) then return end
local ct = Type[ util.NetworkIDToString( id ) ]
if ( !ct ) then return end
return table.Copy( ct )
end
function ClearPlayerClass( ply )
ply:SetClassID( 0 )
end
function RunClass( ply, funcname, ... )
local class = LookupPlayerClass( ply )
if ( !class ) then return end
local func = class[ funcname ]
if ( !func ) then ErrorNoHalt( "Function " .. funcname .. " not found on player class!\n" ) return end
return func( class, ... )
end
--
-- Should be called on spawn automatically to set the variables below
-- This is called in the base gamemode :PlayerSpawn function
--
function OnPlayerSpawn( ply, transiton )
local class = LookupPlayerClass( ply )
if ( !class ) then return end
ply:SetSlowWalkSpeed( class.SlowWalkSpeed )
ply:SetWalkSpeed( class.WalkSpeed )
ply:SetRunSpeed( class.RunSpeed )
ply:SetCrouchedWalkSpeed( class.CrouchedWalkSpeed )
ply:SetDuckSpeed( class.DuckSpeed )
ply:SetUnDuckSpeed( class.UnDuckSpeed )
ply:SetJumpPower( class.JumpPower )
ply:AllowFlashlight( class.CanUseFlashlight )
ply:ShouldDropWeapon( class.DropWeaponOnDie )
ply:SetNoCollideWithTeammates( class.TeammateNoCollide )
ply:SetAvoidPlayers( class.AvoidPlayers )
if ( !transiton ) then
ply:SetMaxHealth( class.MaxHealth )
ply:SetMaxArmor( class.MaxArmor )
ply:SetHealth( class.StartHealth )
ply:SetArmor( class.StartArmor )
end
end

23
lua/includes/modules/playerload.lua Normal file
View File

@@ -0,0 +1,23 @@
--[[
| 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/
--]]
local loadQueue = {}
hook.Add( "PlayerInitialSpawn", "GM_FullLoadQueue", function( ply )
loadQueue[ply] = true
end )
hook.Add( "SetupMove", "GM_FullLoadInit", function( ply, _, cmd )
if not loadQueue[ply] then return end
if cmd:IsForced() then return end
loadQueue[ply] = nil
hook.Run( "PlayerFullLoad", ply )
end )

415
lua/includes/modules/pon.lua Normal file
View File

@@ -0,0 +1,415 @@
--[[
| 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/
--]]
--[[
DEVELOPMENTAL VERSION;
VERSION 1.2.2
Copyright thelastpenguin™
You may use this for any purpose as long as:
- You don't remove this copyright notice.
- You don't claim this to be your own.
- You properly credit the author, thelastpenguin™, if you publish your work based on (and/or using) this.
If you modify the code for any purpose, the above still applies to the modified code.
The author is not held responsible for any damages incured from the use of pon, you use it at your own risk.
DATA TYPES SUPPORTED:
- tables - k,v - pointers
- strings - k,v - pointers
- numbers - k,v
- booleans- k,v
- Vectors - k,v
- Angles - k,v
- Entities- k,v
- Players - k,v
- PhysObj - k,v
CHANGE LOG
V 1.1.0
- Added Vehicle, NPC, NextBot, Player, Weapon
V 1.2.0
- Added custom handling for k,v tables without any array component.
V 1.2.1
- fixed deserialization bug.
THANKS TO...
- VERCAS for the inspiration.
]]
local pon = {};
_G.pon = pon;
local type, count = type, table.Count ;
local tonumber = tonumber ;
local format = string.format;
do
local type, count = type, table.Count ;
local tonumber = tonumber ;
local format = string.format;
local encode = {};
local tryCache ;
local cacheSize = 0;
encode['table'] = function( self, tbl, output, cache )
if( cache[ tbl ] )then
output[ #output + 1 ] = format('(%x)', cache[tbl] );
return ;
else
cacheSize = cacheSize + 1;
cache[ tbl ] = cacheSize;
end
local first = next(tbl, nil)
local predictedNumeric = 1
local lastKey = nil
-- starts with a numeric dealio
if first == 1 then
output[#output + 1] = '{'
for k,v in next, tbl do
if k == predictedNumeric then
predictedNumeric = predictedNumeric + 1
local tv = type(v)
if tv == 'string' then
local pid = cache[v]
if pid then
output[#output + 1] = format('(%x)', pid)
else
cacheSize = cacheSize + 1
cache[v] = cacheSize
self.string(self, v, output, cache)
end
else
self[tv](self, v, output, cache)
end
else
break
end
end
predictedNumeric = predictedNumeric - 1
else
predictedNumeric = nil
end
if predictedNumeric == nil then
output[#output + 1] = '[' -- no array component
else
output[#output + 1] = '~' -- array component came first so shit needs to happen
end
for k, v in next, tbl, predictedNumeric do
local tk, tv = type(k), type(v)
-- WRITE KEY
if tk == 'string' then
local pid = cache[ k ];
if( pid )then
output[ #output + 1 ] = format('(%x)', pid );
else
cacheSize = cacheSize + 1;
cache[ k ] = cacheSize;
self.string( self, k, output, cache );
end
else
self[tk](self, k, output, cache)
end
-- WRITE VALUE
if( tv == 'string' )then
local pid = cache[ v ];
if( pid )then
output[ #output + 1 ] = format('(%x)', pid );
else
cacheSize = cacheSize + 1;
cache[ v ] = cacheSize;
self.string( self, v, output, cache );
end
else
self[ tv ]( self, v, output, cache );
end
end
output[#output + 1] = '}'
end
-- ENCODE STRING
local gsub = string.gsub ;
encode['string'] = function( self, str, output )
--if tryCache( str, output ) then return end
local estr, count = gsub( str, ";", "\\;");
if( count == 0 )then
output[ #output + 1 ] = '\''..str..';';
else
output[ #output + 1 ] = '"'..estr..'";';
end
end
-- ENCODE NUMBER
encode['number'] = function( self, num, output )
if num%1 == 0 then
if num < 0 then
output[ #output + 1 ] = format( 'x%x;', -num );
else
output[ #output + 1 ] = format('X%x;', num );
end
else
output[ #output + 1 ] = tonumber( num )..';';
end
end
-- ENCODE BOOLEAN
encode['boolean'] = function( self, val, output )
output[ #output + 1 ] = val and 't' or 'f'
end
-- ENCODE VECTOR
encode['Vector'] = function( self, val, output )
output[ #output + 1 ] = ('v'..val.x..','..val.y)..(','..val.z..';');
end
-- ENCODE ANGLE
encode['Angle'] = function( self, val, output )
output[ #output + 1 ] = ('a'..val.p..','..val.y)..(','..val.r..';');
end
encode['Entity'] = function( self, val, output )
local entIndex = val == NULL and '#' or val:EntIndex();
output[ #output + 1] = 'E'..entIndex..';';
end
encode['Player'] = encode['Entity'];
encode['Vehicle'] = encode['Entity'];
encode['Weapon'] = encode['Entity'];
encode['NPC'] = encode['Entity'];
encode['NextBot'] = encode['Entity'];
encode['PhysObj'] = encode['Entity'];
encode['nil'] = function( _, _, output )
output[ #output + 1 ] = '?;';
end
setmetatable( encode, {
__index = function( self, key )
local val = rawget( self, key );
if val then return val end
ErrorNoHalt('Type: '..key..' can not be encoded. Encoded as as pass-over value.');
return rawget( self, 'nil' );
end
});
do
local empty, concat = table.Empty, table.concat ;
function pon.encode( tbl )
local output = {};
cacheSize = 0;
encode[ 'table' ]( encode, tbl, output, {} );
local res = concat( output );
return res;
end
end
end
do
local tonumber = tonumber ;
local find, sub, gsub, Explode = string.find, string.sub, string.gsub, string.Explode ;
local Vector, Angle, Entity = Vector, Angle, Entity ;
local decode = {};
decode['{'] = function( self, index, str, cache )
local cur = {};
cache[ #cache + 1 ] = cur;
local k, v, tk, tv = 1, nil, nil, nil;
while( true )do
tv = sub( str, index, index );
if( not tv or tv == '~' )then
index = index + 1;
break ;
end
if( tv == '}' )then
return index + 1, cur;
end
-- READ THE VALUE
index = index + 1;
index, v = self[ tv ]( self, index, str, cache );
cur[ k ] = v;
k = k + 1;
end
while( true )do
tk = sub( str, index, index );
if( not tk or tk == '}' )then
index = index + 1;
break ;
end
-- READ THE KEY
index = index + 1;
index, k = self[ tk ]( self, index, str, cache );
-- READ THE VALUE
tv = sub( str, index, index );
index = index + 1;
index, v = self[ tv ]( self, index, str, cache );
cur[ k ] = v;
end
return index, cur;
end
decode['['] = function( self, index, str, cache )
local cur = {};
cache[ #cache + 1 ] = cur;
local k, v, tk, tv = 1, nil, nil, nil;
while( true )do
tk = sub( str, index, index );
if( not tk or tk == '}' )then
index = index + 1;
break ;
end
-- READ THE KEY
index = index + 1;
index, k = self[ tk ]( self, index, str, cache );
if not k then continue end
-- READ THE VALUE
tv = sub( str, index, index );
index = index + 1;
if not self[tv] then
print('did not find type: '..tv)
end
index, v = self[ tv ]( self, index, str, cache );
cur[ k ] = v;
end
return index, cur;
end
-- STRING
decode['"'] = function( self, index, str, cache )
local finish = find( str, '";', index, true );
local res = gsub( sub( str, index, finish - 1 ), '\\;', ';' );
index = finish + 2;
cache[ #cache + 1 ] = res;
return index, res;
end
-- STRING NO ESCAPING NEEDED
decode['\''] = function( self, index, str, cache )
local finish = find( str, ';', index, true );
local res = sub( str, index, finish - 1 )
index = finish + 1;
cache[ #cache + 1 ] = res;
return index, res;
end
-- NUMBER
decode['n'] = function( self, index, str, cache )
index = index - 1;
local finish = find( str, ';', index, true );
local num = tonumber( sub( str, index, finish - 1 ) );
index = finish + 1;
return index, num;
end
decode['0'] = decode['n'];
decode['1'] = decode['n'];
decode['2'] = decode['n'];
decode['3'] = decode['n'];
decode['4'] = decode['n'];
decode['5'] = decode['n'];
decode['6'] = decode['n'];
decode['7'] = decode['n'];
decode['8'] = decode['n'];
decode['9'] = decode['n'];
decode['-'] = decode['n'];
-- positive hex
decode['X'] = function( self, index, str, cache )
local finish = find( str, ';', index, true );
local num = tonumber( sub( str, index, finish - 1), 16 );
index = finish + 1;
return index, num;
end
-- negative hex
decode['x'] = function( self, index, str, cache )
local finish = find( str, ';', index, true );
local num = -tonumber( sub( str, index, finish - 1), 16 );
index = finish + 1;
return index, num;
end
-- POINTER
decode['('] = function( self, index, str, cache )
local finish = find( str, ')', index, true );
local num = tonumber( sub( str, index, finish - 1), 16 );
index = finish + 1;
return index, cache[ num ];
end
-- BOOLEAN. ONE DATA TYPE FOR YES, ANOTHER FOR NO.
decode[ 't' ] = function( self, index )
return index, true;
end
decode[ 'f' ] = function( self, index )
return index, false;
end
-- VECTOR
decode[ 'v' ] = function( self, index, str, cache )
local finish = find( str, ';', index, true );
local vecStr = sub( str, index, finish - 1 );
index = finish + 1;
local segs = Explode( ',', vecStr, false );
return index, Vector( segs[1], segs[2], segs[3] );
end
-- ANGLE
decode[ 'a' ] = function( self, index, str, cache )
local finish = find( str, ';', index, true );
local angStr = sub( str, index, finish - 1 );
index = finish + 1;
local segs = Explode( ',', angStr, false );
return index, Angle( tonumber( segs[1] ), tonumber( segs[2] ), tonumber( segs[3] ) );
end
-- ENTITY
decode[ 'E' ] = function( self, index, str, cache )
local finish = find( str, ';', index, true );
local num = sub( str, index, finish - 1 );
index = finish + 1;
return index, num == '#' and NULL or Entity( num );
end
-- PLAYER
decode[ 'P' ] = decode[ 'E' ];
-- NIL
decode[ '?' ] = function( _, index )
return index + 1, nil;
end
function pon.decode( data )
local _, res = decode[ sub( data, 1, 1 ) ]( decode, 2, data, {});
return res;
end
end

65
lua/includes/modules/ppp_includes/console.lua Normal file
View File

@@ -0,0 +1,65 @@
--[[
| 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/
--]]
AddCSLuaFile()
-- Convars
pk_pills.convars = {}
-- Admin vars
pk_pills.convars.admin_restrict = CreateConVar("pk_pill_admin_restrict", game.IsDedicated() and 1 or 0, FCVAR_REPLICATED + FCVAR_NOTIFY, "Restrict morphing to admins.")
pk_pills.convars.admin_anyweapons = CreateConVar("pk_pill_admin_anyweapons", 0, FCVAR_REPLICATED, "Allow use of any weapon when morphed.")
pk_pills.convars.preserve = CreateConVar("pk_pill_preserve", 0, FCVAR_REPLICATED, "Makes player spit out pills when they unmorph or die.")
-- Client vars
if CLIENT then
pk_pills.convars.cl_thirdperson = CreateClientConVar("pk_pill_cl_thirdperson", 1)
pk_pills.convars.cl_hidehud = CreateClientConVar("pk_pill_cl_hidehud", 0)
end
-- Admin var setter command.
if SERVER then
local function admin_set(ply, cmd, args)
if not ply then
print("If you are using the server console, you should set the variables directly!")
return
end
if not ply:IsSuperAdmin() then
ply:PrintMessage(HUD_PRINTCONSOLE, "You must be a super admin to use this command.")
return
end
local var = args[1]
local value = args[2]
if not var then
if ply then
ply:PrintMessage(HUD_PRINTCONSOLE, "Please supply a valid convar name. Do not include 'pk_pill_admin_'.")
end
return
elseif not ConVarExists("pk_pill_admin_" .. var) then
ply:PrintMessage(HUD_PRINTCONSOLE, "Convar 'pk_pill_admin_" .. var .. "' does not exist. Please supply a valid convar name. Do not include 'pk_pill_admin_'.")
return
end
if not value then
ply:PrintMessage(HUD_PRINTCONSOLE, "Please supply a value to set the convar to.")
return
end
RunConsoleCommand("pk_pill_admin_" .. var, value)
end
concommand.Add("pk_pill_admin_set", admin_set, nil, "Helper command for setting Morph Mod admin convars. Available to super admins.")
end

19
lua/includes/modules/ppp_includes/join_prompt.lua Normal file
View File

@@ -0,0 +1,19 @@
--[[
| 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/
--]]
AddCSLuaFile()
if CLIENT then
function pk_pills.join_prompt(name, addr)
Derma_Query("Are you sure you want to join '" .. name .. "'?\nWARNING: You will exit your current game!", "", "Yes", function()
LocalPlayer():ConCommand("connect " .. addr)
end, "No")
end
end

66
lua/includes/modules/ppp_includes/locomotion.lua Normal file
View File

@@ -0,0 +1,66 @@
--[[
| 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/
--]]
AddCSLuaFile()
custom={}
if SERVER then
function custom.meleeEx(ply,ent,tbl)
-- Small edit that can use a custom dmgType and doesn't force an animation, for morphs with multiple attacks in a single anim
if !ply:IsOnGround() then return end
timer.Simple(tbl.delay,function() if !IsValid(ent) then return end
if !IsValid(ent) then return end
if ply:TraceHullAttack(ply:EyePos(), ply:EyePos()+ply:EyeAngles():Forward()*tbl.range,
Vector(-10,-10,-10),Vector(10,10,10),tbl.dmg,tbl.dmgType,0.1,true) then
ent:PillSound("melee_hit")
else
ent:PillSound("melee_miss")
end
end)
end
function custom.LocoAnim(ply,ent,anim)
-- New function that uses animation locomotion (ish)
if !ply:IsOnGround() then return end
ent:PillAnim(anim,true)
local seq,dur = ent:GetPuppet():LookupSequence(ent.formTable.anims.default[anim])
local ga,gb,gc = ent:GetPuppet():GetSequenceMovement(seq,0,1)
if not ga then print("ga failed") return end -- The animation has no locomotion or it's invalid or we failed in some other way.
local pos = ply:GetPos()
local trin = {}
trin.maxs = Vector(16, 16, 72)
trin.mins = Vector(-16, -16, 0)
trin.start = ply:EyePos()
trin.endpos = gb
trin.filter = {ply, ent, ent:GetPuppet()}
local trout = util.TraceHull(trin)
local gd_prev = ent:GetPuppet():GetCycle()
for i=1,dur*1000 do
timer.Simple(0.001*i,function()
if !IsValid(ent) then return end
if ply:GetPos() == trout.HitPos then return end -- Avoid going through walls if possible chief.
local gd_cur = ent:GetPuppet():GetCycle()
local ga2,gb2,gc2 = ent:GetPuppet():GetSequenceMovement(seq,gd_prev,gd_cur)
gd_prev = gd_cur
if not ga2 then print("ga failed") return end
if gd_cur==0 then return end
if !util.IsInWorld(ply:LocalToWorld(gb2)) then return end
ply:SetPos(ply:LocalToWorld(gb2))
ply:SetAngles(ply:LocalToWorldAngles(gc2))
end)
end
end
end

103
lua/includes/modules/ppp_includes/nocompat.lua Normal file
View File

@@ -0,0 +1,103 @@
--[[
| 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/
--]]
-- Does what compat.lua used to without being so aggressive about compatability.
-- If another addon wants to break things, IT CAN!
AddCSLuaFile()
-- This will let us use the noclip key to exit morphs,
-- while letting other mods that disable noclip do their thing.
if CLIENT then
local noclip_btns = {}
for i = KEY_FIRST, BUTTON_CODE_LAST do
if input.LookupKeyBinding(i) == "noclip" then
table.insert(noclip_btns, i)
end
end
hook.Add("CreateMove", "momo_exit_check", function()
if vgui.GetKeyboardFocus() == nil and not gui.IsGameUIVisible() then
for _, key in pairs(noclip_btns) do
if input.WasKeyPressed(key) then
timer.Simple(0, function()
RunConsoleCommand("pk_pill_restore")
end)
break
end
end
end
end)
end
-- Still dont let people noclip while morphed
hook.Add("PlayerNoClip", "momo_block_noclip", function(ply)
if IsValid(pk_pills.getMappedEnt(ply)) then return false end
end)
-- Them hooks
hook.Add("CalcView", "momo_calcview", function(ply, pos, ang, fov, nearZ, farZ)
local ent = pk_pills.getMappedEnt(LocalPlayer())
if IsValid(ent) and ply:GetViewEntity() == ply then
local startpos
if ent.formTable.type == "phys" then
startpos = ent:LocalToWorld(ent.formTable.camera and ent.formTable.camera.offset or Vector(0, 0, 0))
else
startpos = pos
end
if pk_pills.convars.cl_thirdperson:GetBool() then
local dist
if ent.formTable.type == "phys" and ent.formTable.camera and ent.formTable.camera.distFromSize then
dist = ent:BoundingRadius() * 5
else
dist = ent.formTable.camera and ent.formTable.camera.dist or 100
end
local underslung = ent.formTable.camera and ent.formTable.camera.underslung
local offset = LocalToWorld(Vector(-dist, 0, underslung and -dist / 5 or dist / 5), Angle(0, 0, 0), Vector(0, 0, 0), ang)
local tr = util.TraceHull({
start = startpos,
endpos = startpos + offset,
filter = ent.camTraceFilter,
mins = Vector(-5, -5, -5),
maxs = Vector(5, 5, 5),
mask = MASK_VISIBLE
})
local view = {}
view.origin = tr.HitPos
view.angles = ang
view.fov = fov
view.drawviewer = true
--[[else
local view = {}
view.origin = startpos
view.angles = ang
view.fov = fov
return view]]
return view
end
end
end)
--[[
hook.Add("CalcViewModelView","momo_calcviewmodel",function(wep,vm,oldPos,oldAng,pos,ang)
local ent = pk_pills.getMappedEnt(LocalPlayer())
local ply = wep.Owner
if (IsValid(ent) and ply:GetViewEntity()==ply and pk_pills.convars.cl_thirdperson:GetBool()) then
return oldPos+oldAng:Forward()*-1000,ang
end
end)]]

70
lua/includes/modules/ppp_includes/restricted.lua Normal file
View File

@@ -0,0 +1,70 @@
--[[
| 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/
--]]
AddCSLuaFile()
local restricted
if SERVER then
util.AddNetworkString("pk_pill_restricted")
-- rename old file
if file.Exists("pill_config/restrictions.txt", "DATA") then
file.Rename("pill_config/restrictions.txt", "pill_config/restricted.txt")
end
-- load restrictions
restricted = {}
for k, v in pairs(("\n"):Explode(file.Read("pill_config/restricted.txt") or "")) do
restricted[v] = true
end
pk_pills._restricted = restricted
concommand.Add("pk_pill_restrict", function(ply, cmd, args, str)
if not ply:IsSuperAdmin() then return end
local pill = args[1]
local a = args[2]
if a == "on" then
restricted[pill] = true
elseif a == "off" then
restricted[pill] = false
end
local write_str = ""
for k, v in pairs(restricted) do
if write_str ~= "" then
write_str = write_str .. "\n"
end
write_str = write_str .. k
end
file.Write("pill_config/restricted.txt", write_str)
net.Start("pk_pill_restricted")
net.WriteTable(restricted)
net.Broadcast()
end)
hook.Add("PlayerInitialSpawn", "pk_pill_transmit_restricted", function(ply)
net.Start("pk_pill_restricted")
net.WriteTable(restricted)
net.Send(ply)
end)
else
pk_pills._restricted = {}
net.Receive("pk_pill_restricted", function(len, pl)
restricted = net.ReadTable()
pk_pills._restricted = restricted
end)
end

206
lua/includes/modules/ppp_includes/sv_ai.lua Normal file
View File

@@ -0,0 +1,206 @@
--[[
| 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/
--]]
local npc_sides = {
npc_advisor = "hl_combine",
npc_alyx = "default",
npc_antlion = "hl_antlion",
npc_antlion_grub = "hl_antlion",
npc_antlionguard = "hl_antlion",
npc_barnacle = "wild",
npc_antlion_worker = "hl_antlion",
npc_barney = "default",
npc_breen = "hl_combine",
npc_citizen = "default",
npc_clawscanner = "hl_combine",
npc_combine_camera = "hl_combine",
npc_combine_s = "hl_combine",
npc_combinedropship = "hl_combine",
npc_combinegunship = "hl_combine",
npc_crow = "harmless",
npc_cscanner = "hl_combine",
npc_dog = "default",
npc_eli = "default",
npc_fastzombie = "hl_zombie",
npc_fastzombie_torso = "hl_zombie",
npc_fisherman = "default",
npc_gman = "harmless",
npc_headcrab = "hl_zombie",
npc_headcrab_black = "hl_zombie",
npc_headcrab_fast = "hl_zombie",
npc_helicopter = "hl_combine",
npc_hunter = "hl_combine",
npc_ichthyosaur = "wild",
npc_kleiner = "default",
npc_magnusson = "default",
npc_manhack = "hl_combine",
npc_metropolice = "hl_combine",
npc_monk = "default",
npc_mossman = "default",
npc_pigeon = "harmless",
npc_poisonzombie = "hl_zombie",
npc_rollermine = "hl_combine",
npc_seagull = "harmless",
npc_sniper = "hl_combine",
npc_stalker = "hl_combine",
npc_strider = "hl_combine",
npc_turret_ceiling = "hl_combine",
npc_turret_floor = "hl_combine",
npc_turret_ground = "hl_combine",
npc_vortigaunt = "default",
npc_zombie = "hl_zombie",
npc_zombie_torso = "hl_zombie",
npc_zombine = "hl_zombie"
}
local side_relationships = {
default = {
hl_combine = D_HT,
hl_antlion = D_HT,
hl_zombie = D_HT,
hl_infiltrator = D_LI
},
hl_combine = {
default = D_HT,
hl_antlion = D_HT,
hl_zombie = D_HT,
hl_infiltrator = D_LI
},
hl_antlion = {
default = D_HT,
hl_combine = D_HT,
hl_zombie = D_HT,
hl_infiltrator = D_HT
},
hl_zombie = {
default = D_HT,
hl_combine = D_HT,
hl_antlion = D_HT,
hl_infiltrator = D_HT
}
}
local team_map = {}
--AI TEAMS
function setAiTeam(ent, side)
if ent:IsPlayer() and side == "default" then
team_map[ent] = nil
else
team_map[ent] = side
end
for _, npc in pairs(ents.FindByClass("npc_*")) do
if npc == ent or not npc.AddEntityRelationship or not IsValid(npc) then continue end
local otherSide = getAiTeam(npc)
--if otherSide==nil then continue end
if side == otherSide or side == "harmless" then
npc:AddEntityRelationship(ent, D_LI, 99)
elseif side == "wild" then
npc:AddEntityRelationship(ent, D_HT, 99)
else
local relationship = (side_relationships[otherSide] or {})[side]
if relationship then
npc:AddEntityRelationship(ent, relationship, 99)
end
end
if ent:IsNPC() then
if otherSide == side or otherSide == "harmless" then
ent:AddEntityRelationship(npc, D_LI, 99)
elseif side == "wild" then
ent:AddEntityRelationship(npc, D_HT, 99)
else
local relationship = (side_relationships[side] or {})[otherSide]
if relationship then
ent:AddEntityRelationship(npc, relationship, 99)
end
end
end
end
if ent:IsNPC() then
for _, ply in pairs(player.GetAll()) do
local otherSide = getAiTeam(ply)
if otherSide == side or otherSide == "harmless" then
ent:AddEntityRelationship(ply, D_LI, 99)
elseif side == "wild" then
ent:AddEntityRelationship(ply, D_HT, 99)
else
local relationship = (side_relationships[side] or {})[otherSide]
if relationship then
ent:AddEntityRelationship(ply, relationship, 99)
end
end
end
end
if not ent:IsPlayer() and ent:GetTable() then
ent:CallOnRemove("ClearAiTeam", function()
team_map[ent] = nil
end)
end
end
function getAiTeam(ent)
local side
side = team_map[ent]
if side then return side end
side = npc_sides[ent:GetClass()]
if side then return side end
--if ent.formTable then side=ent.formTable.side end
--if side then return side end
if ent:IsPlayer() then return "default" end
return "harmless"
end
hook.Add("OnEntityCreated", "pk_pill_npc_spawn", function(npc)
if npc.AddEntityRelationship then
local otherSide = getAiTeam(npc)
if otherSide == nil then return end
for ent, side in pairs(team_map) do
if not IsValid(ent) then continue end --This really shouldn't happen. But it does. ):
if side == otherSide or side == "harmless" then
npc:AddEntityRelationship(ent, D_LI, 99)
elseif side == "wild" then
npc:AddEntityRelationship(ent, D_HT, 99)
else
local relationship = (side_relationships[otherSide] or {})[side]
if relationship == nil then continue end
npc:AddEntityRelationship(ent, relationship, 99)
end
--TODO CHECK AGAINST ALL NPCS, NOT JUST ONES IN THIS LIST -- THIS MIGHT ACTUALLY BE RIGHT
if ent:IsNPC() then
if otherSide == side or otherSide == "harmless" then
ent:AddEntityRelationship(npc, D_LI, 99)
elseif side == "wild" then
ent:AddEntityRelationship(npc, D_HT, 99)
else
local relationship = (side_relationships[side] or {})[otherSide]
if relationship == nil then continue end
ent:AddEntityRelationship(npc, relationship, 99)
end
end
end
end
end)
hook.Add("PlayerDisconnected", "pk_pill_clearplayerteam", function(ply)
team_map[ply] = nil
end)

35
lua/includes/modules/ppp_includes/tf2lib.lua Normal file
View File

@@ -0,0 +1,35 @@
--[[
| 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/
--]]
AddCSLuaFile()
--Speed modifications done by tf2 weapons, effects, etc.
hook.Add("SetupMove", "momo_tf2_movemod", function(ply, mv, cmd)
local speedmod = 1
--Check weapons
for _, wep in pairs(ply:GetWeapons()) do
if wep.momo_SpeedMod then
local thismod = wep:momo_SpeedMod()
if thismod then
speedmod = speedmod * thismod
end
end
end
--Change the speed
if speedmod ~= 1 then
local basevel = mv:GetVelocity()
basevel.x = basevel.x * speedmod
basevel.y = basevel.y * speedmod
mv:SetVelocity(basevel)
end
end)

132
lua/includes/modules/ppp_includes/util.lua Normal file
View File

@@ -0,0 +1,132 @@
--[[
| 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/
--]]
AddCSLuaFile()
helpers = {}
function helpers.makeList(str, n1, n2)
if not n2 then
n2 = n1
n1 = 1
end
local lst = {}
for i = n1, n2 do
table.insert(lst, string.Replace(str, "#", tostring(i)))
end
return lst
end
common = {}
if SERVER then
function common.shoot(ply, ent, tbl)
local aim = ent.formTable.aim
if ent.formTable.canAim and not ent.formTable.canAim(ply, ent) then return end
if aim.usesSecondaryEnt and not IsValid(ent:GetPillAimEnt()) then return end
local aimEnt = aim.usesSecondaryEnt and ent:GetPillAimEnt() or (ent.formTable.type == "ply" and ent:GetPuppet()) or ent
local start
if aim.attachment then
start = aimEnt:GetAttachment(aimEnt:LookupAttachment(aim.attachment))
elseif aim.offset then
local a = ply:EyeAngles()
a.p = 0
start = {
Pos = ply:EyePos() + a:Forward() * aim.offset,
Ang = ply:EyeAngles()
}
else
return
end
local bullet = {}
-- PLZ FIX
if aim.overrideStart then
bullet.Src = ent:LocalToWorld(aim.overrideStart)
else
if not start then return end
bullet.Src = start.Pos
end
--debugoverlay.Sphere(bullet.Src,10,1, Color(0,0,255), true)
--[[bullet.Src = start.Pos]]
bullet.Attacker = ply
if aim.simple then
bullet.Dir = ply:EyeAngles():Forward()
else
bullet.Dir = start.Ang:Forward()
end
if tbl.spread then
bullet.Spread = Vector(tbl.spread, tbl.spread, 0)
end
bullet.Num = tbl.num
bullet.Damage = tbl.damage
bullet.Force = tbl.force
bullet.Tracer = tbl.tracer and not aim.fixTracers and 1 or 0
if aim.fixTracers then
bullet.Callback = function(_ply, tr, dmg)
local ed = EffectData()
ed:SetStart(tr.StartPos)
ed:SetOrigin(tr.HitPos)
ed:SetScale(5000)
util.Effect(tbl.tracer, ed)
end
else
bullet.TracerName = tbl.tracer
end
--[[bullet.Callback=function(ply,tr,dmg)
if tr.HitPos then
debugoverlay.Sphere(tr.HitPos,50,5, Color(0,255,0), true)
end
end]]
aimEnt:FireBullets(bullet)
--Animation
if tbl.anim then
ent:PillAnim(tbl.anim, true)
end
--Sound
ent:PillSound("shoot", true)
end
function common.melee(ply, ent, tbl)
if not ply:IsOnGround() then return end
if tbl.animCount then
ent:PillAnim("melee" .. math.random(tbl.animCount), true)
else
ent:PillAnim("melee", true)
end
ent:PillGesture("melee")
ent:PillSound("melee")
timer.Simple(tbl.delay, function()
if not IsValid(ent) then return end
if ply:TraceHullAttack(ply:EyePos(), ply:EyePos() + ply:EyeAngles():Forward() * tbl.range, Vector(-10, -10, -10), Vector(10, 10, 10), tbl.dmg, DMG_SLASH, 1, true) then
ent:PillSound("melee_hit")
else
ent:PillSound("melee_miss")
end
end)
end
end

201
lua/includes/modules/ppp_includes/vox.lua Normal file
View File

@@ -0,0 +1,201 @@
--[[
| 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/
--]]
AddCSLuaFile()
local voxPacks = {}
function registerVox(name, tbl)
voxPacks[name] = tbl
end
if CLIENT then
concommand.Add("pk_pill_voxmenu", function(ply, cmd, args, str)
if pk_pills.getMappedEnt(ply) and pk_pills.getMappedEnt(ply).formTable.voxSet then
local voiceMenuSrc = [[
<head>
<style>
body {-webkit-user-select: none; font-family: Arial;}
h1 {margin: 10px 0; background-color: #CCF; border: 1px solid #00A; color: #00A; width: 150px; font-style:italic;}
.close {background: red; border: 2px solid black; float: right;}
.close:hover {background: #F44;}
#input {height: 55px; background: white; border: 1px solid gray; overflow-x: auto; white-space: nowrap; font-size: 30px;}
#picker {background: #CCC; border: 1px solid black; margin-top: 10px; overflow-y: auto; position: relative;}
#picker>div {margin: 4px;cursor: pointer;}
#cursor {display: inline-block; width: 0; height: 26px; border-left: 2px solid black; margin-top: 2px;}
#picker>div:hover {background-color: #FFC; border: 1px solid #AA0;}
#selected {background-color: #CCF; border: 1px solid #00A;}
.highlight {color: red; font-weight: bold;}
</style>
</head>
<body>
<button class="close" onclick="console.log('RUNLUA:SELF:Remove()')">X</button>
<h1>PillVox</h1>
<div id="input"></div>
<div id="picker"></div>
</body>
<script>
var picker = document.getElementById('picker')
var input = document.getElementById('input')
picker.style.height= (window.innerHeight-150)+"px"
var phrases = []
var txt=""
var cPos=0
function htmlSafe(str) {
return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/ /g,'&nbsp;')
}
function render(renderpicker) {
//search
var begin = txt.substr(0,cPos)
var end = txt.substr(cPos)
input.innerHTML=htmlSafe(begin)+"<div id='cursor'></div>"+htmlSafe(end)
input.scrollLeft = input.scrollWidth
//picker
if (renderpicker) {
var out=[]
if (txt=="") {
for (var i in phrases) {
out.push("<div data-phrase='"+phrases[i]+"' onclick='pick(this)'>"+phrases[i]+"</div>")
}
} else {
var tosort=[]
for (var i in phrases) {
var phrase = phrases[i]
var fragments = txt.trim().split(' ')
var score=0
var highlighted = phrase.replace(new RegExp(fragments.join("|"),"gi"), function(matched) {
score+=matched.length
return "<span class='highlight'>"+matched+"</span>"
})
score+=1/phrase.length
if (highlighted!=phrase) {
tosort.push({html: ("<div data-phrase='"+phrase.replace(/'/g,"&#39;")+"' onclick='pick(this)'>"+highlighted+"</div>"), score: score})
}
}
tosort.sort(function(a,b) {return b.score-a.score})
for (j in tosort) {
out.push(tosort[j].html)
}
}
picker.innerHTML=out.join('')
var selectedElement = picker.childNodes[0]
if (selectedElement) {
selectedElement.setAttribute("id","selected")
selected = selectedElement.dataset.phrase
}
}
}
function pick(e) {
console.log('RUNLUA:RunConsoleCommand("pk_pill_vox","'+e.dataset.phrase+'")')
console.log('RUNLUA:SELF:Remove()')
}
function init(t) {
for (k in t) {
phrases.push(k)
}
phrases.sort()
render(true)
}
//cursor
setInterval(function() {
var cursor = document.getElementById('cursor')
if (cursor.style.visibility=='visible')
cursor.style.visibility='hidden'
else
cursor.style.visibility='visible'
},400)
document.addEventListener('keydown', function(event) {
var key = event.keyCode
if (key>=65 && key<=90) {
txt=txt.substr(0,cPos)+String.fromCharCode(key+32)+txt.substr(cPos)
cPos++
render(true)
} else if (key>=48 && key<=57 || key==32) {
txt=txt.substr(0,cPos)+String.fromCharCode(key)+txt.substr(cPos)
cPos++
render(true)
} else if (key==8) {
if (cPos>0) {
txt=txt.substr(0,cPos-1)+txt.substr(cPos)
cPos--
}
render(true)
} else if (key==13) {
var selectedElement = document.getElementById('selected')
if (selectedElement) {
pick(selectedElement)
} else {
console.log('RUNLUA:SELF:Remove()')
}
render()
} else if (key==37) {
if (cPos>0) {
cPos--
}
render()
} else if (key==39) {
if (cPos<txt.length) {
cPos++
}
render()
} else if (key==38) {
var selectedElement = document.getElementById('selected')
if (selectedElement.previousSibling) {
selectedElement.removeAttribute('id')
selectedElement=selectedElement.previousSibling
selectedElement.setAttribute("id","selected")
picker.scrollTop = selectedElement.offsetTop-225
}
} else if (key==40) {
var selectedElement = document.getElementById('selected')
if (selectedElement.nextSibling) {
selectedElement.removeAttribute('id')
selectedElement=selectedElement.nextSibling
selectedElement.setAttribute("id","selected")
picker.scrollTop = selectedElement.offsetTop-225
}
}
})
</script>
]]
local html = vgui.Create("DHTML", panel)
html:SetPos(10, ScrH() / 6)
html:SetSize(300, ScrH() * (2 / 3))
html:SetAllowLua(true)
html:SetHTML(voiceMenuSrc)
html:RunJavascript("init(" .. util.TableToJSON(voxPacks[pk_pills.getMappedEnt(ply).formTable.voxSet]) .. ")")
html:MakePopup()
end
end)
else
concommand.Add("pk_pill_vox", function(ply, cmd, args, str)
if pk_pills.getMappedEnt(ply) and pk_pills.getMappedEnt(ply).formTable.voxSet then
pk_pills.getMappedEnt(ply):EmitSound(voxPacks[pk_pills.getMappedEnt(ply).formTable.voxSet][args[1]])
end
end)
end

101
lua/includes/modules/presets.lua Normal file
View File

@@ -0,0 +1,101 @@
--[[
| 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/
--]]
module( "presets", package.seeall )
-- TODO: A function to check/replace invalid characters for filenames!
local Presets = LoadPresets()
function GetTable( presetname )
if ( !presetname ) then return end
presetname = presetname:Trim()
if ( presetname == "" ) then return end
Presets[ presetname ] = Presets[ presetname ] or {}
return Presets[ presetname ]
end
function Exists( presetname, strName )
if ( !presetname || !strName ) then return false end
presetname = presetname:Trim()
strName = strName:Trim()
if ( presetname == "" || strName == "" ) then return false end
if ( !Presets[ presetname ] || !Presets[ presetname ][ strName ] ) then return false end
return true
end
function Add( presetname, strName, pTable )
if ( !presetname || !strName ) then return end
presetname = presetname:Trim()
strName = strName:Trim()
if ( presetname == "" || strName == "" ) then return end
Presets[ presetname ] = Presets[ presetname ] or {}
Presets[ presetname ][ strName ] = pTable
-- Only save the specific preset group, not ALL of them
SavePresets( { [ presetname ] = Presets[ presetname ] } )
end
function Rename( presetname, strName, strToName )
if ( !presetname || !strName || !strToName || strName == strToName ) then return end
presetname = presetname:Trim()
strName = strName:Trim()
strToName = strToName:Trim()
if ( presetname == "" || strName == "" || strToName == "" || strName == strToName ) then return end
Presets[ presetname ] = Presets[ presetname ] or {}
Presets[ presetname ][ strToName ] = Presets[ presetname ][ strName ]
Presets[ presetname ][ strName ] = nil
-- Only save the specific preset group, not ALL of them
SavePresets( { [ presetname ] = Presets[ presetname ] } )
end
function Remove( presetname, strName )
if ( !presetname || !strName ) then return end
presetname = presetname:Trim()
strName = strName:Trim()
if ( presetname == "" || strName == "" ) then return end
Presets[ presetname ] = Presets[ presetname ] or {}
Presets[ presetname ][ strName ] = nil
-- Only save the specific preset group, not ALL of them
SavePresets( { [ presetname ] = Presets[ presetname ] } )
end
-- Internal helper functions to not copypaste same code
function BadNameAlert()
Derma_Message( "#preset.badname_desc", "#preset.badname_title", "#preset.okay" )
end
function OverwritePresetPrompt( func )
Derma_Query( "#preset.exists_desc", "#preset.exists_title", "#preset.overwrite", func, "#preset.cancel" )
end

264
lua/includes/modules/properties.lua Normal file
View File

@@ -0,0 +1,264 @@
--[[
| 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/
--]]
module( "properties", package.seeall )
local meta = {
MsgStart = function( self )
net.Start( "properties" )
net.WriteString( self.InternalName )
end,
MsgEnd = function( self )
net.SendToServer()
end
}
meta.__index = meta
List = {}
-- .MenuLabel [string] Label to show on opened menu
-- .Filter( ent ) [function] Return true if we should show a menu for this entity
-- .Action( ent ) [function] On menu choice selected
-- .Order [int] The order in which it should be shown on the menu
-- .Receive( len, ply ) [function] A message has been received from the clientside version
function Add( name, tab )
name = name:lower()
tab.InternalName = name
setmetatable( tab, meta )
List[ name ] = tab
end
local function AddToggleOption( data, menu, ent, ply, tr )
if ( !menu.ToggleSpacer ) then
menu.ToggleSpacer = menu:AddSpacer()
menu.ToggleSpacer:SetZPos( 500 )
end
local option = menu:AddOption( data.MenuLabel, function() data:Action( ent, tr ) end )
option:SetChecked( data:Checked( ent, ply ) )
option:SetZPos( 501 )
return option
end
local function AddOption( data, menu, ent, ply, tr )
if ( data.Type == "toggle" ) then return AddToggleOption( data, menu, ent, ply, tr ) end
if ( data.PrependSpacer ) then
menu:AddSpacer()
end
local option = menu:AddOption( data.MenuLabel, function() data:Action( ent, tr ) end )
if ( data.MenuIcon ) then
option:SetImage( data.MenuIcon )
end
if ( data.MenuOpen ) then
data.MenuOpen( data, option, ent, tr )
end
return option
end
function OpenEntityMenu( ent, tr )
local menu = DermaMenu()
for k, v in SortedPairsByMemberValue( List, "Order" ) do
if ( !v.Filter ) then continue end
if ( !v:Filter( ent, LocalPlayer() ) ) then continue end
local option = AddOption( v, menu, ent, LocalPlayer(), tr )
if ( v.OnCreate ) then v:OnCreate( menu, option ) end
end
menu:Open()
end
function OnScreenClick( eyepos, eyevec )
local ent, tr = GetHovered( eyepos, eyevec )
if ( !IsValid( ent ) ) then return end
OpenEntityMenu( ent, tr )
end
-- Use this check in your properties to see if given entity can be affected by it
-- Ideally this should be done automatically for you, but due to how this system was set up, its now impossible
function CanBeTargeted( ent, ply )
if ( !IsValid( ent ) ) then return false end
if ( ent:IsPlayer() ) then return false end
-- Check the range if player object is given
-- This is not perfect, but it is close enough and its definitely better than nothing
if ( IsValid( ply ) ) then
local mins = ent:OBBMins()
local maxs = ent:OBBMaxs()
local maxRange = math.max( math.abs( mins.x ) + maxs.x, math.abs( mins.y ) + maxs.y, math.abs( mins.z ) + maxs.z )
local pos = ent:LocalToWorld( ent:OBBCenter() ) --ent:GetPos()
if ( pos:Distance( ply:GetShootPos() ) > maxRange + 1024 ) then return false end
end
return !( ent:GetPhysicsObjectCount() < 1 && ent:GetSolid() == SOLID_NONE && bit.band( ent:GetSolidFlags(), FSOLID_USE_TRIGGER_BOUNDS ) == 0 && bit.band( ent:GetSolidFlags(), FSOLID_CUSTOMRAYTEST ) == 0 )
end
function GetHovered( eyepos, eyevec )
local ply = LocalPlayer()
local filter = ply:GetViewEntity()
if ( filter == ply ) then
local veh = ply:GetVehicle()
if ( veh:IsValid() && ( !veh:IsVehicle() || !veh:GetThirdPersonMode() ) ) then
-- A dirty hack for prop_vehicle_crane. util.TraceLine returns the vehicle but it hits phys_bone_follower - something that needs looking into
filter = { filter, veh, unpack( ents.FindByClass( "phys_bone_follower" ) ) }
end
end
local trace = util.TraceLine( {
start = eyepos,
endpos = eyepos + eyevec * 1024,
filter = filter
} )
-- Hit COLLISION_GROUP_DEBRIS and stuff
if ( !trace.Hit || !IsValid( trace.Entity ) ) then
trace = util.TraceLine( {
start = eyepos,
endpos = eyepos + eyevec * 1024,
filter = filter,
mask = MASK_ALL
} )
end
if ( !trace.Hit || !IsValid( trace.Entity ) ) then return end
return trace.Entity, trace
end
-- Receives commands from clients
if ( SERVER ) then
util.AddNetworkString( "properties" )
net.Receive( "properties", function( len, client )
if ( !IsValid( client ) ) then return end
local name = net.ReadString()
if ( !name ) then return end
local prop = List[ name ]
if ( !prop ) then return end
if ( !prop.Receive ) then return end
prop:Receive( len, client )
end )
end
if ( CLIENT ) then
local lastEyePos = vector_origin
local function UpdateEyePos()
-- A bit of a hack due to EyePos() being affected by other rendering functions
-- So we cache the value when we know it is the correct value for the frame
lastEyePos = EyePos()
end
hook.Add( "PreDrawHalos", "PropertiesHover", function()
if ( !IsValid( vgui.GetHoveredPanel() ) || !vgui.GetHoveredPanel():IsWorldClicker() ) then return end
UpdateEyePos()
local ent = GetHovered( lastEyePos, LocalPlayer():GetAimVector() )
if ( !IsValid( ent ) ) then return end
local c = Color( 255, 255, 255, 255 )
c.r = 200 + math.sin( RealTime() * 50 ) * 55
c.g = 200 + math.sin( RealTime() * 20 ) * 55
c.b = 200 + math.cos( RealTime() * 60 ) * 55
local t = { ent }
if ( ent.GetActiveWeapon && IsValid( ent:GetActiveWeapon() ) ) then table.insert( t, ent:GetActiveWeapon() ) end
halo.Add( t, c, 2, 2, 2, true, false )
end )
hook.Add( "PreDrawEffects", "PropertiesUpdateEyePos", function()
UpdateEyePos()
end )
hook.Add( "GUIMousePressed", "PropertiesClick", function( code, vector )
if ( !IsValid( vgui.GetHoveredPanel() ) || !vgui.GetHoveredPanel():IsWorldClicker() ) then return end
if ( code == MOUSE_RIGHT && !input.IsButtonDown( MOUSE_LEFT ) ) then
OnScreenClick( lastEyePos, vector )
end
end )
local wasPressed = false
hook.Add( "PreventScreenClicks", "PropertiesPreventClicks", function()
if ( !input.IsButtonDown( MOUSE_RIGHT ) ) then wasPressed = false end
if ( wasPressed && input.IsButtonDown( MOUSE_RIGHT ) && !input.IsButtonDown( MOUSE_LEFT ) ) then return true end
if ( !IsValid( vgui.GetHoveredPanel() ) || !vgui.GetHoveredPanel():IsWorldClicker() ) then return end
local ply = LocalPlayer()
if ( !IsValid( ply ) ) then return end
--
-- Are we pressing the right mouse button?
-- (We check whether we're pressing the left too, to allow for physgun freezes)
--
if ( input.IsButtonDown( MOUSE_RIGHT ) && !input.IsButtonDown( MOUSE_LEFT ) ) then
--
-- Are we hovering an entity? If so, then stomp the action
--
local hovered = GetHovered( lastEyePos, ply:GetAimVector() )
if ( IsValid( hovered ) ) then
wasPressed = true
return true
end
end
end )
end

436
lua/includes/modules/saverestore.lua Normal file
View File

@@ -0,0 +1,436 @@
--[[
| 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/
--]]
local Msg = Msg
local type = type
local pairs = pairs
local gmod = gmod
local table = table
--[[
This module is to help bind the engine's saverestore stuff to Lua.
This is so we can save Lua stuff in the save game file. The entities
should automatically save most of their table contents to the save file.
!!Warning!!: Editing this file may render old saves useless.
You can hook into this system like so
local function MySaveFunction( save )
saverestore.WriteTable( my_table, save )
end
local function MyRestoreFunction( restore )
my_table = saverestore.ReadTable( restore )
end
saverestore.AddSaveHook( "HookNameHere", MySaveFunction )
saverestore.AddRestoreHook( "HookNameHere", MyRestoreFunction )
--]]
module( "saverestore" )
local TYPE_NONE = 0
local TYPE_FLOAT = 1 -- Treat all numbers as floats (they're all the same to Lua)
local TYPE_STRING = 2
local TYPE_ENTITY = 3
local TYPE_VECTOR = 4
local TYPE_TABLE = 5
local TYPE_BOOL = 6
local TYPE_ANGLE = 7
local SaveHooks = {}
local RestoreHooks = {}
local TableRefs = {}
local TableRef = 1
function PreSave()
TableRefs = {}
TableRef = 1
end
function PreRestore()
TableRefs = {}
TableRef = 1
end
--[[---------------------------------------------------------
Name: GetTypeStr
Desc: Given a string returns a TYPE_
-----------------------------------------------------------]]
local function GetTypeStr( name )
if ( name == "function" ) then return TYPE_NONE end
if ( name == "number" ) then return TYPE_FLOAT end
if ( name == "string" ) then return TYPE_STRING end
if ( name == "Entity" ) then return TYPE_ENTITY end
if ( name == "Vehicle" ) then return TYPE_ENTITY end
if ( name == "NPC" ) then return TYPE_ENTITY end
if ( name == "Player" ) then return TYPE_ENTITY end
if ( name == "Weapon" ) then return TYPE_ENTITY end
if ( name == "Vector" ) then return TYPE_VECTOR end
if ( name == "Angle" ) then return TYPE_ANGLE end
if ( name == "table" ) then return TYPE_TABLE end
if ( name == "boolean" ) then return TYPE_BOOL end
-- These aren't saved
if ( name == "ConVar" ) then return TYPE_NONE end
if ( name == "PhysObj" ) then return TYPE_NONE end
-- Bitch about it incase I've forgot to hook a savable type up
Msg( "Can't save unknown type " .. name .. "\n" )
return TYPE_NONE
end
--[[---------------------------------------------------------
Name: GetType
Desc: Given a variable returns a TYPE_
-----------------------------------------------------------]]
local function GetType( var )
return GetTypeStr( type(var) )
end
--[[---------------------------------------------------------
Name: IsWritable
Desc: Returns true if we can save the K/V pair
-----------------------------------------------------------]]
local function IsWritable( k, v )
local itype = GetType( k )
if ( itype == TYPE_NONE ) then return false end
if ( itype == TYPE_STRING && k == "SR_Recursion" ) then return false end
local itype = GetType( v )
if ( itype == TYPE_NONE ) then return false end
return true
end
--[[---------------------------------------------------------
Name: WriteVar
Desc: Writes a single variable to the save
-----------------------------------------------------------]]
function WritableKeysInTable( t )
local i = 0
for k, v in pairs( t ) do
if ( IsWritable( k, v ) ) then
i = i + 1
end
end
return i
end
--[[---------------------------------------------------------
Name: WriteVar
Desc: Writes a single variable to the save
-----------------------------------------------------------]]
function WriteVar( var, save )
local itype = GetType( var )
if ( itype == TYPE_NONE ) then return end
save:StartBlock( type( var ) )
if ( itype == TYPE_FLOAT ) then
save:WriteFloat( var )
elseif ( itype == TYPE_BOOL ) then
save:WriteBool( var )
elseif ( itype == TYPE_STRING ) then
save:WriteString( var )
elseif ( itype == TYPE_ENTITY ) then
save:WriteEntity( var )
elseif ( itype == TYPE_ANGLE ) then
save:WriteAngle( var )
elseif ( itype == TYPE_VECTOR ) then
save:WriteVector( var )
elseif ( itype == TYPE_TABLE ) then
WriteTable( var, save )
else
Msg( "Error! Saving unsupported Type: " .. type( var ) .. "\n" )
end
save:EndBlock()
end
--[[---------------------------------------------------------
Name: ReadVar
Desc: Reads a single variable
-----------------------------------------------------------]]
function ReadVar( restore )
local retval = 0
local typename = restore:StartBlock()
local itype = GetTypeStr( typename )
if ( itype == TYPE_FLOAT ) then
retval = restore:ReadFloat()
elseif ( itype == TYPE_BOOL ) then
retval = restore:ReadBool()
elseif ( itype == TYPE_STRING ) then
retval = restore:ReadString()
elseif ( itype == TYPE_ENTITY ) then
retval = restore:ReadEntity()
elseif ( itype == TYPE_ANGLE ) then
retval = restore:ReadAngle()
elseif ( itype == TYPE_VECTOR ) then
retval = restore:ReadVector()
elseif ( itype == TYPE_TABLE ) then
retval = ReadTable( restore )
else
Msg( "Error! Loading unsupported Type: " .. typename .. "\n" )
end
restore:EndBlock()
return retval
end
--[[---------------------------------------------------------
Name: WriteTable
Desc: Writes a table to the save
-----------------------------------------------------------]]
function WriteTable( tab, save )
-- Write a blank table (because read will be expecting one)
if ( tab == nil ) then
save:StartBlock( "Table" )
save:EndBlock()
end
-- We have already saved this table
if ( TableRefs[ tab ] ) then
save:StartBlock( "TableRef" )
save:WriteInt( TableRefs[ tab ] )
save:EndBlock()
return
end
TableRefs[ tab ] = TableRef
save:StartBlock( "Table" )
local iCount = WritableKeysInTable( tab )
save:WriteInt( TableRef )
TableRef = TableRef + 1
save:WriteInt( iCount )
for k, v in pairs( tab ) do
if ( IsWritable( k, v ) ) then
WriteVar( k, save )
WriteVar( v, save )
end
end
save:EndBlock()
end
--[[---------------------------------------------------------
Name: ReadTable
Desc: Assumes a table is waiting to be read, returns a table
-----------------------------------------------------------]]
function ReadTable( restore )
local name = restore:StartBlock()
local tab = {}
if ( name == "TableRef" ) then
local ref = restore:ReadInt()
if ( !TableRefs[ ref ] ) then
TableRefs[ ref ] = {}
return
end
tab = TableRefs[ ref ]
else
local iRef = restore:ReadInt()
local iCount = restore:ReadInt()
if ( TableRefs[ iRef ] ) then
tab = TableRefs[ iRef ]
end
for i = 0, iCount - 1 do
local k = ReadVar( restore )
local v = ReadVar( restore )
tab[ k ] = v
end
TableRefs[ iRef ] = tab
end
restore:EndBlock()
return tab
end
--[[---------------------------------------------------------
Name: SaveEntity
Desc: Called by the engine for each entity
-----------------------------------------------------------]]
function SaveEntity( ent, save )
save:StartBlock( "EntityTable" )
WriteTable( ent:GetTable(), save )
save:EndBlock()
end
--[[---------------------------------------------------------
Name: LoadEntity
Desc: Called by the engine for each entity
-----------------------------------------------------------]]
function LoadEntity( ent, restore )
local EntTable = ent:GetTable()
local name = restore:StartBlock()
if ( name == "EntityTable" ) then
table.Merge( EntTable, ReadTable( restore ) )
end
restore:EndBlock()
ent:SetTable( EntTable )
end
--[[---------------------------------------------------------
Name: AddSaveHook
Desc: Adds a hook enabling something to save something..
-----------------------------------------------------------]]
function AddSaveHook( name, func )
local h = {}
h.Name = name
h.Func = func
SaveHooks[ name ] = h
end
--[[---------------------------------------------------------
Name: AddRestoreHook
Desc: Adds a hook enabling something to restore something..
-----------------------------------------------------------]]
function AddRestoreHook( name, func )
local h = {}
h.Name = name
h.Func = func
RestoreHooks[ name ] = h
end
--[[---------------------------------------------------------
Name: SaveGlobal
Desc: Should save any Lua stuff that isn't entity based.
-----------------------------------------------------------]]
function SaveGlobal( save )
save:StartBlock( "GameMode" )
WriteTable( gmod.GetGamemode(), save )
save:EndBlock()
for k, v in pairs( SaveHooks ) do
save:StartBlock( v.Name )
v.Func( save )
save:EndBlock()
end
end
--[[---------------------------------------------------------
Name: LoadGlobal
Desc: ...
-----------------------------------------------------------]]
function LoadGlobal( restore )
local name = restore:StartBlock()
if ( name == "GameMode" ) then
table.Merge( gmod.GetGamemode(), ReadTable( restore ) )
end
restore:EndBlock()
while ( name != "EndGlobal" ) do
name = restore:StartBlock()
local tab = RestoreHooks[ name ]
if ( tab ) then
tab.Func( restore )
end
restore:EndBlock()
end
end

288
lua/includes/modules/scripted_ents.lua Normal file
View File

@@ -0,0 +1,288 @@
--[[
| 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: scripted_ents
Desc: Scripted Entity factory
-----------------------------------------------------------]]
module( "scripted_ents", package.seeall )
local Aliases = {}
local SEntList = {}
local BaseClasses = {}
BaseClasses[ "anim" ] = "base_anim"
BaseClasses[ "point" ] = "base_point"
BaseClasses[ "brush" ] = "base_brush"
BaseClasses[ "filter" ] = "base_filter"
--[[---------------------------------------------------------
Name: TableInherit( t, base )
Desc: Copies any missing data from base to t
-----------------------------------------------------------]]
local function TableInherit( t, base )
for k, v in pairs( base ) do
if ( t[ k ] == nil ) then
t[ k ] = v
elseif ( k != "BaseClass" && istable( t[ k ] ) && istable( v ) ) then
TableInherit( t[ k ], v )
end
end
t[ "BaseClass" ] = base
return t
end
--[[---------------------------------------------------------
Name: IsBasedOn( name, base )
Desc: Checks if name is based on base
-----------------------------------------------------------]]
function IsBasedOn( name, base )
local t = GetStored( name )
if not t then return false end
if t.Base == name then return false end
if t.Base == base then return true end
return IsBasedOn( t.Base, base )
end
function Register( t, name )
if ( hook.Run( "PreRegisterSENT", t, name ) == false ) then return end
if ( isstring( t.ClassNameOverride ) ) then name = t.ClassNameOverride end
local Base = t.Base
if ( !Base ) then Base = BaseClasses[ t.Type ] end
local old = SEntList[ name ]
local tab = {}
tab.type = t.Type
tab.t = t
tab.isBaseType = true
tab.Base = Base
tab.t.ClassName = name
if ( !Base ) then
Msg( "WARNING: Scripted entity " .. name .. " has an invalid base entity!\n" )
end
SEntList[ name ] = tab
-- Allow all SENTS to be duplicated, unless specified
if ( !t.DisableDuplicator ) then
duplicator.Allow( name )
end
--
-- If we're reloading this entity class
-- then refresh all the existing entities.
--
if ( old != nil ) then
--
-- For each entity using this class
--
for _, entity in ipairs( ents.FindByClass( name ) ) do
--
-- Replace the contents with this entity table
--
table.Merge( entity, tab.t )
--
-- Call OnReloaded hook (if it has one)
--
if ( entity.OnReloaded ) then
entity:OnReloaded()
end
end
-- Update entity table of entities that are based on this entity
for _, e in ipairs( ents.GetAll() ) do
if ( IsBasedOn( e:GetClass(), name ) ) then
table.Merge( e, Get( e:GetClass() ) )
if ( e.OnReloaded ) then
e:OnReloaded()
end
end
end
end
if ( !t.Spawnable ) then return end
list.Set( "SpawnableEntities", name, {
-- Required information
PrintName = t.PrintName,
ClassName = name,
Category = t.Category,
-- Optional information
NormalOffset = t.NormalOffset,
DropToFloor = t.DropToFloor,
Author = t.Author,
AdminOnly = t.AdminOnly,
Information = t.Information,
ScriptedEntityType = t.ScriptedEntityType,
IconOverride = t.IconOverride
} )
end
--
-- All scripts have been loaded...
--
function OnLoaded()
--
-- Once all the scripts are loaded we can set up the baseclass
-- - we have to wait until they're all setup because load order
-- could cause some entities to load before their bases!
--
for k, v in pairs( SEntList ) do
baseclass.Set( k, Get( k ) )
end
end
function Get( name, retval )
-- Do we have an alias?
if ( Aliases[ name ] ) then
name = Aliases[ name ]
end
if ( SEntList[ name ] == nil ) then return nil end
-- Create/copy a new table
local retval = retval or {}
for k, v in pairs( SEntList[ name ].t ) do
if ( istable( v ) ) then
retval[ k ] = table.Copy( v )
else
retval[ k ] = v
end
end
-- Derive from base class
if ( SEntList[ name ].Base != name ) then
local base = Get( SEntList[ name ].Base )
if ( !base ) then
Msg("ERROR: Trying to derive entity " .. tostring( name ) .. " from non existant entity " .. tostring( SEntList[ name ].Base ) .. "!\n" )
else
retval = TableInherit( retval, base )
end
end
return retval
end
function GetType( name )
for k, v in pairs( BaseClasses ) do
if ( name == v ) then return k end
end
local ent = SEntList[ name ]
if ( ent == nil ) then return nil end
if ( ent.type ) then
return ent.type
end
if ( ent.Base ) then
return GetType( ent.Base )
end
return nil
end
--[[---------------------------------------------------------
Name: GetStored( string )
Desc: Gets the REAL sent table, not a copy
-----------------------------------------------------------]]
function GetStored( name )
return SEntList[ name ]
end
--[[---------------------------------------------------------
Name: GetList( string )
Desc: Get a list of all the registered SENTs
-----------------------------------------------------------]]
function GetList()
local result = {}
for k,v in pairs( SEntList ) do
result[ k ] = v
end
return result
end
function GetSpawnable()
local result = {}
for k, v in pairs( SEntList ) do
local tab = v.t
if ( tab.Spawnable ) then
table.insert( result, tab )
end
end
return result
end
function Alias( From, To )
Aliases[ From ] = To
end
function GetMember( entity_name, membername )
if ( !entity_name ) then return end
local ent = SEntList[ entity_name ]
if ( !ent ) then return end
local member = ent.t[ membername ]
if ( member != nil ) then return member end
-- If our base is the same as us - don't infinite loop!
if ( entity_name == ent.Base ) then return end
return GetMember( ent.Base, membername )
end

59
lua/includes/modules/search.lua Normal file
View File

@@ -0,0 +1,59 @@
--[[
| 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/
--]]
module( "search", package.seeall )
local Providers = {}
function AddProvider( func, id )
local prov = {
func = func,
}
if ( id ) then
Providers[ id ] = prov
else
table.insert( Providers, prov )
end
end
function GetResults( str, types, maxResults )
if ( !maxResults || maxResults < 1 ) then maxResults = 1024 end
local str = str:lower()
if ( str == "" ) then return {} end
local results = {}
for k, v in pairs( Providers ) do
if ( isstring( types ) ) then
if ( types != k ) then continue end
elseif ( istable( types ) ) then
if ( !table.HasValue( types, k ) ) then continue end
end
local tbl = v.func( str )
for _, e in pairs( tbl ) do
table.insert( results, e )
end
if ( #results >= maxResults ) then break end
end
-- Todo. Sort, weighted?
return results
end

98
lua/includes/modules/sound_vj_track.lua Normal file
View File

@@ -0,0 +1,98 @@
--[[
| 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/
--]]
/*--------------------------------------------------
=============== VJ Theme Soundtrack Module ===============
*** Copyright (c) 2012-2023 by DrVrej, All rights reserved. ***
No parts of this code or any of its contents may be reproduced, copied, modified or adapted,
without the prior written consent of the author, unless otherwise indicated for stand-alone materials.
INFO: Thanks to Orion for creating the original code
--------------------------------------------------*/
//AddCSLuaFile()
module("sound_vj_track",package.seeall)
//if SERVER then return end
//print("The Module is running!")
//if CLIENT then
local MetatableMusic = {}
MetatableMusic.__index = MetatableMusic
MUSIC_CHANNEL_INDEX = {[1] = {CurTrack = NULL, CurTrackName = "!"}}
---------------------------------------------------------------------------------------------------------------------------------------------
AddChannel = function()
MUSIC_CHANNEL_INDEX[#MUSIC_CHANNEL_INDEX+1] = {CurTrack = NULL, CurTrackName = "!"}
return MUSIC_CHANNEL_INDEX[#MUSIC_CHANNEL_INDEX+1]
end
---------------------------------------------------------------------------------------------------------------------------------------------
GetChannel = function(index)
return MUSIC_CHANNEL_INDEX[index] or Error("WARNING! VJ SOUNDTRACK CHANNEL DOES NOT EXIST: "..index) or Error("INVALID VJ SOUNDTRACK INPUT!")
end
---------------------------------------------------------------------------------------------------------------------------------------------
Add = function(name,path,dur)
MetatableMusic[name] = {Path = path, Duration = dur}
end
---------------------------------------------------------------------------------------------------------------------------------------------
Get = function(name)
return MetatableMusic[name]
end
---------------------------------------------------------------------------------------------------------------------------------------------
GetCurrentTrack = function(chn)
return GetChannel(chn).CurTrack
end
---------------------------------------------------------------------------------------------------------------------------------------------
SetCurrentTrack = function(chn,csp,name)
GetChannel(chn).CurTrack = csp
GetChannel(chn).CurTrackName = name
end
---------------------------------------------------------------------------------------------------------------------------------------------
GetCurrentTrackName = function(chn)
return GetChannel(chn).CurTrackName
end
---------------------------------------------------------------------------------------------------------------------------------------------
Play = function(chn,sound_vj_track,soundlevel)
if not sound_vj_track then return print("VJ Soundtrack wasn't able to find any sound to play!") end
if istable(sound_vj_track) then
if #sound_vj_track < 1 then return print("VJ Soundtrack didn't play any track since the table is empty!") end -- If the table is empty then end it
sound_vj_track = sound_vj_track[math.random(1,#sound_vj_track)]
end
local CSoundPatch = CreateSound(LocalPlayer(),Get(sound_vj_track).Path)
CSoundPatch:Play()
CSoundPatch:SetSoundLevel(soundlevel) -- Play the track globally!
if (GetCurrentTrack(chn) ~= NULL) && IsPlaying(chn) then
//Stop(chn)
end
SetCurrentTrack(chn,CSoundPatch,sound_vj_track)
GetChannel(chn).bFaded = false
print("Current VJ Soundtrack track is "..sound_vj_track.." in channel "..chn)
//print("Current VJ Soundtrack track in channel "..chn.." = "..sound_vj_track)
end
---------------------------------------------------------------------------------------------------------------------------------------------
IsPlaying = function(chn)
return (GetCurrentTrack(chn) ~= NULL) && GetCurrentTrack(chn):IsPlaying() && GetChannel(chn).bFaded == false
end
---------------------------------------------------------------------------------------------------------------------------------------------
Stop = function(chn)
if IsPlaying(chn) then
GetCurrentTrack(chn):Stop()
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
FadeOut = function(chn,tm)
local tm = tm or 2 -- If no number is set then just fadeout in 2 seconds
if IsPlaying(chn) then
GetCurrentTrack(chn):FadeOut(tm)
GetChannel(chn).bFaded = true
end
end
---------------------------------------------------------------------------------------------------------------------------------------------
Duration = function(chn)
if (not chn) or (chn == nil) or (chn == NULL) then return end
if GetCurrentTrackName(chn) == "!" then return end
return MetatableMusic[GetCurrentTrackName(chn)].Duration
end
//end

316
lua/includes/modules/spawnmenu.lua Normal file
View File

@@ -0,0 +1,316 @@
--[[
| 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/
--]]
local spawnmenu_engine = spawnmenu
module( "spawnmenu", package.seeall )
local g_ToolMenu = {}
local CreationMenus = {}
local PropTable = {}
local PropTableCustom = {}
local ActiveToolPanel = nil
local ActiveSpawnlistID = 1000
--[[---------------------------------------------------------
Tool Tabs
-----------------------------------------------------------]]
function SetActiveControlPanel( pnl )
ActiveToolPanel = pnl
end
function ActiveControlPanel()
return ActiveToolPanel
end
function GetTools()
return g_ToolMenu
end
function GetToolMenu( name, label, icon )
--
-- This is a dirty hack so that Main stays at the front of the tabs.
--
if ( name == "Main" ) then name = "AAAAAAA_Main" end
label = label or name
icon = icon or "icon16/wrench.png"
for k, v in ipairs( g_ToolMenu ) do
if ( v.Name == name ) then return v.Items end
end
local NewMenu = { Name = name, Items = {}, Label = label, Icon = icon }
table.insert( g_ToolMenu, NewMenu )
--
-- Order the tabs by NAME
--
table.SortByMember( g_ToolMenu, "Name", true )
return NewMenu.Items
end
function ClearToolMenus()
g_ToolMenu = {}
end
function AddToolTab( strName, strLabel, Icon )
GetToolMenu( strName, strLabel, Icon )
end
function SwitchToolTab( id )
local Tab = g_SpawnMenu:GetToolMenu():GetToolPanel( id )
if ( !IsValid( Tab ) or !IsValid( Tab.PropertySheetTab ) ) then return end
Tab.PropertySheetTab:DoClick()
end
function ActivateToolPanel( tabId, ctrlPnl, toolName )
local Tab = g_SpawnMenu:GetToolMenu():GetToolPanel( tabId )
if ( !IsValid( Tab ) ) then return end
spawnmenu.SetActiveControlPanel( ctrlPnl )
if ( ctrlPnl ) then
Tab:SetActive( ctrlPnl )
end
SwitchToolTab( tabId )
if ( toolName && Tab.SetActiveToolText ) then
Tab:SetActiveToolText( toolName )
end
end
-- While technically tool class names CAN be duplicate, it normally should never happen.
function ActivateTool( strName, noCommand )
-- I really don't like this triple loop
for tab, v in ipairs( g_ToolMenu ) do
for _, items in pairs( v.Items ) do
for _, item in pairs( items ) do
if ( istable( item ) && item.ItemName && item.ItemName == strName ) then
if ( !noCommand && item.Command && string.len( item.Command ) > 1 ) then
RunConsoleCommand( unpack( string.Explode( " ", item.Command ) ) )
end
local cp = controlpanel.Get( strName )
if ( !cp:GetInitialized() ) then
cp:FillViaTable( { Text = item.Text, ControlPanelBuildFunction = item.CPanelFunction } )
end
ActivateToolPanel( tab, cp, strName )
return
end
end
end
end
end
function AddToolCategory( tab, RealName, PrintName )
local Menu = GetToolMenu( tab )
-- Does this category already exist?
for k, v in ipairs( Menu ) do
if ( v.Text == PrintName ) then return end
if ( v.ItemName == RealName ) then return end
end
table.insert( Menu, { Text = PrintName, ItemName = RealName } )
end
function AddToolMenuOption( tab, category, itemname, text, command, controls, cpanelfunction, TheTable )
local Menu = GetToolMenu( tab )
local CategoryTable = nil
for k, v in ipairs( Menu ) do
if ( v.ItemName && v.ItemName == category ) then CategoryTable = v break end
end
-- No table found.. lets create one
if ( !CategoryTable ) then
CategoryTable = { Text = "#" .. category, ItemName = category }
table.insert( Menu, CategoryTable )
end
TheTable = TheTable or {}
TheTable.ItemName = itemname
TheTable.Text = text
TheTable.Command = command
TheTable.Controls = controls
TheTable.CPanelFunction = cpanelfunction
table.insert( CategoryTable, TheTable )
-- Keep the table sorted
table.SortByMember( CategoryTable, "Text", true )
end
--[[---------------------------------------------------------
Creation Tabs
-----------------------------------------------------------]]
function AddCreationTab( strName, pFunction, pMaterial, iOrder, strTooltip )
iOrder = iOrder or 1000
pMaterial = pMaterial or "icon16/exclamation.png"
CreationMenus[ strName ] = { Function = pFunction, Icon = pMaterial, Order = iOrder, Tooltip = strTooltip }
end
function GetCreationTabs()
return CreationMenus
end
function SwitchCreationTab( id )
local tab = g_SpawnMenu:GetCreationMenu():GetCreationTab( id )
if ( !tab or !IsValid( tab.Tab ) ) then return end
tab.Tab:DoClick()
end
--[[---------------------------------------------------------
Spawn lists
-----------------------------------------------------------]]
function GetPropTable()
return PropTable
end
function GetCustomPropTable()
return PropTableCustom
end
function AddPropCategory( strFilename, strName, tabContents, icon, id, parentid, needsapp )
PropTableCustom[ strFilename ] = {
name = strName,
contents = tabContents,
icon = icon,
id = id or ActiveSpawnlistID,
parentid = parentid or 0,
needsapp = needsapp
}
if ( !id ) then ActiveSpawnlistID = ActiveSpawnlistID + 1 end
end
-- Populate the spawnmenu from the text files (engine)
function PopulateFromEngineTextFiles()
-- Reset the already loaded prop list before loading them again.
-- This caused the spawnlists to duplicate into crazy trees when spawnmenu_reload'ing after saving edited spawnlists
PropTable = {}
spawnmenu_engine.PopulateFromTextFiles( function( strFilename, strName, tabContents, icon, id, parentid, needsapp )
PropTable[ strFilename ] = {
name = strName,
contents = tabContents,
icon = icon,
id = id,
parentid = parentid or 0,
needsapp = needsapp
}
end )
end
-- Save the spawnfists to text files (engine)
function DoSaveToTextFiles( props )
spawnmenu_engine.SaveToTextFiles( props )
end
--[[
Content Providers
Functions that populate the spawnmenu from the spawnmenu txt files.
function MyFunction( ContentPanel, ObjectTable )
local myspawnicon = CreateSpawnicon( ObjectTable.model )
ContentPanel:AddItem( myspawnicon )
end
spawnmenu.AddContentType( "model", MyFunction )
--]]
local cp = {}
function AddContentType( name, func )
cp[ name ] = func
end
function GetContentType( name )
if ( !cp[ name ] ) then
cp[ name ] = function() end
Msg( "spawnmenu.GetContentType( ", name, " ) - not found!\n" )
end
return cp[ name ]
end
function CreateContentIcon( type, parent, tbl )
local ctrlpnl = GetContentType( type )
if ( ctrlpnl ) then return ctrlpnl( parent, tbl ) end
end

49
lua/includes/modules/sui.lua Normal file
View File

@@ -0,0 +1,49 @@
--[[
| 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/
--]]
if sui then return end
AddCSLuaFile()
sui = {}
do
local wspace_chs = {} -- whitespace characters except a normal space " "
for k, v in ipairs({0x0c, 0x0a, 0x0d, 0x09, 0x0b}) do
wspace_chs[string.char(v)] = true
end
sui.wspace_chs = wspace_chs
local cntrl_chs = {string.char(0x7f)} -- control characters
for i = 0x00, 0x1f do
cntrl_chs[string.char(i)] = true
end
sui.cntrl_chs = cntrl_chs
end
if SERVER then
AddCSLuaFile("sui/libs/tdlib/cl_tdlib.lua")
AddCSLuaFile("sui/libs/bshadows.lua")
AddCSLuaFile("sui/libs/gif_loader.lua")
AddCSLuaFile("sui/libs/png_encoder.lua")
AddCSLuaFile("sui/libs/types.lua")
AddCSLuaFile("sui/cl_base.lua")
else
include("sui/libs/tdlib/cl_tdlib.lua")
include("sui/libs/bshadows.lua")
include("sui/libs/types.lua")
include("sui/cl_base.lua")
end
if SERVER then
for _, f in ipairs(file.Find("sui/vgui/*.lua", "LUA")) do
AddCSLuaFile("sui/vgui/" .. f)
end
end

221
lua/includes/modules/team.lua Normal file
View File

@@ -0,0 +1,221 @@
--[[
| 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/
--]]
module( "team", package.seeall )
local TeamInfo = {}
local DefaultColor = Color(255, 255, 100, 255)
TeamInfo[TEAM_CONNECTING] = { Name = "Joining/Connecting", Color = DefaultColor, Score = 0, Joinable = false }
TeamInfo[TEAM_UNASSIGNED] = { Name = "Unassigned", Color = DefaultColor, Score = 0, Joinable = false }
TeamInfo[TEAM_SPECTATOR] = { Name = "Spectator", Color = DefaultColor, Score = 0, Joinable = true }
--[[------------------------------------------------------------
Call this to set up your team. It should be called in
a shared file. This system assumes that your teams are
static. If you want to have dynamic teams you need to
code this yourself.
id should be a number. It's best to do something like
TEAM_TERRORISTS = 2
at the top of your code somewhere so you can reference
teams via a variable rather than a number.
--------------------------------------------------------------]]
function SetUp( id, name, color, joinable )
if ( joinable == nil ) then joinable = true end
TeamInfo[id] = { Name = name, Color = color, Score = 0, Joinable = joinable }
end
function GetAllTeams()
return TeamInfo -- copyof?
end
function Valid( id )
if ( !TeamInfo[id] ) then return false end
return true
end
function Joinable( id )
if ( !TeamInfo[id] ) then return false end
return TeamInfo[id].Joinable
end
function GetSpawnPoint( id )
if ( !TeamInfo[id] ) then return end
return TeamInfo[id].SpawnPointTable
end
function GetSpawnPoints( id )
if ( IsTableOfEntitiesValid( TeamInfo[id].SpawnPoints ) ) then return TeamInfo[id].SpawnPoints end
local SpawnPointTable = team.GetSpawnPoint( id )
if ( !SpawnPointTable ) then return end
TeamInfo[id].SpawnPoints = {}
for k, entname in pairs( SpawnPointTable ) do
TeamInfo[id].SpawnPoints = table.Add( TeamInfo[id].SpawnPoints, ents.FindByClass( entname ) )
end
return TeamInfo[id].SpawnPoints
end
function SetSpawnPoint( id, ent_name )
if ( !TeamInfo[id] ) then return end
if ( !istable( ent_name ) ) then ent_name = {ent_name} end
TeamInfo[id].SpawnPointTable = ent_name
end
function SetClass( id, classtable )
if ( !TeamInfo[id] ) then return end
if ( !istable( classtable ) ) then classtable = {classtable} end
TeamInfo[id].SelectableClasses = classtable
end
function GetClass( id )
if ( !TeamInfo[id] ) then return end
return TeamInfo[id].SelectableClasses
end
function TotalDeaths(index)
local score = 0
for id,pl in ipairs( player.GetAll() ) do
if (pl:Team() == index) then
score = score + pl:Deaths()
end
end
return score
end
function TotalFrags(index)
local score = 0
for id,pl in ipairs( player.GetAll() ) do
if (pl:Team() == index) then
score = score + pl:Frags()
end
end
return score
end
function NumPlayers(index)
return #GetPlayers(index)
end
function GetPlayers(index)
local TeamPlayers = {}
for id,pl in ipairs( player.GetAll() ) do
if (IsValid(pl) and pl:Team() == index) then
table.insert(TeamPlayers, pl)
end
end
return TeamPlayers
end
function GetScore(index)
return GetGlobalInt( "Team."..tostring(index)..".Score", 0 )
end
function GetName( index )
if (!TeamInfo[index]) then return "" end
return TeamInfo[index].Name
end
function SetColor( index, color )
if ( !TeamInfo[ index ] ) then return false; end
TeamInfo[ index ].Color = color
return color
end
function GetColor( index )
if (!TeamInfo[index]) then return DefaultColor end
return table.Copy( TeamInfo[index].Color )
end
function SetScore(index, score)
return SetGlobalInt( "Team."..tostring(index)..".Score", score )
end
function AddScore(index, score)
SetScore( index, GetScore( index ) + score )
end
function BestAutoJoinTeam()
local SmallestTeam = TEAM_UNASSIGNED
local SmallestPlayers = 1000
for id, tm in pairs( team.GetAllTeams() ) do
if ( id != TEAM_SPECTATOR && id != TEAM_UNASSIGNED && id != TEAM_CONNECTING && tm.Joinable ) then
local PlayerCount = team.NumPlayers( id )
if ( PlayerCount < SmallestPlayers || (PlayerCount == SmallestPlayers && id < SmallestTeam ) ) then
SmallestPlayers = PlayerCount
SmallestTeam = id
end
end
end
return SmallestTeam
end

519
lua/includes/modules/undo.lua Normal file
View File

@@ -0,0 +1,519 @@
--[[
| 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/
--]]
module( "undo", package.seeall )
-- undo.Create("Wheel")
-- undo.AddEntity( axis )
-- undo.AddEntity( constraint )
-- undo.SetPlayer( self.Owner )
-- undo.Finish()
if ( CLIENT ) then
local ClientUndos = {}
local bIsDirty = true
--[[---------------------------------------------------------
GetTable
Returns the undo table for whatever reason
-----------------------------------------------------------]]
function GetTable()
return ClientUndos
end
--[[---------------------------------------------------------
UpdateUI
Actually updates the UI. Removes old controls and
re-creates them using the new data.
-----------------------------------------------------------]]
local function UpdateUI()
local Panel = controlpanel.Get( "Undo" )
if ( !IsValid( Panel ) ) then return end
Panel:Clear()
Panel:AddControl( "Header", { Description = "#spawnmenu.utilities.undo.help" } )
local ComboBox = Panel:ListBox()
ComboBox:SetTall( 500 )
local Limit = 100
local Count = 0
for k, v in ipairs( ClientUndos ) do
local Item = ComboBox:AddItem( tostring( v.Name ) )
Item.DoClick = function() RunConsoleCommand( "gmod_undonum", tostring( v.Key ) ) end
Count = Count + 1
if ( Count > Limit ) then break end
end
end
--[[---------------------------------------------------------
AddUndo
Called from server. Adds a new undo to our UI
-----------------------------------------------------------]]
net.Receive( "Undo_AddUndo", function()
local k = net.ReadInt( 16 )
local v = net.ReadString()
table.insert( ClientUndos, 1, { Key = k, Name = v } )
MakeUIDirty()
end )
-- Called from server, fires GM:OnUndo
net.Receive( "Undo_FireUndo", function()
local name = net.ReadString()
local hasCustomText = net.ReadBool()
local customtext
if ( hasCustomText ) then
customtext = net.ReadString()
end
hook.Run( "OnUndo", name, customtext )
end )
--[[---------------------------------------------------------
Undone
Called from server. Notifies us that one of our undos
has been undone or made redundant. We act by updating
out data (We wait until the UI is viewed until updating)
-----------------------------------------------------------]]
local function Undone()
local key = net.ReadInt( 16 )
local NewUndo = {}
local i = 1
for k, v in ipairs( ClientUndos ) do
if ( v.Key != key ) then
NewUndo [ i ] = v
i = i + 1
end
end
ClientUndos = NewUndo
NewUndo = nil
MakeUIDirty()
end
net.Receive( "Undo_Undone", Undone )
--[[---------------------------------------------------------
MakeUIDirty
Makes the UI dirty - it will re-create the controls
the next time it is viewed.
-----------------------------------------------------------]]
function MakeUIDirty()
bIsDirty = true
end
--[[---------------------------------------------------------
CPanelPaint
Called when the inner panel of the undo CPanel is painted
We hook onto this to determine when the panel is viewed.
When it's viewed we update the UI if it's marked as dirty
-----------------------------------------------------------]]
local function CPanelUpdate( panel )
-- This is kind of a shitty way of doing it - but we only want
-- to update the UI when it's visible.
if ( bIsDirty ) then
-- Doing this in a timer so it calls it in a sensible place
-- Calling in the paint function could cause all kinds of problems
-- It's a hack but hey welcome to GMod!
timer.Simple( 0, UpdateUI )
bIsDirty = false
end
end
--[[---------------------------------------------------------
SetupUI
Adds a hook (CPanelPaint) to the control panel paint
function so we can determine when it is being drawn.
-----------------------------------------------------------]]
function SetupUI()
local UndoPanel = controlpanel.Get( "Undo" )
if ( !IsValid( UndoPanel ) ) then return end
-- Mark as dirty please
MakeUIDirty()
-- Panels only think when they're visible
UndoPanel.Think = CPanelUpdate
end
hook.Add( "PostReloadToolsMenu", "BuildUndoUI", SetupUI )
end
if ( !SERVER ) then return end
local PlayerUndo = {}
-- PlayerUndo
-- - Player UniqueID
-- - Undo Table
-- - Name
-- - Entities (table of ents)
-- - Owner (player)
local Current_Undo = nil
util.AddNetworkString( "Undo_Undone" )
util.AddNetworkString( "Undo_AddUndo" )
util.AddNetworkString( "Undo_FireUndo" )
--[[---------------------------------------------------------
GetTable
Returns the undo table for whatever reason
-----------------------------------------------------------]]
function GetTable()
return PlayerUndo
end
--[[---------------------------------------------------------
GetTable
Save/Restore the undo tables
-----------------------------------------------------------]]
local function Save( save )
saverestore.WriteTable( PlayerUndo, save )
end
local function Restore( restore )
PlayerUndo = saverestore.ReadTable( restore )
end
saverestore.AddSaveHook( "UndoTable", Save )
saverestore.AddRestoreHook( "UndoTable", Restore )
--[[---------------------------------------------------------
Start a new undo
-----------------------------------------------------------]]
function Create( text )
Current_Undo = {}
Current_Undo.Name = text
Current_Undo.Entities = {}
Current_Undo.Owner = nil
Current_Undo.Functions = {}
end
--[[---------------------------------------------------------
Adds an entity to this undo (The entity is removed on undo)
-----------------------------------------------------------]]
function SetCustomUndoText( CustomUndoText )
if ( !Current_Undo ) then return end
Current_Undo.CustomUndoText = CustomUndoText
end
--[[---------------------------------------------------------
Adds an entity to this undo (The entity is removed on undo)
-----------------------------------------------------------]]
function AddEntity( ent )
if ( !Current_Undo ) then return end
if ( !IsValid( ent ) ) then return end
table.insert( Current_Undo.Entities, ent )
end
--[[---------------------------------------------------------
Add a function to call to this undo
-----------------------------------------------------------]]
function AddFunction( func, ... )
if ( !Current_Undo ) then return end
if ( !func ) then return end
table.insert( Current_Undo.Functions, { func, {...} } )
end
--[[---------------------------------------------------------
Replace Entity
-----------------------------------------------------------]]
function ReplaceEntity( from, to )
local ActionTaken = false
for _, PlayerTable in pairs( PlayerUndo ) do
for _, UndoTable in pairs( PlayerTable ) do
if ( UndoTable.Entities ) then
for key, ent in pairs( UndoTable.Entities ) do
if ( ent == from ) then
UndoTable.Entities[ key ] = to
ActionTaken = true
end
end
end
end
end
return ActionTaken
end
--[[---------------------------------------------------------
Sets who's undo this is
-----------------------------------------------------------]]
function SetPlayer( ply )
if ( !Current_Undo ) then return end
if ( !IsValid( ply ) ) then return end
Current_Undo.Owner = ply
end
--[[---------------------------------------------------------
SendUndoneMessage
Sends a message to notify the client that one of their
undos has been removed. They can then update their GUI.
-----------------------------------------------------------]]
local function SendUndoneMessage( ent, id, ply )
if ( !IsValid( ply ) ) then return end
-- For further optimization we could queue up the ids and send them
-- in one batch every 0.5 seconds or something along those lines.
net.Start( "Undo_Undone" )
net.WriteInt( id, 16 )
net.Send( ply )
end
--[[---------------------------------------------------------
Checks whether an undo is allowed to be created
-----------------------------------------------------------]]
local function Can_CreateUndo( undo )
local call = hook.Run( "CanCreateUndo", undo.Owner, undo )
return call == true or call == nil
end
--[[---------------------------------------------------------
Finish
-----------------------------------------------------------]]
function Finish( NiceText )
if ( !Current_Undo ) then return end
-- Do not add undos that have no owner or anything to undo
if ( !IsValid( Current_Undo.Owner ) or ( table.IsEmpty( Current_Undo.Entities ) && table.IsEmpty( Current_Undo.Functions ) ) or !Can_CreateUndo( Current_Undo ) ) then
Current_Undo = nil
return false
end
local index = Current_Undo.Owner:UniqueID()
PlayerUndo[ index ] = PlayerUndo[ index ] or {}
Current_Undo.NiceText = NiceText or Current_Undo.Name
local id = table.insert( PlayerUndo[ index ], Current_Undo )
net.Start( "Undo_AddUndo" )
net.WriteInt( id, 16 )
net.WriteString( Current_Undo.NiceText )
net.Send( Current_Undo.Owner )
-- Have one of the entities in the undo tell us when it gets undone.
if ( IsValid( Current_Undo.Entities[ 1 ] ) ) then
local ent = Current_Undo.Entities[ 1 ]
ent:CallOnRemove( "undo" .. id, SendUndoneMessage, id, Current_Undo.Owner )
end
Current_Undo = nil
return true
end
--[[---------------------------------------------------------
Undos an undo
-----------------------------------------------------------]]
function Do_Undo( undo )
if ( !undo ) then return false end
if ( hook.Run( "PreUndo", undo ) == false ) then return end
local count = 0
-- Call each function
if ( undo.Functions ) then
for index, func in pairs( undo.Functions ) do
local success = func[ 1 ]( undo, unpack( func[ 2 ] ) )
if ( success != false ) then
count = count + 1
end
end
end
-- Remove each entity in this undo
if ( undo.Entities ) then
for index, entity in pairs( undo.Entities ) do
if ( IsValid( entity ) ) then
entity:Remove()
count = count + 1
end
end
end
if ( count > 0 ) then
net.Start( "Undo_FireUndo" )
net.WriteString( undo.Name )
net.WriteBool( undo.CustomUndoText != nil )
if ( undo.CustomUndoText != nil ) then
net.WriteString( undo.CustomUndoText )
end
net.Send( undo.Owner )
end
hook.Run( "PostUndo", undo, count )
return count
end
--[[---------------------------------------------------------
Checks whether a player is allowed to undo
-----------------------------------------------------------]]
local function Can_Undo( ply, undo )
local call = hook.Run( "CanUndo", ply, undo )
return call == true or call == nil
end
--[[---------------------------------------------------------
Console command
-----------------------------------------------------------]]
local function CC_UndoLast( pl, command, args )
local index = pl:UniqueID()
PlayerUndo[ index ] = PlayerUndo[ index ] or {}
local last = nil
local lastk = nil
for k, v in pairs( PlayerUndo[ index ] ) do
lastk = k
last = v
end
-- No undos
if ( !last ) then return end
-- This is quite messy, but if the player rejoined the server
-- 'Owner' might no longer be a valid entity. So replace the Owner
-- with the player that is doing the undoing
last.Owner = pl
if ( !Can_Undo( pl, last ) ) then return end
local count = Do_Undo( last )
net.Start( "Undo_Undone" )
net.WriteInt( lastk, 16 )
net.Send( pl )
PlayerUndo[ index ][ lastk ] = nil
-- If our last undo object is already deleted then compact
-- the undos until we hit one that does something
if ( count == 0 ) then
CC_UndoLast( pl )
end
end
--[[---------------------------------------------------------
Console command
-----------------------------------------------------------]]
local function CC_UndoNum( ply, command, args )
if ( !args[ 1 ] ) then return end
local index = ply:UniqueID()
PlayerUndo[ index ] = PlayerUndo[ index ] or {}
local UndoNum = tonumber( args[ 1 ] )
if ( !UndoNum ) then return end
local TheUndo = PlayerUndo[ index ][ UndoNum ]
if ( !TheUndo ) then return end
-- Do the same as above
TheUndo.Owner = ply
if ( !Can_Undo( ply, TheUndo ) ) then return end
-- Undo!
Do_Undo( TheUndo )
-- Notify the client UI that the undo happened
-- This is normally called by the deleted entity via SendUndoneMessage
-- But in cases where the undo only has functions that will not do
net.Start( "Undo_Undone" )
net.WriteInt( UndoNum, 16 )
net.Send( ply )
-- Don't delete the entry completely so nothing new takes its place and ruin CC_UndoLast's logic (expecting newest entry be at highest index)
PlayerUndo[ index ][ UndoNum ] = {}
end
concommand.Add( "undo", CC_UndoLast, nil, "", { FCVAR_DONTRECORD } )
concommand.Add( "gmod_undo", CC_UndoLast, nil, "", { FCVAR_DONTRECORD } )
concommand.Add( "gmod_undonum", CC_UndoNum, nil, "", { FCVAR_DONTRECORD } )

97
lua/includes/modules/usermessage.lua Normal file
View File

@@ -0,0 +1,97 @@
--[[
| 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/
--]]
-- Globals that we are going to use
local unpack = unpack
local Msg = Msg
--[[
This is merely a convenience function. If you pass numbers
using this they're always sent as long. Which sucks if you're sending
numbers that are always under 100 etc.
--]]
function SendUserMessage( name, ply, ... )
if ( CLIENT ) then return end
umsg.Start( name, ply )
for k, v in ipairs( { ... } ) do
local t = TypeID( v )
if ( t == TYPE_STRING ) then
umsg.String( v )
elseif ( t == TYPE_ENTITY ) then
umsg.Entity( v )
elseif ( t == TYPE_NUMBER ) then
umsg.Long( v )
elseif ( t == TYPE_VECTOR ) then
umsg.Vector( v )
elseif ( t == TYPE_ANGLE ) then
umsg.Angle( v )
elseif ( t == TYPE_BOOL ) then
umsg.Bool( v )
else
ErrorNoHalt( "SendUserMessage: Couldn't send type " .. type( v ) .. "\n" )
end
end
umsg.End()
end
--[[---------------------------------------------------------
Name: usermessage
Desc: Enables the server to send the client messages (in a bandwidth friendly manner)
-----------------------------------------------------------]]
module( "usermessage" )
local Hooks = {}
--[[---------------------------------------------------------
Name: GetTable
Desc: Returns the table of hooked usermessages
-----------------------------------------------------------]]
function GetTable()
return Hooks
end
--[[---------------------------------------------------------
Name: Hook
Desc: Adds a hook
-----------------------------------------------------------]]
function Hook( messagename, func, ... )
Hooks[ messagename ] = {}
Hooks[ messagename ].Function = func
Hooks[ messagename ].PreArgs = { ... }
end
--[[---------------------------------------------------------
Name: Call( name, args )
Desc: Called by the engine to call a gamemode hook
-----------------------------------------------------------]]
function IncomingMessage( MessageName, msg )
if ( Hooks[ MessageName ] ) then
Hooks[ MessageName ].Function( msg, unpack( Hooks[ MessageName ].PreArgs ) )
return
end
Msg( "Warning: Unhandled usermessage '" .. MessageName .. "'\n" )
end

387
lua/includes/modules/utf8.lua Normal file
View File

@@ -0,0 +1,387 @@
--[[
| 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/
--]]
local bit = bit
local error = error
local ipairs = ipairs
local string = string
local table = table
local unpack = unpack
local math = math
module( "utf8" )
--
-- Pattern that can be used with the string library to match a single UTF-8 byte-sequence.
-- This expects the string to contain valid UTF-8 data.
--
charpattern = "[%z\x01-\x7F\xC2-\xF4][\x80-\xBF]*"
--
-- Transforms indexes of a string to be positive.
-- Negative indices will wrap around like the string library's functions.
--
local function strRelToAbs( str, ... )
local args = { ... }
for k, v in ipairs( args ) do
v = v > 0 and v or math.max( #str + v + 1, 1 )
if v < 1 or v > #str + 1 then
error( "bad index to string (out of range)", 3 )
end
args[ k ] = v
end
return unpack( args )
end
-- Decodes a single UTF-8 byte-sequence from a string, ensuring it is valid
-- Returns the index of the first/last chars of a sequence and its codepoint
--
local function decode( str, startPos )
startPos = strRelToAbs( str, startPos or 1 )
local b1 = str:byte( startPos, startPos )
-- End of string
if not b1 then
return nil
end
-- Single-byte sequence
if b1 < 0x80 then
return startPos, startPos, b1
end
-- Validate first byte of multi-byte sequence
if b1 > 0xF4 or b1 < 0xC2 then
return nil
end
-- Get 'supposed' amount of continuation bytes from primary byte
local contByteCount = b1 >= 0xF0 and 3 or
b1 >= 0xE0 and 2 or
b1 >= 0xC0 and 1
local endPos = startPos + contByteCount
local codePoint = 0
-- The string doesn't have enough data for this many continutation bytes
if #str < endPos then
return nil
end
-- Validate our continuation bytes
for _, bX in ipairs { str:byte( startPos + 1, endPos ) } do
-- Invalid continuation byte hit
if bit.band( bX, 0xC0 ) ~= 0x80 then
return nil
end
codePoint = bit.bor( bit.lshift( codePoint, 6 ), bit.band( bX, 0x3F ) )
b1 = bit.lshift( b1, 1 )
end
codePoint = bit.bor( codePoint, bit.lshift( bit.band( b1, 0x7F ), contByteCount * 5 ) )
return startPos, endPos, codePoint
end
--
-- Takes zero or more integers and returns a string containing the UTF-8 representation of each
--
function char( ... )
local buf = {}
for k, v in ipairs { ... } do
if v < 0 or v > 0x10FFFF then
error( "bad argument #" .. k .. " to char (out of range)", 2 )
end
local b1, b2, b3, b4 = nil, nil, nil, nil
if v < 0x80 then -- Single-byte sequence
table.insert( buf, string.char( v ) )
elseif v < 0x800 then -- Two-byte sequence
b1 = bit.bor( 0xC0, bit.band( bit.rshift( v, 6 ), 0x1F ) )
b2 = bit.bor( 0x80, bit.band( v, 0x3F ) )
table.insert( buf, string.char( b1, b2 ) )
elseif v < 0x10000 then -- Three-byte sequence
b1 = bit.bor( 0xE0, bit.band( bit.rshift( v, 12 ), 0x0F ) )
b2 = bit.bor( 0x80, bit.band( bit.rshift( v, 6 ), 0x3F ) )
b3 = bit.bor( 0x80, bit.band( v, 0x3F ) )
table.insert( buf, string.char( b1, b2, b3 ) )
else -- Four-byte sequence
b1 = bit.bor( 0xF0, bit.band( bit.rshift( v, 18 ), 0x07 ) )
b2 = bit.bor( 0x80, bit.band( bit.rshift( v, 12 ), 0x3F ) )
b3 = bit.bor( 0x80, bit.band( bit.rshift( v, 6 ), 0x3F ) )
b4 = bit.bor( 0x80, bit.band( v, 0x3F ) )
table.insert( buf, string.char( b1, b2, b3, b4 ) )
end
end
return table.concat( buf, "" )
end
--
-- Iterates over a UTF-8 string similarly to pairs
-- k = index of sequence, v = string value of sequence
--
function codes( str )
local i = 1
return function()
-- Have we hit the end of the iteration set?
if i > #str then
return nil
end
local startPos, endPos, codePoint = decode( str, i )
if not startPos then
error( "invalid UTF-8 code", 2 )
end
i = endPos + 1
return startPos, codePoint
end
end
--
-- Returns an integer-representation of the UTF-8 sequence(s) in a string
-- startPos defaults to 1, endPos defaults to startPos
--
function codepoint( str, startPos, endPos )
startPos, endPos = strRelToAbs( str, startPos or 1, endPos or startPos or 1 )
local ret = {}
repeat
local seqStartPos, seqEndPos, codePoint = decode( str, startPos )
if not seqStartPos then
error( "invalid UTF-8 code", 2 )
end
-- Increment current string index
startPos = seqEndPos + 1
table.insert( ret, codePoint )
until seqEndPos >= endPos
return unpack( ret )
end
--
-- Returns the length of a UTF-8 string. false, index is returned if an invalid sequence is hit
-- startPos defaults to 1, endPos defaults to -1
--
function len( str, startPos, endPos )
startPos, endPos = strRelToAbs( str, startPos or 1, endPos or -1 )
local len = 0
while endPos >= startPos and startPos <= #str do
local seqStartPos, seqEndPos = decode( str, startPos )
-- Hit an invalid sequence?
if not seqStartPos then
return false, startPos
end
-- Increment current string pointer
startPos = seqEndPos + 1
-- Increment length
len = len + 1
end
return len
end
--
-- Returns the byte-index of the n'th UTF-8-character after the given byte-index (nil if none)
-- startPos defaults to 1 when n is positive and -1 when n is negative
-- If 0 is zero, this function instead returns the byte-index of the UTF-8-character startPos lies within.
--
function offset( str, n, startPos )
if startPos and ( startPos > #str or -startPos > #str or startPos == 0 ) then
error( "bad index to string (out of range)", 2 )
end
local pos = ( n >= 0 ) and 1 or #str
pos = strRelToAbs( str, startPos or pos )
-- Back up to the start of this byte sequence
if n == 0 then
while pos > 0 and not decode( str, pos ) do
pos = pos - 1
end
return pos
end
--
-- Make sure we're on a valid sequence
--
if not decode( str, pos ) then
error( "initial position is a continuation byte", 2 )
end
-- Back up to (-n) byte sequences
if n < 0 then
for i = 1, -n do
pos = pos - 1
while pos > 0 and not decode( str, pos ) do
pos = pos - 1
end
end
if pos < 1 then
return nil
end
return pos
end
-- Jump forward (n) byte sequences
if n > 0 then
for i = 1, n do
pos = pos + 1
while pos <= #str and not decode( str, pos ) do
pos = pos + 1
end
end
if pos > #str then
return nil
end
return pos
end
end
--
-- Forces a string to contain only valid UTF-8 data.
-- Invalid sequences are replaced with U+FFFD.
--
function force( str )
local buf = {}
local curPos, endPos = 1, #str
-- Empty string?
if endPos == 0 then
return str
end
repeat
local seqStartPos, seqEndPos = decode( str, curPos )
if not seqStartPos then
table.insert( buf, char( 0xFFFD ) )
curPos = curPos + 1
else
table.insert( buf, str:sub( seqStartPos, seqEndPos ) )
curPos = seqEndPos + 1
end
until curPos > endPos
return table.concat( buf, "" )
end
--
-- Converts a relative index to an absolute
-- This is different from the above in that it cares about characters and not bytes
--
local function strRelToAbsChar( str, pos )
if pos < 0 then
pos = math.max( pos + len( str ) + 1, 0 )
end
return pos
end
--
-- UTF-8 compilant version of str[idx]
--
function GetChar( str, idx )
idx = strRelToAbsChar( str, idx )
if idx == 0 then return "" end
if idx > len( str ) then return "" end
local off = offset( str, idx - 1 )
return char( codepoint( str, off ) )
end
--
-- UTF-8 compilant version of string.sub
--
function sub( str, charstart, charend )
charstart = strRelToAbsChar( str, charstart )
charend = strRelToAbsChar( str, charend or -1 )
local buf = {}
for i = charstart, charend do
buf[#buf + 1] = GetChar( str, i )
end
return table.concat( buf )
end

195
lua/includes/modules/weapons.lua Normal file
View File

@@ -0,0 +1,195 @@
--[[
| 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/
--]]
module( "weapons", package.seeall )
local WeaponList = {}
--[[---------------------------------------------------------
Name: TableInherit( t, base )
Desc: Copies any missing data from base to t
-----------------------------------------------------------]]
local function TableInherit( t, base )
for k, v in pairs( base ) do
if ( t[ k ] == nil ) then
t[ k ] = v
elseif ( k != "BaseClass" && istable( t[ k ] ) && istable( v ) ) then
TableInherit( t[ k ], v )
end
end
t[ "BaseClass" ] = base
return t
end
--[[---------------------------------------------------------
Name: IsBasedOn( name, base )
Desc: Checks if name is based on base
-----------------------------------------------------------]]
function IsBasedOn( name, base )
local t = GetStored( name )
if ( !t ) then return false end
if ( t.Base == name ) then return false end
if ( t.Base == base ) then return true end
return IsBasedOn( t.Base, base )
end
--[[---------------------------------------------------------
Name: Register( table, string, bool )
Desc: Used to register your SWEP with the engine
-----------------------------------------------------------]]
function Register( t, name )
if ( hook.Run( "PreRegisterSWEP", t, name ) == false ) then return end
if ( isstring( t.ClassNameOverride ) ) then name = t.ClassNameOverride end
local old = WeaponList[ name ]
t.ClassName = name
WeaponList[ name ] = t
--baseclass.Set( name, t )
list.Set( "Weapon", name, {
ClassName = name,
PrintName = t.PrintName or name,
Category = t.Category or "Other",
Spawnable = t.Spawnable,
AdminOnly = t.AdminOnly,
ScriptedEntityType = t.ScriptedEntityType,
IconOverride = t.IconOverride
} )
-- Allow all SWEPS to be duplicated, unless specified
if ( !t.DisableDuplicator ) then
duplicator.Allow( name )
end
--
-- If we're reloading this entity class
-- then refresh all the existing entities.
--
if ( old != nil ) then
-- Update SWEP table of entities that are based on this SWEP
for _, e in ipairs( ents.GetAll() ) do
local class = e:GetClass()
if ( class == name ) then
--
-- Replace the contents with this entity table
--
table.Merge( e, t )
--
-- Call OnReloaded hook (if it has one)
--
if ( e.OnReloaded ) then
e:OnReloaded()
end
end
if ( IsBasedOn( class, name ) ) then
table.Merge( e, Get( class ) )
if ( e.OnReloaded ) then
e:OnReloaded()
end
end
end
end
end
--
-- All scripts have been loaded...
--
function OnLoaded()
--
-- Once all the scripts are loaded we can set up the baseclass
-- - we have to wait until they're all setup because load order
-- could cause some entities to load before their bases!
--
for k, v in pairs( WeaponList ) do
baseclass.Set( k, Get( k ) )
end
end
--[[---------------------------------------------------------
Name: Get( string )
Desc: Get a weapon by name.
-----------------------------------------------------------]]
function Get( name, retval )
local Stored = GetStored( name )
if ( !Stored ) then return nil end
-- Create/copy a new table
local retval = retval or {}
for k, v in pairs( Stored ) do
if ( istable( v ) ) then
retval[ k ] = table.Copy( v )
else
retval[ k ] = v
end
end
retval.Base = retval.Base or "weapon_base"
-- If we're not derived from ourselves (a base weapon)
-- then derive from our 'Base' weapon.
if ( retval.Base != name ) then
local base = Get( retval.Base )
if ( !base ) then
Msg( "ERROR: Trying to derive weapon " .. tostring( name ) .. " from non existant SWEP " .. tostring( retval.Base ) .. "!\n" )
else
retval = TableInherit( retval, base )
end
end
return retval
end
--[[---------------------------------------------------------
Name: GetStored( string )
Desc: Gets the REAL weapon table, not a copy
-----------------------------------------------------------]]
function GetStored( name )
return WeaponList[ name ]
end
--[[---------------------------------------------------------
Name: GetList( string )
Desc: Get a list of all the registered SWEPs
-----------------------------------------------------------]]
function GetList()
local result = {}
for k, v in pairs( WeaponList ) do
table.insert( result, v )
end
return result
end

173
lua/includes/modules/widget.lua Normal file
View File

@@ -0,0 +1,173 @@
--[[
| 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/
--]]
--
-- Widgets are like gui controls in the 3D world(!!!)
--
widgets = {}
--
-- Holds the currently hovered widget
--
widgets.Hovered = nil
widgets.HoveredPos = vector_origin
--
-- Holds the current pressed widget
--
widgets.Pressed = nil
local function UpdateHovered( pl, mv )
if ( !IsValid( pl ) ) then return end
if ( !pl:Alive() ) then
pl:SetHoveredWidget( NULL )
return
end
local OldHovered = pl:GetHoveredWidget()
pl:SetHoveredWidget( NULL )
local eyePos = pl:EyePos()
local aimVector = pl:GetAimVector()
aimVector:Mul( 256 )
aimVector:Add( eyePos )
local trace =
{
start = eyePos,
endpos = aimVector,
filter = function( ent )
return IsValid( ent ) && ent:IsWidget()
end
}
-- debugoverlay.Line( trace.start, trace.endpos, 0.5 )
widgets.Tracing = true
local tr = util.TraceLine( trace )
widgets.Tracing = false
if ( !IsValid( tr.Entity ) ) then return end
if ( tr.Entity:IsWorld() ) then return end
if ( !tr.Entity:IsWidget() ) then return end
-- debugoverlay.Cross( tr.HitPos, 1, 60 )
if ( OldHovered != tr.Entity ) then
-- On hover changed? why bother?
end
pl:SetHoveredWidget( tr.Entity )
pl.WidgetHitPos = tr.HitPos
end
local function UpdateButton( pl, mv, btn, mousebutton )
local now = mv:KeyDown( btn )
local was = mv:KeyWasDown( btn )
local hvr = pl:GetHoveredWidget()
local prs = pl:GetPressedWidget()
if ( now && !was && IsValid( hvr ) ) then
hvr:OnPress( pl, mousebutton, mv )
end
if ( !now && was && IsValid( prs ) ) then
prs:OnRelease( pl, mousebutton, mv )
end
end
--
-- The idea here is to have exactly the same
-- behaviour on the client as the server.
--
function widgets.PlayerTick( pl, mv )
UpdateHovered( pl, mv )
UpdateButton( pl, mv, IN_ATTACK, 1 )
UpdateButton( pl, mv, IN_ATTACK2, 2 )
local prs = pl:GetPressedWidget()
if ( IsValid( prs ) ) then
prs:PressedThinkInternal( pl, mv )
end
end
---
--- Render the widgets!
---
local RenderList = {}
function widgets.RenderMe( ent )
--
-- The pressed widget gets to decide what should draw
--
if ( LocalPlayer() && IsValid(LocalPlayer():GetPressedWidget()) ) then
if ( !LocalPlayer():GetPressedWidget():PressedShouldDraw( ent ) ) then
return
end
end
table.insert( RenderList, ent )
end
hook.Add( "PostDrawEffects", "RenderWidgets", function()
--
-- Don't do anything if we don't have widgets to render!
--
if ( #RenderList == 0 ) then return end
cam.Start3D( EyePos(), EyeAngles() )
for k, v in ipairs( RenderList ) do
v:OverlayRender()
end
cam.End3D()
RenderList = {}
end )
hook.Add( "PlayerTick", "TickWidgets", function( pl, mv ) widgets.PlayerTick( pl, mv ) end )
local ENTITY = FindMetaTable( "Entity" )
function ENTITY:IsWidget()
return self.Widget
end