150 lines
3.9 KiB
Lua
150 lines
3.9 KiB
Lua
--[[
|
|
Array gates
|
|
]]
|
|
|
|
GateActions("Array")
|
|
|
|
|
|
local types_defaults = {
|
|
NUMBER = 0,
|
|
ANGLE = Angle(0,0,0),
|
|
VECTOR = Vector(0,0,0),
|
|
STRING = "",
|
|
ENTITY = NULL,
|
|
}
|
|
|
|
local types_formats = {
|
|
NUMBER = function(x) return tostring(x) end,
|
|
ANGLE = function(x) return string.format("(%d,%d,%d)",x.p,x.r,x.y) end,
|
|
VECTOR = function(x) return string.format("(%d,%d,%d)",x.x,x.y,x.z) end,
|
|
STRING = function(x) return x end,
|
|
ENTITY = function(x) return tostring(x) end,
|
|
}
|
|
|
|
local types_compare = { -- used for array find gates.
|
|
ANGLE = function(a,b) return a.p == b.p and
|
|
a.y == b.y and
|
|
a.r == b.r end,
|
|
VECTOR = function(a,b) return a.x == b.x and
|
|
a.y == b.y and
|
|
a.z == b.z end,
|
|
}
|
|
local normal_compare = function(a,b) return a == b end
|
|
|
|
for type_name, default in pairs( types_defaults ) do
|
|
local type_name2 = type_name
|
|
if type_name2 == "NUMBER" then type_name2 = "NORMAL" end
|
|
local compare = types_compare[type_name] or normal_compare
|
|
|
|
GateActions["array_read_" .. type_name] = {
|
|
name = "Array Read (" .. type_name .. ")",
|
|
inputs = { "R", "Index" },
|
|
inputtypes = { "ARRAY", "NORMAL" },
|
|
outputtypes = { type_name2 },
|
|
output = function(gate, r, index)
|
|
local var = r[math.floor(index)]
|
|
local tp = type(var)
|
|
|
|
if not var then return default end
|
|
|
|
if tp == "Player" and type_name == "ENTITY" then return var end -- Special case
|
|
if tp == "NPC" and type_name == "ENTITY" then return var end -- Special case
|
|
if string.upper(tp) ~= type_name then return default end
|
|
|
|
return var
|
|
end,
|
|
label = function(Out,r,index)
|
|
return string.format( "%s[%s] = %s", r, index, types_formats[type_name](Out) )
|
|
end,
|
|
}
|
|
|
|
GateActions["array_find_" .. type_name] = {
|
|
name = "Array Find (" .. type_name .. ")",
|
|
inputs = { "R", "Value" },
|
|
inputtypes = { "ARRAY", type_name2 },
|
|
outputtypes = { "NORMAL" },
|
|
output = function(gate, r, value)
|
|
for i=1,#r do
|
|
if i > 10000 then return 0 end -- Stop iterating too much to prevent lag
|
|
|
|
local var = r[i]
|
|
|
|
if compare(var,value) then return i end
|
|
end
|
|
|
|
return 0
|
|
end,
|
|
label = function(Out,r,index)
|
|
return string.format( "find(%s,%s) = %d", r, index, Out )
|
|
end,
|
|
}
|
|
|
|
--[[
|
|
I feel there is no need for these gates at this time.
|
|
The only time you'll encounter arrays with gates
|
|
are in a situation where you only need to read.
|
|
I'll add it here for future reference
|
|
|
|
GateActions["array_write_" .. type_name] = {
|
|
name = "Array Write (" .. type_name .. ")",
|
|
inputs = { "R", "Index", "Value" },
|
|
inputtypes = { "ARRAY", "NORMAL", type_name2 },
|
|
output = function(gate, r, index, value)
|
|
if type(var) ~= string.lower(type_name) then return end
|
|
if not var then return end
|
|
|
|
r[math.floor(index)] = value
|
|
end,
|
|
label = function(Out,r,index)
|
|
return string.format( "%s[%s] = %s", r, index, types_formats[type_name](Out) )
|
|
end,
|
|
}
|
|
]]
|
|
end
|
|
|
|
--[[
|
|
I feel there is no need for this gate at this time.
|
|
The only time you'll encounter arrays with gates
|
|
are in a situation where you only need to read.
|
|
I'll add it here for future reference
|
|
|
|
GateActions["array_create"] = {
|
|
name = "Array Create",
|
|
output = function(gate)
|
|
return {}
|
|
end,
|
|
}
|
|
]]
|
|
|
|
GateActions["array_gettype"] = {
|
|
name = "Array Get Type",
|
|
inputs = { "R", "Index" },
|
|
inputtypes = { "ARRAY", "NORMAL" },
|
|
outputtypes = { "STRING" },
|
|
output = function(gate, r, index)
|
|
local tp = type(r[math.floor(index)])
|
|
|
|
if tp == "nil" then return "NIL" end
|
|
if tp == "Player" then return "ENTITY" end -- Special case
|
|
if tp == "NPC" then return "ENTITY" end -- Special case
|
|
if not types_defaults[string.upper(tp)] then return "TYPE NOT SUPPORTED" end
|
|
|
|
return tp
|
|
end,
|
|
label = function(Out,r,index)
|
|
return string.format( "type(%s[%s]) = %s", r, index, Out )
|
|
end,
|
|
}
|
|
|
|
GateActions["array_count"] = {
|
|
name = "Array Count",
|
|
inputs = { "R" },
|
|
inputtypes = { "ARRAY" },
|
|
outputtypes = { "NORMAL" },
|
|
output = function(gate, r)
|
|
return #r
|
|
end,
|
|
label = function(Out,r,index)
|
|
return string.format( "#%s = %s", r, Out )
|
|
end,
|
|
}
|