metrostroi-repo/MetrostroiAddon
1
0
Fork 0
mirror of https://github.com/metrostroi-repo/MetrostroiAddon.git synced 2026-05-02 00:42:29 +00:00
Code Activity
Files
313c055cc1b7eb5740c8560226b1b48c3a102d3d
MetrostroiAddon/lua/metrostroi/sv_turbostroi_v2.lua
HellReach 155719f900 Merge pull request #417 from metrostroi-repo/#103
2021-12-29 15:14:19 +03:00

523 lines
20 KiB
Lua
Raw Blame History

--------------------------------------------------------------------------------
-- Simulation acceleration DLL support
--------------------------------------------------------------------------------
if not TURBOSTROI and (not Turbostroi or not Turbostroi.SetMTAffinityMask) then return end
local turbostroiTrains = {}
if Turbostroi and not TURBOSTROI then
local FPS = 1/engine.TickInterval()
local messageTimeout = 0
local messageCounter = 0
local dataCache = {{},{}}
local SendMessage = Turbostroi.SendMessage
local RecvMessages = Turbostroi.RecvMessages
local RecvMessage = Turbostroi.RecvMessage
local ReadAvailable = Turbostroi.ReadAvailable
local unpack = unpack
hook.Add("EntityRemoved","Turbostroi",function(ent)
if dataCache[ent] then
dataCache[ent] = nil
end
if turbostroiTrains[ent] then
turbostroiTrains[ent] = nil
end
end)
for k,ent in pairs(ents.GetAll()) do
if ent.Base == "gmod_subway_base" and not ent.NoTrain and not ent.DontAccelerateSimulation then
turbostroiTrains[ent] = true
end
end
hook.Add("OnEntityCreated","Turbostroi",function(ent)
timer.Simple(0,function()
if IsValid(ent) and ent.Base == "gmod_subway_base" and not ent.NoTrain and not ent.DontAccelerateSimulation then
turbostroiTrains[ent] = true
end
end)
end)
local id,system,name,index,value
local msg_count = 0
local idActionTable = {
[1] = function (train)
if train.Systems[system] then
train.Systems[system][name] = value
if train.TriggerTurbostroiInput then train:TriggerTurbostroiInput(system,name,value) end
end
end,
[2] = function (train)
if index == 0 and name ~= "bass" then index = nil end
if value == 0 and name ~= "bass" then value = nil end
if name == "" then name = nil end
--net.WriteString(name)
train:PlayOnce(system,name,index,value)
end,
[3] = function (train)
if name == "on" then
--print("[!]Wire "..index.." starts update! Value "..value)
dataCache[train]["wiresW"][index] = value
--train:WriteTrainWire(index,value)
if not train.TrainWireWritersID[index] then train.TrainWireWritersID[index] = true end
train.TrainWireTurbostroi[index] = value
if train.TriggerTurbostroiInput then train:TriggerTurbostroiInput("TrainWire",index,value) end
else
--print("[!]Wire "..index.." stop update!")
dataCache[train]["wiresW"][index] = nil
end
end,
[4] = function (train)
if train.Systems[system] then
train.Systems[system]:TriggerInput(name,value)
end
end,
[5] = function (train)
for twid,value in pairs(dataCache[train]["wiresW"]) do
--train:WriteTrainWire(twid,value)
end
end,
[6] = function (train)
if IsValid(Player(index)) then
if value==0 then
Player(index):PrintMessage( HUD_PRINTCONSOLE, "--START" )
-- print("--START")
end
Player(index):PrintMessage( HUD_PRINTCONSOLE, system )
-- print(system)
end
end,
}
local function updateTrains(trains)
--local recvMessage = Turbostroi.RecvMessage
-- Get data packets from simulation
for train in pairs(trains) do
if not dataCache[train] then
if not SendMessage(train,5,"","",0,0) then return end
dataCache[train] = {wiresW = {}}
for sys_name,system in pairs(train.Systems) do
if system.OutputsList and system.DontAccelerateSimulation then
for _,name in pairs(system.OutputsList) do
local value = system[name] or 0
if type(value) == "boolean" then value = value and 1 or 0 end
if type(value) == "number" then
if not dataCache[train][sys_name] then dataCache[train][sys_name] = {} end
dataCache[train][sys_name][name] = math.Round(value)
end
end
end
end
end
msg_count = ReadAvailable(train)
for _ = 1, msg_count do
id,system,name,index,value = RecvMessage(train)
idActionTable[id](train)
messageCounter = messageCounter + 1
end
end
-- Send train wire values
-- Output all system values
for train in pairs(trains) do
if train.ReadTrainWire then
for i in pairs(train.TrainWires) do
if not dataCache[train]["wires"] then dataCache[train]["wires"] = {} end
if dataCache[train]["wires"][i] ~= train:ReadTrainWire(i) then
if SendMessage(train,3,"","",i,train:ReadTrainWire(i)) then
dataCache[train]["wires"][i] = train:ReadTrainWire(i)
end
end
end
for sys_name,system in pairs(train.Systems) do
if system.OutputsList and system.DontAccelerateSimulation then
for _,name in pairs(system.OutputsList) do
local value = system[name] or 0
if type(value) == "boolean" then
value = value and 1 or 0
end
if type(value) == "number" then
value = math.Round(value,1)
if not dataCache[train][sys_name] then dataCache[train][sys_name] = {} end
if dataCache[train][sys_name][name] ~= value then
if SendMessage(train,1,sys_name,name,0,value) then
dataCache[train][sys_name][name] = value
end
end
end
end
end
end
end
end
end
if Turbostroi then
concommand.Add("metrostroi_turbostroi_run",function(ply,_,_,cmd)
if not IsValid(ply) or not ply:IsSuperAdmin() then return end
local train = ply:GetTrain()
if IsValid(train) then
-- print(cmd:sub(1,2),cmd:sub(3,4))
SendMessage(train,6,cmd:sub(1,255),cmd:sub(256,511),ply:UserID(),0)
end
end)
function Turbostroi.TriggerInput(train,system,name,value)
local v = value or 0
if type(value) == "boolean" then v = value and 1 or 0 end
SendMessage(train,4,system,name,0,v)
--end
end
CreateConVar("turbostroi_main_cores",1, FCVAR_ARCHIVE,"Set cores for main thread")
CreateConVar("turbostroi_train_cores",254, FCVAR_ARCHIVE,"Set cores for train threads")
cvars.AddChangeCallback("turbostroi_main_cores", function(cvar, old, value)
Turbostroi.SetMTAffinityMask(tonumber(value) or 1) -- CPU5 CPU4 on 6 core --NEWTURBOSTROI
end, "turbostroi")
cvars.AddChangeCallback("turbostroi_train_cores", function(cvar, old, value)
Turbostroi.SetSTAffinityMask(tonumber(value) or 254) -- 0 - disabled --NEWTURBOSTROI
end, "turbostroi")
Turbostroi.SetMTAffinityMask(GetConVar("turbostroi_main_cores"):GetInt() or 1) -- CPU5 CPU4 on 6 core --NEWTURBOSTROI
Turbostroi.SetSTAffinityMask(GetConVar("turbostroi_train_cores"):GetInt() or 254) -- 0 - disabled --NEWTURBOSTROI
Turbostroi.SetSimulationFPS(FPS)
hook.Add("Think", "Turbostroi_Think", function()
if not Turbostroi then return end
updateTrains(turbostroiTrains)
--[[
-- HACK
GLOBAL_SKIP_TRAIN_SYSTEMS = nil
-- Print stats
if ((CurTime() - messageTimeout) > 1.0) then
messageTimeout = CurTime()
RunConsoleCommand("say",Format("Metrostroi: %d messages per second (%d per tick)",messageCounter,messageCounter / FPS))
messageCounter = 0
end]]
end)
end
return
end
--------------------------------------------------------------------------------
-- Turbostroi scripts
--------------------------------------------------------------------------------
-- NEW API
local ffi = require("ffi")
ffi.cdef[[
bool ThreadSendMessage(void *p, int message, const char* system_name, const char* name, double index, double value);
int ThreadReadAvailable(void* p);
typedef struct {
int message;
char system_name[64];
char name[64];
double index;
double value;
} thread_msg;
thread_msg ThreadRecvMessage(void* p);
]]
local OSName = "gmsv_turbostroi_"
if jit.os == "Windows" then
OSName = OSName.."win"
elseif jit.os == "Linux" then
OSName = OSName.."linux"
end
if jit.arch == "x86" then
OSName = OSName.."32"
else
OSName = OSName.."64"
end
local TS = ffi.load(OSName)
Metrostroi = {}
local dataCache = {wires = {},wiresW = {},wiresL = {}}
Metrostroi.BaseSystems = {} -- Systems that can be loaded
Metrostroi.Systems = {} -- Constructors for systems
LoadSystems = {} -- Systems that must be loaded/initialized
GlobalTrain = {} -- Train emulator
GlobalTrain.Systems = {} -- Train systems
GlobalTrain.TrainWires = {}
GlobalTrain.WriteTrainWires = {}
TimeMinus = 0
_Time = 0
function CurTime()
--return CurrentTime-TimeMinus
return _Time
end
--function CurTime() return os.clock() end
function Metrostroi.DefineSystem(name)
TRAIN_SYSTEM = {}
Metrostroi.BaseSystems[name] = TRAIN_SYSTEM
-- Create constructor
Metrostroi.Systems[name] = function(train,...)
local tbl = { _base = name }
local TRAIN_SYSTEM = Metrostroi.BaseSystems[tbl._base]
if not TRAIN_SYSTEM then print("No system: "..tbl._base) return end
for k,v in pairs(TRAIN_SYSTEM) do
if type(v) == "function" then
tbl[k] = function(...)
if not Metrostroi.BaseSystems[tbl._base][k] then
print("ERROR",k,tbl._base)
end
return Metrostroi.BaseSystems[tbl._base][k](...)
end
else
tbl[k] = v
end
end
tbl.Initialize = tbl.Initialize or function() end
tbl.Think = tbl.Think or function() end
tbl.Inputs = tbl.Inputs or function() return {} end
tbl.Outputs = tbl.Outputs or function() return {} end
tbl.TriggerInput = tbl.TriggerInput or function() end
tbl.TriggerOutput = tbl.TriggerOutput or function() end
tbl.Train = train
tbl:Initialize(...)
tbl.OutputsList = tbl:Outputs()
tbl.InputsList = tbl:Inputs()
tbl.IsInput = {}
for k,v in pairs(tbl.InputsList) do tbl.IsInput[v] = true end
return tbl
end
end
function GlobalTrain.LoadSystem(self,a,b,...)
local name
local sys_name
if b then
name = b
sys_name = a
else
name = a
sys_name = a
end
if not Metrostroi.Systems[name] then print("Error: No system defined: "..name) return end
if self.Systems[sys_name] then print("Error: System already defined: "..sys_name) return end
self[sys_name] = Metrostroi.Systems[name](self,...)
self[sys_name].Name = sys_name
self[sys_name].BaseName = name
self.Systems[sys_name] = self[sys_name]
-- Don't simulate on here
local no_acceleration = Metrostroi.BaseSystems[name].DontAccelerateSimulation
if no_acceleration then
self.Systems[sys_name].Think = function() end
self.Systems[sys_name].TriggerInput = function(train,name,value)
local v = value or 0
if type(value) == "boolean" then v = value and 1 or 0 end
TS.ThreadSendMessage(_userdata, 4,sys_name,name,0,v)
end -- replace with new api
--Precache values
elseif self[sys_name].OutputsList then
dataCache[sys_name] = {}
for _,name in pairs(self[sys_name].OutputsList) do
dataCache[sys_name][name] = 0--self[sys_name][name] or 0
end
end
end
function GlobalTrain.PlayOnce(self,soundid,location,range,pitch)
TS.ThreadSendMessage(_userdata, 2,soundid or "",location or "",range or 0,pitch or 0) -- replace with new api
end
function GlobalTrain.ReadTrainWire(self,n)
return self.TrainWires[n] or 0
end
function GlobalTrain.WriteTrainWire(self,n,v)
self.WriteTrainWires[n] = v
end
GlobalTrain.DeltaTime = 0.33
--------------------------------------------------------------------------------
-- Main train code (turbostroi side)
--------------------------------------------------------------------------------
print("[!] Train initialized!")
function Think(skipped)
-- This is just blatant copy paste from init.lua of base train entity
local self = GlobalTrain
--[[ if skipped then
self.BeSkip = self.BeSkip or CurTime()
return
else
self.PrevTime = self.PrevTime or CurTime()
if self.BeSkip then
--print(1,(CurTime()-self.BeSkip)-0.03)
TimeMinus = TimeMinus + math.max(0,(CurTime()-self.BeSkip)-0.03)
--print(2,TimeMinus)
self.BeSkip = false
end
end--]]
-- Is initialized?
if not self.Initialized then
Initialize()
return
end
self.DeltaTime = (CurrentTime - self.PrevTime)--self.DeltaTime+math.min(0.02,((CurrentTime - self.PrevTime)-self.DeltaTime)*0.1)
self.PrevTime = CurrentTime
if skipped or self.DeltaTime<=0 then return end
_Time = _Time+self.DeltaTime
-- Perform data exchange
DataExchange()
-- Simulate according to schedule
for i,s in ipairs(self.Schedule) do
for k,v in ipairs(s) do
v:Think(self.DeltaTime / (v.SubIterations or 1),i)
end
end
end
function Initialize()
if not CurrentTime then return end
print("[!] Loading systems")
local time = os.clock()
for k,v in pairs(LoadSystems) do
GlobalTrain:LoadSystem(k,v)
end
print(string.format("[!] -Took %.2fs",os.clock()-time))
GlobalTrain.PrevTime = CurrentTime
local iterationsCount = 1
if (not GlobalTrain.Schedule) or (iterationsCount ~= GlobalTrain.Schedule.IterationsCount) then
GlobalTrain.Schedule = { IterationsCount = iterationsCount }
local SystemIterations = {}
-- Find max number of iterations
local maxIterations = 0
for k,v in pairs(GlobalTrain.Systems) do
SystemIterations[k] = (v.SubIterations or 1)
maxIterations = math.max(maxIterations,(v.SubIterations or 1))
end
-- Create a schedule of simulation
for iteration=1,maxIterations do
GlobalTrain.Schedule[iteration] = {}
-- Populate schedule
for k,v in pairs(GlobalTrain.Systems) do
if ((iteration)%(maxIterations/(v.SubIterations or 1))) == 0 then
table.insert(GlobalTrain.Schedule[iteration],v)
end
end
end
end
GlobalTrain.Initialized = true
end
local msg_data
local msg_count = 0
local id,system,name,index,value
function DataExchange()
-- Get data packets
msg_count = TS.ThreadReadAvailable(_userdata)
for i = 1, msg_count do
msg_data = TS.ThreadRecvMessage(_userdata)
if msg_data.message == 1 then
local system_name = ffi.string(msg_data.system_name)
if GlobalTrain.Systems[system_name] then
GlobalTrain.Systems[system_name][ffi.string(msg_data.name)] = msg_data.value
end
end
if msg_data.message == 3 then
dataCache["wiresW"][msg_data.index] = msg_data.value
end
if msg_data.message == 4 then
local system_name = ffi.string(msg_data.system_name)
if GlobalTrain.Systems[system_name] then
GlobalTrain.Systems[system_name]:TriggerInput(ffi.string(msg_data.name),msg_data.value)
end
end
if msg_data.message == 5 then
dataCache["wiresL"] = {}
end
if msg_data.message == 6 then
local scr = [[
local _retdata=""
local print = function(...)
for k,v in ipairs({...}) do _retdata = _retdata..tostring(v).."\t" end
_retdata = _retdata.."\n"
end
]]
scr = scr..ffi.string(msg_data.system_name)..ffi.string(msg_data.name).."\n"
scr = scr.."return _retdata"
local data,err = loadstring(scr)
if data then
local ret = tostring(data()) or "N\\A"
for i=0,math.ceil(#ret/63) do
TS.ThreadSendMessage(_userdata, 6, ret:sub(i*63,(i+1)*63-1), "",msg_data.index,i)
end
else
print(err)
TS.ThreadSendMessage(_userdata, 6, tostring(err), "",msg_data.index,0)
end
--Turbostroi.SendMessage(train,6,cmd:sub(1,255),cmd:sub(256,511),ply:UserID(),0)
end
end
for twid,value in pairs(dataCache["wiresW"]) do
GlobalTrain.TrainWires[twid] = value
end
-- Output all variable values
for sys_name,system in pairs(GlobalTrain.Systems) do
if system.OutputsList and (not system.DontAccelerateSimulation) then
for _,name in pairs(system.OutputsList) do
local value = (system[name] or 0)
--if type(value) == "boolean" then value = value and 1 or 0 end
if not dataCache[sys_name] then print(sys_name) end
if dataCache[sys_name][name] ~= value then
--print(sys_name,name,value)
--if SendMessage(1,sys_name,name,0,tonumber(value) or 0) then -- OLD API
if TS.ThreadSendMessage(_userdata, 1, sys_name , name, 0, tonumber(value) or 0) then -- NEW API
dataCache[sys_name][name] = value
end
end
end
end
end
-- Output train wire writes
for twID,value in pairs(GlobalTrain.WriteTrainWires) do
--local value = tonumber(value) or 0
if dataCache["wires"][twID] ~= value then
dataCache["wires"][twID] = value
dataCache["wiresL"][twID] = false
end
if not dataCache["wiresL"][twID] or dataCache["wiresL"][twID]~=GlobalTrain.PrevTime then
--SendMessage(3,"","on",tonumber(twID) or 0,dataCache["wires"][twID]) -- OLD API
TS.ThreadSendMessage(_userdata, 3, "", "on", tonumber(twID) or 0, dataCache["wires"][twID]) -- NEW API
--print("[!]Wire "..twID.." starts update! Value "..dataCache["wires"][twID])
end
GlobalTrain.WriteTrainWires[twID] = nil
dataCache["wiresL"][twID] = CurTime()
end
for twID,time in pairs(dataCache["wiresL"]) do
if time~=CurTime() then
TS.ThreadSendMessage(_userdata,3, "", "off", tonumber(twID) or 0, 0)
--print("[!]Wire "..twID.." stops update!")
dataCache["wiresL"][twID] = nil
end
end
--SendMessage(5,"","",0,0) -- OLD API
--C.ThreadSendMessage(_userdata, 5,"","",0,0) -- NEW API
--print(string.format("%s %s",count,#msgCache))
--count = 0
end
View Git Blame Copy Permalink