mods that hopefully work for a TechAge-based pack
This commit is contained in:
@@ -0,0 +1,6 @@
|
||||
FPGAs can be used to chain multiple logic gates together in a compact manner.
|
||||
They come with 4 I/O ports and 10 internal registers,
|
||||
which can then be connected with each other to form logic circuits.
|
||||
They work fine in unloaded blocks.<br />
|
||||
Supported gate types: <b>AND</b>, <b>OR</b>, <b>NOT</b>, <b>XOR</b>, <b>NAND</b>, <b>XNOR</b>, <b>Buffer</b> (=)<br />
|
||||
I/O ports: <b>A B C D</b>; Registers: numbered <b>0</b> to <b>9</b>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.9 KiB |
@@ -0,0 +1,3 @@
|
||||
The FPGA programmer can be used to copy gate configurations from one FPGA to another.<br />
|
||||
Shift+Right-Click an FPGA to read its configuration and "remember" it.
|
||||
Left-click (punch) FPGAs to write the saved configuration to them.
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 519 B |
Binary file not shown.
|
After Width: | Height: | Size: 1.7 KiB |
@@ -0,0 +1,464 @@
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
|
||||
local plg = {}
|
||||
plg.rules = {}
|
||||
-- per-player formspec positions
|
||||
plg.open_formspecs = {}
|
||||
|
||||
local lcore = dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/logic.lua")
|
||||
dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/tool.lua")(plg)
|
||||
|
||||
plg.register_nodes = function(template)
|
||||
-- each loop is for one of the 4 IO ports
|
||||
for a = 0, 1 do
|
||||
for b = 0, 1 do
|
||||
for c = 0, 1 do
|
||||
for d = 0, 1 do
|
||||
local ndef = table.copy(template)
|
||||
local nodename = "mesecons_fpga:fpga"
|
||||
.. tostring(d) .. tostring(c) .. tostring(b) .. tostring(a)
|
||||
|
||||
-- build top texture string
|
||||
local texture = "jeija_fpga_top.png"
|
||||
if a == 1 then texture = texture .. "^jeija_luacontroller_LED_A.png" end
|
||||
if b == 1 then texture = texture .. "^jeija_luacontroller_LED_B.png" end
|
||||
if c == 1 then texture = texture .. "^jeija_luacontroller_LED_C.png" end
|
||||
if d == 1 then texture = texture .. "^jeija_luacontroller_LED_D.png" end
|
||||
ndef.tiles[1] = texture
|
||||
ndef.inventory_image = texture
|
||||
|
||||
if (a + b + c + d) > 0 then
|
||||
ndef.groups["not_in_creative_inventory"] = 1
|
||||
end
|
||||
|
||||
-- interaction with mesecons (input / output)
|
||||
local rules_out = {}
|
||||
if a == 1 then table.insert(rules_out, {x = -1, y = 0, z = 0}) end
|
||||
if b == 1 then table.insert(rules_out, {x = 0, y = 0, z = 1}) end
|
||||
if c == 1 then table.insert(rules_out, {x = 1, y = 0, z = 0}) end
|
||||
if d == 1 then table.insert(rules_out, {x = 0, y = 0, z = -1}) end
|
||||
plg.rules[nodename] = rules_out
|
||||
|
||||
local rules_in = {}
|
||||
if a == 0 then table.insert(rules_in, {x = -1, y = 0, z = 0}) end
|
||||
if b == 0 then table.insert(rules_in, {x = 0, y = 0, z = 1}) end
|
||||
if c == 0 then table.insert(rules_in, {x = 1, y = 0, z = 0}) end
|
||||
if d == 0 then table.insert(rules_in, {x = 0, y = 0, z = -1}) end
|
||||
ndef.mesecons.effector.rules = rules_in
|
||||
|
||||
if (a + b + c + d) > 0 then
|
||||
ndef.mesecons.receptor = {
|
||||
state = mesecon.state.on,
|
||||
rules = rules_out,
|
||||
}
|
||||
end
|
||||
|
||||
minetest.register_node(nodename, ndef)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
plg.register_nodes({
|
||||
description = S("FPGA"),
|
||||
drawtype = "nodebox",
|
||||
tiles = {
|
||||
"", -- replaced later
|
||||
"jeija_microcontroller_bottom.png",
|
||||
"jeija_fpga_sides.png",
|
||||
"jeija_fpga_sides.png",
|
||||
"jeija_fpga_sides.png",
|
||||
"jeija_fpga_sides.png"
|
||||
},
|
||||
inventory_image = "", -- replaced later
|
||||
is_ground_content = false,
|
||||
sunlight_propagates = true,
|
||||
paramtype = "light",
|
||||
walkable = true,
|
||||
groups = {dig_immediate = 2, mesecon = 3, overheat = 1},
|
||||
drop = "mesecons_fpga:fpga0000",
|
||||
selection_box = {
|
||||
type = "fixed",
|
||||
fixed = { -8/16, -8/16, -8/16, 8/16, -5/16, 8/16 },
|
||||
},
|
||||
node_box = {
|
||||
type = "fixed",
|
||||
fixed = {
|
||||
{ -8/16, -8/16, -8/16, 8/16, -7/16, 8/16 }, -- bottom slab
|
||||
{ -5/16, -7/16, -5/16, 5/16, -6/16, 5/16 }, -- circuit board
|
||||
{ -3/16, -6/16, -3/16, 3/16, -5/16, 3/16 }, -- IC
|
||||
}
|
||||
},
|
||||
on_construct = function(pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
local is = { {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {} }
|
||||
|
||||
meta:set_string("instr", lcore.serialize(is))
|
||||
meta:set_int("valid", 0)
|
||||
meta:set_string("infotext", "FPGA")
|
||||
end,
|
||||
on_rightclick = function(pos, _, clicker)
|
||||
if not minetest.is_player(clicker) then
|
||||
return
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local name = clicker:get_player_name()
|
||||
-- Erase formspecs of old FPGAs
|
||||
meta:set_string("formspec", "")
|
||||
|
||||
plg.open_formspecs[name] = pos
|
||||
local is = lcore.deserialize(meta:get_string("instr"))
|
||||
minetest.show_formspec(name, "mesecons:fpga", plg.to_formspec_string(is, nil))
|
||||
end,
|
||||
sounds = mesecon.node_sound.stone,
|
||||
mesecons = {
|
||||
effector = {
|
||||
rules = {}, -- replaced later
|
||||
action_change = function(pos, _, rule, newstate)
|
||||
if plg.ports_changed(pos, rule, newstate) then
|
||||
plg.update(pos)
|
||||
end
|
||||
end
|
||||
}
|
||||
},
|
||||
after_dig_node = function(pos, node)
|
||||
mesecon.receptor_off(pos, plg.rules[node.name])
|
||||
for name, open_pos in pairs(plg.open_formspecs) do
|
||||
if vector.equals(pos, open_pos) then
|
||||
minetest.close_formspec(name, "mesecons:fpga")
|
||||
plg.open_formspecs[name] = nil
|
||||
end
|
||||
end
|
||||
end,
|
||||
on_blast = mesecon.on_blastnode,
|
||||
on_rotate = function(pos, _, user, mode)
|
||||
local abcd1 = {"A", "B", "C", "D"}
|
||||
local abcd2 = {A = 1, B = 2, C = 3, D = 4}
|
||||
local ops = {"op1", "op2", "dst"}
|
||||
local dir = 0
|
||||
if mode == screwdriver.ROTATE_FACE then -- clock-wise
|
||||
dir = 1
|
||||
if user and user:is_player() then
|
||||
minetest.chat_send_player(user:get_player_name(),
|
||||
"FPGA ports have been rotated clockwise.")
|
||||
end
|
||||
elseif mode == screwdriver.ROTATE_AXIS then -- counter-clockwise
|
||||
dir = -1
|
||||
if user and user:is_player() then
|
||||
minetest.chat_send_player(user:get_player_name(),
|
||||
"FPGA ports have been rotated counter-clockwise.")
|
||||
end
|
||||
end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
local instr = lcore.deserialize(meta:get_string("instr"))
|
||||
for i = 1, #instr do
|
||||
for _, op in ipairs(ops) do
|
||||
local o = instr[i][op]
|
||||
if o and o.type == "io" then
|
||||
local num = abcd2[o.port]
|
||||
num = num + dir
|
||||
if num > 4 then num = 1
|
||||
elseif num < 1 then num = 4 end
|
||||
instr[i][op].port = abcd1[num]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
meta:set_string("instr", lcore.serialize(instr))
|
||||
plg.update_meta(pos, instr)
|
||||
return true
|
||||
end,
|
||||
})
|
||||
|
||||
plg.to_formspec_string = function(is, err)
|
||||
local function dropdown_op(x, y, name, val)
|
||||
local s = "dropdown[" .. tostring(x) .. "," .. tostring(y) .. ";"
|
||||
.. "0.75,0.5;" .. name .. ";" -- the height seems to be ignored?
|
||||
s = s .. " ,A,B,C,D,0,1,2,3,4,5,6,7,8,9;"
|
||||
if val == nil then
|
||||
s = s .. "0" -- actually selects no field at all
|
||||
elseif val.type == "io" then
|
||||
local mapping = {
|
||||
["A"] = 1,
|
||||
["B"] = 2,
|
||||
["C"] = 3,
|
||||
["D"] = 4,
|
||||
}
|
||||
s = s .. tostring(1 + mapping[val.port])
|
||||
else -- "reg"
|
||||
s = s .. tostring(6 + val.n)
|
||||
end
|
||||
return s .. "]"
|
||||
end
|
||||
local function dropdown_action(x, y, name, val)
|
||||
local selected = 0
|
||||
local titles = { " " }
|
||||
for i, data in ipairs(lcore.get_operations()) do
|
||||
titles[i + 1] = data.fs_name
|
||||
if val == data.gate then
|
||||
selected = i + 1
|
||||
end
|
||||
end
|
||||
return ("dropdown[%f,%f;1.125,0.5;%s;%s;%i]"):format(
|
||||
x, y, name, table.concat(titles, ","), selected)
|
||||
end
|
||||
local s = "size[9,9]"..
|
||||
"label[3.4,-0.15;FPGA gate configuration]"..
|
||||
"button[7,7.5;2,2.5;program;Program]"..
|
||||
"box[4.2,0.5;0.03,7;#ffffff]"..
|
||||
"label[0.25,0.25;op. 1]"..
|
||||
"label[1.0,0.25;gate type]"..
|
||||
"label[2.125,0.25;op. 2]"..
|
||||
"label[3.15,0.25;dest]"..
|
||||
"label[4.5,0.25;op. 1]"..
|
||||
"label[5.25,0.25;gate type]"..
|
||||
"label[6.375,0.25;op. 2]"..
|
||||
"label[7.4,0.25;dest]"
|
||||
local x = 1 - 0.75
|
||||
local y = 1 - 0.25
|
||||
for i = 1, 14 do
|
||||
local cur = is[i]
|
||||
s = s .. dropdown_op (x , y, tostring(i).."op1", cur.op1)
|
||||
s = s .. dropdown_action(x+0.75 , y, tostring(i).."act", cur.action)
|
||||
s = s .. dropdown_op (x+1.875, y, tostring(i).."op2", cur.op2)
|
||||
s = s .. "label[" .. tostring(x+2.625) .. "," .. tostring(y+0.1) .. "; ->]"
|
||||
s = s .. dropdown_op (x+2.9 , y, tostring(i).."dst", cur.dst)
|
||||
y = y + 1
|
||||
|
||||
if i == 7 then
|
||||
x = 4.5
|
||||
y = 1 - 0.25
|
||||
end
|
||||
end
|
||||
if err then
|
||||
local fmsg = minetest.colorize("#ff0000", minetest.formspec_escape(err.msg))
|
||||
s = s .. plg.red_box_around(err.i) ..
|
||||
"label[0.25,8.25;The gate configuration is erroneous in the marked area:]"..
|
||||
"label[0.25,8.5;" .. fmsg .. "]"
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
plg.from_formspec_fields = function(fields)
|
||||
local function read_op(s)
|
||||
if s == nil or s == " " then
|
||||
return nil
|
||||
elseif s == "A" or s == "B" or s == "C" or s == "D" then
|
||||
return {type = "io", port = s}
|
||||
else
|
||||
return {type = "reg", n = tonumber(s)}
|
||||
end
|
||||
end
|
||||
local function read_action(s)
|
||||
for i, data in ipairs(lcore.get_operations()) do
|
||||
if data.fs_name == s then
|
||||
return data.gate
|
||||
end
|
||||
end
|
||||
end
|
||||
local is = {}
|
||||
for i = 1, 14 do
|
||||
local cur = {}
|
||||
cur.op1 = read_op(fields[tonumber(i) .. "op1"])
|
||||
cur.action = read_action(fields[tonumber(i) .. "act"])
|
||||
cur.op2 = read_op(fields[tonumber(i) .. "op2"])
|
||||
cur.dst = read_op(fields[tonumber(i) .. "dst"])
|
||||
is[#is + 1] = cur
|
||||
end
|
||||
return is
|
||||
end
|
||||
|
||||
plg.update_meta = function(pos, is)
|
||||
if type(is) == "string" then -- serialized string
|
||||
is = lcore.deserialize(is)
|
||||
end
|
||||
local meta = minetest.get_meta(pos)
|
||||
|
||||
local err = lcore.validate(is)
|
||||
if err == nil then
|
||||
meta:set_int("valid", 1)
|
||||
meta:set_string("infotext", "FPGA (functional)")
|
||||
else
|
||||
meta:set_int("valid", 0)
|
||||
meta:set_string("infotext", "FPGA")
|
||||
end
|
||||
|
||||
-- reset ports and run programmed logic
|
||||
plg.setports(pos, false, false, false, false)
|
||||
plg.update(pos)
|
||||
|
||||
-- Refresh open formspecs
|
||||
local form = plg.to_formspec_string(is, err)
|
||||
for name, open_pos in pairs(plg.open_formspecs) do
|
||||
if vector.equals(pos, open_pos) then
|
||||
minetest.show_formspec(name, "mesecons:fpga", form)
|
||||
end
|
||||
end
|
||||
return err
|
||||
end
|
||||
|
||||
plg.red_box_around = function(i)
|
||||
local x, y
|
||||
if i > 7 then
|
||||
x = 4.5
|
||||
y = 0.75 + (i - 8)
|
||||
else
|
||||
x = 0.25
|
||||
y = 0.75 + (i - 1)
|
||||
end
|
||||
return string.format("box[%f,%f;3.8,0.8;#ff0000]", x-0.1, y-0.05)
|
||||
end
|
||||
|
||||
|
||||
plg.update = function(pos)
|
||||
local meta = minetest.get_meta(pos)
|
||||
if meta:get_int("valid") ~= 1 then
|
||||
return
|
||||
elseif mesecon.do_overheat(pos) then
|
||||
plg.setports(pos, false, false, false, false)
|
||||
meta:set_int("valid", 0)
|
||||
meta:set_string("infotext", "FPGA (overheated)")
|
||||
return
|
||||
end
|
||||
|
||||
local is = lcore.deserialize(meta:get_string("instr"))
|
||||
local A, B, C, D = plg.getports(pos)
|
||||
A, B, C, D = lcore.interpret(is, A, B, C, D)
|
||||
plg.setports(pos, A, B, C, D)
|
||||
end
|
||||
|
||||
-- Updates the port states according to the signal change.
|
||||
-- Returns whether the port states actually changed.
|
||||
plg.ports_changed = function(pos, rule, newstate)
|
||||
if rule == nil then return false end
|
||||
local meta = minetest.get_meta(pos)
|
||||
local states
|
||||
|
||||
local s = meta:get_string("portstates")
|
||||
if s == nil then
|
||||
states = {false, false, false, false}
|
||||
else
|
||||
states = {
|
||||
s:sub(1, 1) == "1",
|
||||
s:sub(2, 2) == "1",
|
||||
s:sub(3, 3) == "1",
|
||||
s:sub(4, 4) == "1",
|
||||
}
|
||||
end
|
||||
|
||||
-- trick to transform rules (see register_node) into port number
|
||||
local portno = ({4, 1, nil, 3, 2})[3 + rule.x + 2*rule.z]
|
||||
states[portno] = (newstate == "on")
|
||||
|
||||
local new_portstates =
|
||||
(states[1] and "1" or "0") .. (states[2] and "1" or "0") ..
|
||||
(states[3] and "1" or "0") .. (states[4] and "1" or "0")
|
||||
if new_portstates ~= s then
|
||||
meta:set_string("portstates", new_portstates)
|
||||
return true
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
plg.getports = function(pos) -- gets merged states of INPUT & OUTPUT
|
||||
local sin, sout
|
||||
|
||||
local s = minetest.get_meta(pos):get_string("portstates")
|
||||
if s == nil then
|
||||
sin = {false, false, false, false}
|
||||
else
|
||||
sin = {
|
||||
s:sub(1, 1) == "1",
|
||||
s:sub(2, 2) == "1",
|
||||
s:sub(3, 3) == "1",
|
||||
s:sub(4, 4) == "1",
|
||||
}
|
||||
end
|
||||
|
||||
local name = minetest.get_node(pos).name
|
||||
assert(name:find("mesecons_fpga:fpga") == 1)
|
||||
local off = #"mesecons_fpga:fpga"
|
||||
sout = {
|
||||
name:sub(off+4, off+4) == "1",
|
||||
name:sub(off+3, off+3) == "1",
|
||||
name:sub(off+2, off+2) == "1",
|
||||
name:sub(off+1, off+1) == "1",
|
||||
}
|
||||
|
||||
return unpack({
|
||||
sin[1] or sout[1],
|
||||
sin[2] or sout[2],
|
||||
sin[3] or sout[3],
|
||||
sin[4] or sout[4],
|
||||
})
|
||||
end
|
||||
|
||||
plg.setports = function(pos, A, B, C, D) -- sets states of OUTPUT
|
||||
local base = "mesecons_fpga:fpga"
|
||||
|
||||
local name = base
|
||||
.. (D and "1" or "0") .. (C and "1" or "0")
|
||||
.. (B and "1" or "0") .. (A and "1" or "0")
|
||||
minetest.swap_node(pos, {name = name, param2 = minetest.get_node(pos).param2})
|
||||
|
||||
if A ~= nil then
|
||||
local ru = plg.rules[base .. "0001"]
|
||||
if A then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
|
||||
end
|
||||
if B ~= nil then
|
||||
local ru = plg.rules[base .. "0010"]
|
||||
if B then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
|
||||
end
|
||||
if C ~= nil then
|
||||
local ru = plg.rules[base .. "0100"]
|
||||
if C then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
|
||||
end
|
||||
if D ~= nil then
|
||||
local ru = plg.rules[base .. "1000"]
|
||||
if D then mesecon.receptor_on(pos, ru) else mesecon.receptor_off(pos, ru) end
|
||||
end
|
||||
end
|
||||
|
||||
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
||||
local player_name = player:get_player_name()
|
||||
|
||||
if formname ~= "mesecons:fpga" or fields.quit then
|
||||
plg.open_formspecs[player_name] = nil -- potential garbage
|
||||
return
|
||||
end
|
||||
if not fields.program then
|
||||
return -- we only care when the user clicks "Program"
|
||||
end
|
||||
local pos = plg.open_formspecs[player_name]
|
||||
if minetest.is_protected(pos, player_name) then
|
||||
minetest.record_protection_violation(pos, player_name)
|
||||
return
|
||||
end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
local is = plg.from_formspec_fields(fields)
|
||||
|
||||
meta:set_string("instr", lcore.serialize(is))
|
||||
local err = plg.update_meta(pos, is)
|
||||
|
||||
if not err then
|
||||
plg.open_formspecs[player_name] = nil
|
||||
-- Close on success
|
||||
minetest.close_formspec(player_name, "mesecons:fpga")
|
||||
end
|
||||
end)
|
||||
|
||||
minetest.register_on_leaveplayer(function(player)
|
||||
plg.open_formspecs[player:get_player_name()] = nil
|
||||
end)
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_fpga:fpga0000 2",
|
||||
recipe = {
|
||||
{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable'},
|
||||
{'mesecons_materials:silicon', 'mesecons_materials:silicon'},
|
||||
{'group:mesecon_conductor_craftable', 'group:mesecon_conductor_craftable'},
|
||||
}
|
||||
})
|
||||
@@ -0,0 +1,3 @@
|
||||
# textdomain: mesecons_fpga
|
||||
FPGA=FPGA
|
||||
FPGA Programmer=FPGA-Programmierer
|
||||
@@ -0,0 +1,7 @@
|
||||
# textdomain: mesecons_fpga
|
||||
|
||||
### init.lua ###
|
||||
FPGA=FPGA
|
||||
|
||||
### tool.lua ###
|
||||
FPGA Programmer=FPGA Programilo
|
||||
@@ -0,0 +1,7 @@
|
||||
# textdomain: mesecons_fpga
|
||||
|
||||
### init.lua ###
|
||||
FPGA=Circuit logique programmable (FPGA)
|
||||
|
||||
### tool.lua ###
|
||||
FPGA Programmer=Programmateur de circuit logique
|
||||
@@ -0,0 +1,7 @@
|
||||
# textdomain: mesecons_fpga
|
||||
|
||||
### init.lua ###
|
||||
FPGA=ПЛИС
|
||||
|
||||
### tool.lua ###
|
||||
FPGA Programmer=ПЛИС-программер
|
||||
@@ -0,0 +1,7 @@
|
||||
# textdomain: mesecons_fpga
|
||||
|
||||
### init.lua ###
|
||||
FPGA=ПКВМ
|
||||
|
||||
### tool.lua ###
|
||||
FPGA Programmer=ПКВМ-программер
|
||||
@@ -0,0 +1,7 @@
|
||||
# textdomain: mesecons_fpga
|
||||
|
||||
### init.lua ###
|
||||
FPGA=
|
||||
|
||||
### tool.lua ###
|
||||
FPGA Programmer=
|
||||
@@ -0,0 +1,222 @@
|
||||
|
||||
local lg = {}
|
||||
|
||||
local operations = {
|
||||
-- table index: Index in the formspec dropdown
|
||||
-- gate: Internal name
|
||||
-- short: Serialized form, single character
|
||||
-- fs_name: Display name, padded to 4 characters
|
||||
-- func: Function that applies the operation
|
||||
-- unary: Whether this gate only has one input
|
||||
{ gate = "and", short = "&", fs_name = " AND", func = function(a, b) return a and b end },
|
||||
{ gate = "or", short = "|", fs_name = " OR", func = function(a, b) return a or b end },
|
||||
{ gate = "not", short = "~", fs_name = " NOT", func = function(_, b) return not b end, unary = true },
|
||||
{ gate = "xor", short = "^", fs_name = " XOR", func = function(a, b) return a ~= b end },
|
||||
{ gate = "nand", short = "?", fs_name = "NAND", func = function(a, b) return not (a and b) end },
|
||||
{ gate = "buf", short = "_", fs_name = " =", func = function(_, b) return b end, unary = true },
|
||||
{ gate = "xnor", short = "=", fs_name = "XNOR", func = function(a, b) return a == b end },
|
||||
{ gate = "nor", short = "!", fs_name = " NOR", func = function(a, b) return not (a or b) end },
|
||||
}
|
||||
|
||||
lg.get_operations = function()
|
||||
return operations
|
||||
end
|
||||
|
||||
-- (de)serialize
|
||||
lg.serialize = function(t)
|
||||
local function _op(t)
|
||||
if t == nil then
|
||||
return " "
|
||||
elseif t.type == "io" then
|
||||
return t.port
|
||||
else -- t.type == "reg"
|
||||
return tostring(t.n)
|
||||
end
|
||||
end
|
||||
-- Serialize actions (gates) from eg. "and" to "&"
|
||||
local function _action(action)
|
||||
for i, data in ipairs(operations) do
|
||||
if data.gate == action then
|
||||
return data.short
|
||||
end
|
||||
end
|
||||
return " "
|
||||
end
|
||||
|
||||
local s = ""
|
||||
for i = 1, 14 do
|
||||
local cur = t[i]
|
||||
if next(cur) ~= nil then
|
||||
s = s .. _op(cur.op1) .. _action(cur.action) .. _op(cur.op2) .. _op(cur.dst)
|
||||
end
|
||||
s = s .. "/"
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
lg.deserialize = function(s)
|
||||
local function _op(c)
|
||||
if c == "A" or c == "B" or c == "C" or c == "D" then
|
||||
return {type = "io", port = c}
|
||||
elseif c == " " then
|
||||
return nil
|
||||
else
|
||||
return {type = "reg", n = tonumber(c)}
|
||||
end
|
||||
end
|
||||
-- Deserialize actions (gates) from eg. "&" to "and"
|
||||
local function _action(action)
|
||||
for i, data in ipairs(operations) do
|
||||
if data.short == action then
|
||||
return data.gate
|
||||
end
|
||||
end
|
||||
-- nil
|
||||
end
|
||||
|
||||
local ret = {}
|
||||
for part in s:gmatch("(.-)/") do
|
||||
local parsed
|
||||
if part == "" then
|
||||
parsed = {}
|
||||
else
|
||||
parsed = {
|
||||
action = _action( part:sub(2,2) ),
|
||||
op1 = _op( part:sub(1,1) ),
|
||||
op2 = _op( part:sub(3,3) ),
|
||||
dst = _op( part:sub(4,4) ),
|
||||
}
|
||||
end
|
||||
ret[#ret + 1] = parsed
|
||||
end
|
||||
-- More than 14 instructions (write to all 10 regs + 4 outputs)
|
||||
-- will not pass the write-once requirement of the validator
|
||||
assert(#ret == 14)
|
||||
return ret
|
||||
end
|
||||
|
||||
-- validation
|
||||
lg.validate_single = function(t, i)
|
||||
local function is_reg_written_to(t, n, max)
|
||||
for i = 1, max-1 do
|
||||
if next(t[i]) ~= nil
|
||||
and t[i].dst and t[i].dst.type == "reg"
|
||||
and t[i].dst.n == n then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
local function compare_op(t1, t2, allow_same_io)
|
||||
if t1 == nil or t2 == nil then
|
||||
return false
|
||||
elseif t1.type ~= t2.type then
|
||||
return false
|
||||
end
|
||||
if t1.type == "reg" and t1.n == t2.n then
|
||||
return true
|
||||
elseif t1.type == "io" and t1.port == t2.port then
|
||||
return not allow_same_io
|
||||
end
|
||||
return false
|
||||
end
|
||||
local elem = t[i]
|
||||
|
||||
local gate_data
|
||||
for j, data in ipairs(operations) do
|
||||
if data.gate == elem.action then
|
||||
gate_data = data
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
-- check for completeness
|
||||
if not gate_data then
|
||||
return {i = i, msg = "Gate type is required"}
|
||||
elseif gate_data.unary then
|
||||
if elem.op1 ~= nil or elem.op2 == nil or elem.dst == nil then
|
||||
return {i = i, msg = "Second operand (only) and destination are required"}
|
||||
end
|
||||
else
|
||||
if elem.op1 == nil or elem.op2 == nil or elem.dst == nil then
|
||||
return {i = i, msg = "Operands and destination are required"}
|
||||
end
|
||||
end
|
||||
-- check whether operands/destination are identical
|
||||
if compare_op(elem.op1, elem.op2) then
|
||||
return {i = i, msg = "Operands cannot be identical"}
|
||||
end
|
||||
if compare_op(elem.op1, elem.dst, true) or compare_op(elem.op2, elem.dst, true) then
|
||||
return {i = i, msg = "Destination and operands must be different"}
|
||||
end
|
||||
-- check whether operands point to defined registers
|
||||
if elem.op1 ~= nil and elem.op1.type == "reg"
|
||||
and not is_reg_written_to(t, elem.op1.n, i) then
|
||||
return {i = i, msg = "First operand is undefined register"}
|
||||
end
|
||||
if elem.op2.type == "reg" and not is_reg_written_to(t, elem.op2.n, i) then
|
||||
return {i = i, msg = "Second operand is undefined register"}
|
||||
end
|
||||
-- check whether destination points to undefined register
|
||||
if elem.dst.type == "reg" and is_reg_written_to(t, elem.dst.n, i) then
|
||||
return {i = i, msg = "Destination is already used register"}
|
||||
end
|
||||
|
||||
return nil
|
||||
end
|
||||
|
||||
lg.validate = function(t)
|
||||
for i = 1, 14 do
|
||||
if next(t[i]) ~= nil then
|
||||
local r = lg.validate_single(t, i)
|
||||
if r ~= nil then
|
||||
return r
|
||||
end
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- interpreter
|
||||
lg.interpret = function(t, a, b, c, d)
|
||||
local function _action(s, v1, v2)
|
||||
for i, data in ipairs(operations) do
|
||||
if data.gate == s then
|
||||
return data.func(v1, v2)
|
||||
end
|
||||
end
|
||||
return false -- unknown gate
|
||||
end
|
||||
local function _op(t, regs, io_in)
|
||||
if t.type == "reg" then
|
||||
return regs[t.n]
|
||||
else -- t.type == "io"
|
||||
return io_in[t.port]
|
||||
end
|
||||
end
|
||||
|
||||
local io_in = {A=a, B=b, C=c, D=d}
|
||||
local regs = {}
|
||||
local io_out = {}
|
||||
for i = 1, 14 do
|
||||
local cur = t[i]
|
||||
if next(cur) ~= nil then
|
||||
local v1, v2
|
||||
if cur.op1 ~= nil then
|
||||
v1 = _op(cur.op1, regs, io_in)
|
||||
end
|
||||
v2 = _op(cur.op2, regs, io_in)
|
||||
|
||||
local result = _action(cur.action, v1, v2)
|
||||
|
||||
if cur.dst.type == "reg" then
|
||||
regs[cur.dst.n] = result
|
||||
else -- cur.dst.type == "io"
|
||||
io_out[cur.dst.port] = result
|
||||
end
|
||||
end
|
||||
end
|
||||
return io_out.A, io_out.B, io_out.C, io_out.D
|
||||
end
|
||||
|
||||
return lg
|
||||
@@ -0,0 +1,3 @@
|
||||
name = mesecons_fpga
|
||||
depends = mesecons, mesecons_gamecompat
|
||||
optional_depends = screwdriver
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,106 @@
|
||||
require("mineunit")
|
||||
|
||||
fixture("mesecons_fpga")
|
||||
fixture("screwdriver")
|
||||
|
||||
local pos = {x = 0, y = 0, z = 0}
|
||||
local pos_a = {x = -1, y = 0, z = 0}
|
||||
local pos_b = {x = 0, y = 0, z = 1}
|
||||
local pos_c = {x = 1, y = 0, z = 0}
|
||||
local pos_d = {x = 0, y = 0, z = -1}
|
||||
|
||||
describe("FPGA rotation", function()
|
||||
before_each(function()
|
||||
world.set_node(pos, "mesecons_fpga:fpga0000")
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("rotates I/O operands clockwise", function()
|
||||
mesecon._test_program_fpga(pos, {{"A", "OR", "B", "C"}})
|
||||
|
||||
local node = world.get_node(pos)
|
||||
minetest.registered_nodes[node.name].on_rotate(pos, node, nil, screwdriver.ROTATE_FACE)
|
||||
|
||||
mesecon._test_place(pos_b, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
|
||||
|
||||
mesecon._test_dig(pos_b)
|
||||
mesecon._test_place(pos_c, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
|
||||
mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
|
||||
assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("rotates I/O operands counterclockwise", function()
|
||||
mesecon._test_program_fpga(pos, {{"A", "OR", "B", "C"}})
|
||||
|
||||
local node = world.get_node(pos)
|
||||
minetest.registered_nodes[node.name].on_rotate(pos, node, nil, screwdriver.ROTATE_AXIS)
|
||||
|
||||
mesecon._test_place(pos_d, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
|
||||
mesecon._test_dig(pos_d)
|
||||
mesecon._test_place(pos_a, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
|
||||
mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("updates ports", function()
|
||||
mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
|
||||
local node = world.get_node(pos)
|
||||
minetest.registered_nodes[node.name].on_rotate(pos, node, nil, screwdriver.ROTATE_AXIS)
|
||||
assert.equal("mesecons_fpga:fpga0001", world.get_node(pos).name)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe("FPGA programmer", function()
|
||||
local pos2 = {x = 10, y = 0, z = 0}
|
||||
|
||||
before_each(function()
|
||||
world.set_node(pos, "mesecons_fpga:fpga0000")
|
||||
world.set_node(pos2, "mesecons_fpga:fpga0000")
|
||||
end)
|
||||
|
||||
after_each(function()
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
end)
|
||||
|
||||
it("transfers instructions", function()
|
||||
mesecon._test_program_fpga(pos2, {{"NOT", "A", "B"}})
|
||||
mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(pos2))
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("does not copy from new FPGAs", function()
|
||||
mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
|
||||
mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(pos2))
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("does not copy from cleared FPGAs", function()
|
||||
mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
|
||||
mesecon._test_program_fpga(pos2, {{"=", "A", "B"}})
|
||||
mesecon._test_program_fpga(pos2, {})
|
||||
mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(pos2))
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
end)
|
||||
|
||||
it("does not copy from non-FPGA nodes", function()
|
||||
mesecon._test_program_fpga(pos, {{"NOT", "A", "B"}})
|
||||
mesecon._test_paste_fpga_program(pos, mesecon._test_copy_fpga_program(vector.add(pos2, 1)))
|
||||
assert.equal("mesecons_fpga:fpga0010", world.get_node(pos).name)
|
||||
end)
|
||||
end)
|
||||
@@ -0,0 +1,235 @@
|
||||
require("mineunit")
|
||||
|
||||
fixture("mesecons_fpga")
|
||||
|
||||
describe("FPGA logic", function()
|
||||
local pos = {x = 0, y = 0, z = 0}
|
||||
local pos_a = {x = -1, y = 0, z = 0}
|
||||
local pos_b = {x = 0, y = 0, z = 1}
|
||||
local pos_c = {x = 1, y = 0, z = 0}
|
||||
local pos_d = {x = 0, y = 0, z = -1}
|
||||
|
||||
local fpga_set = false
|
||||
|
||||
local function set_fpga()
|
||||
if not fpga_set then
|
||||
world.set_node(pos, "mesecons_fpga:fpga0000")
|
||||
fpga_set = true
|
||||
end
|
||||
end
|
||||
before_each(set_fpga)
|
||||
|
||||
local function reset_world()
|
||||
if fpga_set then
|
||||
mesecon._test_reset()
|
||||
world.clear()
|
||||
fpga_set = false
|
||||
end
|
||||
end
|
||||
after_each(reset_world)
|
||||
|
||||
local function test_program(inputs, outputs, program)
|
||||
set_fpga()
|
||||
|
||||
mesecon._test_program_fpga(pos, program)
|
||||
|
||||
if inputs.a then mesecon._test_place(pos_a, "mesecons:test_receptor_on") end
|
||||
if inputs.b then mesecon._test_place(pos_b, "mesecons:test_receptor_on") end
|
||||
if inputs.c then mesecon._test_place(pos_c, "mesecons:test_receptor_on") end
|
||||
if inputs.d then mesecon._test_place(pos_d, "mesecons:test_receptor_on") end
|
||||
mineunit:execute_globalstep() -- Execute receptor_on actions
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
|
||||
local expected_name = "mesecons_fpga:fpga"
|
||||
.. (outputs.d and 1 or 0) .. (outputs.c and 1 or 0)
|
||||
.. (outputs.b and 1 or 0) .. (outputs.a and 1 or 0)
|
||||
assert.equal(expected_name, world.get_node(pos).name)
|
||||
|
||||
reset_world()
|
||||
end
|
||||
|
||||
it("operator and", function()
|
||||
local prog = {{"A", "AND", "B", "C"}}
|
||||
test_program({}, {}, prog)
|
||||
test_program({a = true}, {}, prog)
|
||||
test_program({b = true}, {}, prog)
|
||||
test_program({a = true, b = true}, {c = true}, prog)
|
||||
end)
|
||||
|
||||
it("operator or", function()
|
||||
local prog = {{"A", "OR", "B", "C"}}
|
||||
test_program({}, {}, prog)
|
||||
test_program({a = true}, {c = true}, prog)
|
||||
test_program({b = true}, {c = true}, prog)
|
||||
test_program({a = true, b = true}, {c = true}, prog)
|
||||
end)
|
||||
|
||||
it("operator not", function()
|
||||
local prog = {{"NOT", "A", "B"}}
|
||||
test_program({}, {b = true}, prog)
|
||||
test_program({a = true}, {}, prog)
|
||||
end)
|
||||
|
||||
it("operator xor", function()
|
||||
local prog = {{"A", "XOR", "B", "C"}}
|
||||
test_program({}, {}, prog)
|
||||
test_program({a = true}, {c = true}, prog)
|
||||
test_program({b = true}, {c = true}, prog)
|
||||
test_program({a = true, b = true}, {}, prog)
|
||||
end)
|
||||
|
||||
it("operator nand", function()
|
||||
local prog = {{"A", "NAND", "B", "C"}}
|
||||
test_program({}, {c = true}, prog)
|
||||
test_program({a = true}, {c = true}, prog)
|
||||
test_program({b = true}, {c = true}, prog)
|
||||
test_program({a = true, b = true}, {}, prog)
|
||||
end)
|
||||
|
||||
it("operator buf", function()
|
||||
local prog = {{"=", "A", "B"}}
|
||||
test_program({}, {}, prog)
|
||||
test_program({a = true}, {b = true}, prog)
|
||||
end)
|
||||
|
||||
it("operator xnor", function()
|
||||
local prog = {{"A", "XNOR", "B", "C"}}
|
||||
test_program({}, {c = true}, prog)
|
||||
test_program({a = true}, {}, prog)
|
||||
test_program({b = true}, {}, prog)
|
||||
test_program({a = true, b = true}, {c = true}, prog)
|
||||
end)
|
||||
|
||||
it("operator nor", function()
|
||||
local prog = {{"A", "NOR", "B", "C"}}
|
||||
test_program({}, {c = true}, prog)
|
||||
test_program({a = true}, {}, prog)
|
||||
test_program({b = true}, {}, prog)
|
||||
test_program({a = true, b = true}, {}, prog)
|
||||
end)
|
||||
|
||||
it("rejects duplicate operands", function()
|
||||
test_program({a = true}, {}, {{"A", "OR", "A", "B"}})
|
||||
test_program({a = true}, {}, {{"=", "A", "0"}, {"0", "OR", "0", "B"}})
|
||||
end)
|
||||
|
||||
it("rejects unassigned memory operands", function()
|
||||
test_program({a = true}, {}, {{"A", "OR", "0", "B"}})
|
||||
test_program({a = true}, {}, {{"0", "OR", "A", "B"}})
|
||||
end)
|
||||
|
||||
it("rejects double memory assignment", function()
|
||||
test_program({a = true}, {}, {{"=", "A", "0"}, {"=", "A", "0"}, {"=", "0", "B"}})
|
||||
end)
|
||||
|
||||
it("rejects assignment to memory operand", function()
|
||||
test_program({a = true}, {}, {{"=", "A", "0"}, {"A", "OR", "0", "0"}, {"=", "0", "B"}})
|
||||
end)
|
||||
|
||||
it("allows double port assignment", function()
|
||||
test_program({a = true}, {b = true}, {{"NOT", "A", "B"}, {"=", "A", "B"}})
|
||||
end)
|
||||
|
||||
it("allows assignment to port operand", function()
|
||||
test_program({a = true}, {b = true}, {{"A", "OR", "B", "B"}})
|
||||
end)
|
||||
|
||||
it("preserves initial pin states", function()
|
||||
test_program({a = true}, {b = true}, {{"=", "A", "B"}, {"=", "B", "C"}})
|
||||
end)
|
||||
|
||||
it("rejects binary operations with single operands", function()
|
||||
test_program({a = true}, {}, {{"=", "A", "B"}, {" ", "OR", "A", "C"}})
|
||||
test_program({a = true}, {}, {{"=", "A", "B"}, {"A", "OR", " ", "C"}})
|
||||
end)
|
||||
|
||||
it("rejects unary operations with first operands", function()
|
||||
test_program({a = true}, {}, {{"=", "A", "B"}, {"A", "=", " ", "C"}})
|
||||
end)
|
||||
|
||||
it("rejects operations without destinations", function()
|
||||
test_program({a = true}, {}, {{"=", "A", "B"}, {"=", "A", " "}})
|
||||
end)
|
||||
|
||||
it("allows blank statements", function()
|
||||
test_program({a = true}, {b = true, c = true}, {
|
||||
{" ", " ", " ", " "},
|
||||
{"=", "A", "B"},
|
||||
{" ", " ", " ", " "},
|
||||
{" ", " ", " ", " "},
|
||||
{"=", "A", "C"},
|
||||
})
|
||||
end)
|
||||
|
||||
it("transmits output signals to adjacent nodes", function()
|
||||
mesecon._test_program_fpga(pos, {
|
||||
{"=", "A", "B"},
|
||||
{"=", "A", "C"},
|
||||
{"NOT", "A", "D"},
|
||||
})
|
||||
mesecon._test_place(pos_b, "mesecons:test_effector")
|
||||
mesecon._test_place(pos_c, "mesecons:test_effector")
|
||||
mesecon._test_place(pos_d, "mesecons:test_effector")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on actions
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
|
||||
-- Makes an object from the last three effector events in the list for use with assert.same.
|
||||
-- This is necessary to ignore the ordering of events.
|
||||
local function event_tester(list)
|
||||
local o = {list[#list - 2], list[#list - 1], list[#list - 0]}
|
||||
table.sort(o, function(a, b)
|
||||
local fmt = "%s %d %d %d"
|
||||
return fmt:format(a[1], a[2].x, a[2].y, a[2].z) < fmt:format(b[1], b[2].x, b[2].y, b[2].z)
|
||||
end)
|
||||
return o
|
||||
end
|
||||
|
||||
mesecon._test_place(pos_a, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on action
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
|
||||
mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
|
||||
assert.equal("mesecons_fpga:fpga0110", world.get_node(pos).name)
|
||||
assert.same(event_tester({{"on", pos_b}, {"on", pos_c}, {"off", pos_d}}), event_tester(mesecon._test_effector_events))
|
||||
|
||||
mesecon._test_dig(pos_a)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off action
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
mineunit:execute_globalstep() -- Execute receptor_on/receptor_off actions
|
||||
mineunit:execute_globalstep() -- Execute activate/deactivate/change actions
|
||||
assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
|
||||
assert.same(event_tester({{"off", pos_b}, {"off", pos_c}, {"on", pos_d}}), event_tester(mesecon._test_effector_events))
|
||||
end)
|
||||
|
||||
it("considers past outputs in determining inputs", function()
|
||||
-- Memory cell: Turning on A turns on C; turning on B turns off C.
|
||||
mesecon._test_program_fpga(pos, {
|
||||
{"A", "OR", "C", "0"},
|
||||
{"B", "OR", "D", "1"},
|
||||
{"NOT", "A", "2"},
|
||||
{"NOT", "B", "3"},
|
||||
{"0", "AND", "3", "C"},
|
||||
{"1", "AND", "2", "D"},
|
||||
})
|
||||
|
||||
mesecon._test_place(pos_a, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on actions
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal("mesecons_fpga:fpga0100", world.get_node(pos).name)
|
||||
|
||||
mesecon._test_dig(pos_a)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off actions
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal("mesecons_fpga:fpga0100", world.get_node(pos).name)
|
||||
|
||||
mesecon._test_place(pos_b, "mesecons:test_receptor_on")
|
||||
mineunit:execute_globalstep() -- Execute receptor_on actions
|
||||
mineunit:execute_globalstep() -- Execute activate/change actions
|
||||
assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
|
||||
|
||||
mesecon._test_dig(pos_b)
|
||||
mineunit:execute_globalstep() -- Execute receptor_off actions
|
||||
mineunit:execute_globalstep() -- Execute deactivate/change actions
|
||||
assert.equal("mesecons_fpga:fpga1000", world.get_node(pos).name)
|
||||
end)
|
||||
end)
|
||||
@@ -0,0 +1 @@
|
||||
fixture_paths = {"../.test_fixtures"}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 256 B |
Binary file not shown.
|
After Width: | Height: | Size: 480 B |
Binary file not shown.
|
After Width: | Height: | Size: 760 B |
@@ -0,0 +1,73 @@
|
||||
local S = minetest.get_translator(minetest.get_current_modname())
|
||||
|
||||
return function(plg)
|
||||
|
||||
|
||||
minetest.register_tool("mesecons_fpga:programmer", {
|
||||
description = S("FPGA Programmer"),
|
||||
inventory_image = "jeija_fpga_programmer.png",
|
||||
stack_max = 1,
|
||||
on_place = function(itemstack, placer, pointed_thing)
|
||||
if pointed_thing.type ~= "node" then
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local pos = pointed_thing.under
|
||||
if minetest.get_node(pos).name:find("mesecons_fpga:fpga") ~= 1 then
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
if meta:get_string("instr") == "//////////////" then
|
||||
minetest.chat_send_player(placer:get_player_name(), "This FPGA is unprogrammed.")
|
||||
minetest.sound_play("mesecons_fpga_fail", { pos = placer:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
return itemstack
|
||||
end
|
||||
itemstack:get_meta():set_string("", meta:get_string("instr"))
|
||||
minetest.chat_send_player(placer:get_player_name(), "FPGA gate configuration was successfully copied!")
|
||||
minetest.sound_play("mesecons_fpga_copy", { pos = placer:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
|
||||
return itemstack
|
||||
end,
|
||||
on_use = function(itemstack, user, pointed_thing)
|
||||
if pointed_thing.type ~= "node" then
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local pos = pointed_thing.under
|
||||
if minetest.get_node(pos).name:find("mesecons_fpga:fpga") ~= 1 then
|
||||
return itemstack
|
||||
end
|
||||
local player_name = user:get_player_name()
|
||||
if minetest.is_protected(pos, player_name) then
|
||||
minetest.record_protection_violation(pos, player_name)
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local imeta = itemstack:get_meta():get_string("")
|
||||
if imeta == "" then
|
||||
minetest.chat_send_player(player_name, "Use shift+right-click to copy a gate configuration first.")
|
||||
minetest.sound_play("mesecons_fpga_fail", { pos = user:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
return itemstack
|
||||
end
|
||||
|
||||
local meta = minetest.get_meta(pos)
|
||||
meta:set_string("instr", imeta)
|
||||
plg.update_meta(pos, imeta)
|
||||
minetest.chat_send_player(player_name, "Gate configuration was successfully written to FPGA!")
|
||||
minetest.sound_play("mesecons_fpga_write", { pos = user:get_pos(), gain = 0.1, max_hear_distance = 4 }, true)
|
||||
|
||||
return itemstack
|
||||
end
|
||||
})
|
||||
|
||||
minetest.register_craft({
|
||||
output = "mesecons_fpga:programmer",
|
||||
recipe = {
|
||||
{'group:mesecon_conductor_craftable'},
|
||||
{'mesecons_materials:silicon'},
|
||||
}
|
||||
})
|
||||
|
||||
|
||||
end
|
||||
Reference in New Issue
Block a user