aboutsummaryrefslogtreecommitdiff
path: root/advtrains/nodedb.lua
blob: c66479263800444dc1caff3298c9301d4ccf1cff (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
--nodedb.lua
--database of all nodes that have 'save_in_at_nodedb' field set to true in node definition


--serialization format:
--(2byte z) (2byte y) (2byte x) (2byte contentid)
--contentid := (14bit nodeid, 2bit param2)

local function int_to_bytes(i)
	local x=i+32768--clip to positive integers
	local cH = math.floor(x /           256) % 256;
	local cL = math.floor(x                ) % 256;
	return(string.char(cH, cL));
end
local function bytes_to_int(bytes)
	local t={string.byte(bytes,1,-1)}
	local n = 
		t[1] *           256 +
		t[2]
    return n-32768
end
local function l2b(x)
	return x%4
end
local function u14b(x)
	return math.floor(x/4)
end
local ndb={}

--local variables for performance
local ndb_nodeids={}
local ndb_nodes={}
local ndb_ver

local function ndbget(x,y,z)
	local ny=ndb_nodes[y]
	if ny then
		local nx=ny[x]
		if nx then
			return nx[z]
		end
	end
	return nil
end
local function ndbset(x,y,z,v)
	if not ndb_nodes[y] then
		ndb_nodes[y]={}
	end
	if not ndb_nodes[y][x] then
		ndb_nodes[y][x]={}
	end
	ndb_nodes[y][x][z]=v
end

-- load/save

local path_pre_v4=minetest.get_worldpath()..DIR_DELIM.."advtrains_ndb2"
--load pre_v4 format
--nodeids get loaded by advtrains init.lua and passed here
function ndb.load_data_pre_v4(data)
	atlog("nodedb: Loading pre v4 format")

	ndb_nodeids = data and data.nodeids or {}
	ndb_ver = data and data.ver or 0
	if ndb_ver < 1 then
		for k,v in pairs(ndb_nodeids) do
			if v == "advtrains:dtrack_xing4590_st" then
				cidDepr = k
			elseif v == "advtrains:dtrack_xing90plusx_45l" then
				cidNew = k
			end
		end
	end
	local file, err = io.open(path_pre_v4, "rb")
	if not file then
		atwarn("Couldn't load the node database: ", err or "Unknown Error")
	else
		-- Note: code duplication because of weird coordinate order in ndb2 format (z,y,x)
		local cnt=0
		local hst_z=file:read(2)
		local hst_y=file:read(2)
		local hst_x=file:read(2)
		local cid=file:read(2)
		while hst_z and hst_y and hst_x and cid and #hst_z==2 and #hst_y==2 and #hst_x==2 and #cid==2 do
			if (ndb_ver < 1 and cid == cidDepr) then
				cid = cidNew
			end
			ndbset(bytes_to_int(hst_x), bytes_to_int(hst_y), bytes_to_int(hst_z), bytes_to_int(cid))
			cnt=cnt+1
			hst_z=file:read(2)
			hst_y=file:read(2)
			hst_x=file:read(2)
			cid=file:read(2)
		end
		atlog("nodedb (ndb2 format): read", cnt, "nodes.")
		file:close()
	end
	ndb_ver = 1
end

-- the new ndb file format is backported from cellworld, and stores the cids also in the ndb file.
-- These functions have the form of a serialize_lib atomic load/save callback and are called from avt_save/avt_load.
function ndb.load_callback(file)
	-- read version
	local vers_byte = file:read(1)
	local version = string.byte(vers_byte)
	if version~=1 then
		file:close()
		error("Doesn't support v4 nodedb file of version "..version)
	end
	
	-- read cid mappings
	local nstr_byte = file:read(2)
	local nstr = bytes_to_int(nstr_byte)
	for i = 1,nstr do
		local stid_byte = file:read(2)
		local stid = bytes_to_int(stid_byte)
		local stna = file:read("*l")
		--atdebug("content id:", stid, "->", stna)
		ndb_nodeids[stid] = stna
	end
	atlog("[nodedb] read", nstr, "node content ids.")

	-- read nodes
	local cnt=0
	local hst_x=file:read(2)
	local hst_y=file:read(2)
	local hst_z=file:read(2)
	local cid=file:read(2)
	local cidi
	while hst_z and hst_y and hst_x and cid and #hst_z==2 and #hst_y==2 and #hst_x==2 and #cid==2 do
		cidi = bytes_to_int(cid)
		-- prevent file corruption already here
		if not ndb_nodeids[u14b(cidi)] then
			-- clear the ndb data, to reinitialize it
			-- in strict loading mode, doesn't matter as starting will be interrupted anyway
			ndb_nodeids = {}
			ndb_nodes = {}
			error("NDB file is corrupted (found entry with invalid cid)")
		end
		ndbset(bytes_to_int(hst_x), bytes_to_int(hst_y), bytes_to_int(hst_z), cidi)
		cnt=cnt+1
		hst_x=file:read(2)
		hst_y=file:read(2)
		hst_z=file:read(2)
		cid=file:read(2)
	end
	atlog("[nodedb] read", cnt, "nodes.")
	file:close()
end

--save
function ndb.save_callback(data, file)
	--atdebug("storing ndb...")
	-- write version
	file:write(string.char(1))
	
	-- how many cid entries
	local cnt = 0
	for _,_ in pairs(ndb_nodeids) do
		cnt = cnt + 1
	end
	-- write cids
	local nstr = 0
	file:write(int_to_bytes(cnt))
	for stid,stna in pairs(ndb_nodeids) do
		file:write(int_to_bytes(stid))
		file:write(stna)
		file:write("\n")
		nstr = nstr+1
	end
	--atdebug("saved cids count ", nstr)
	
	-- write entries
	local cnt = 0
	for y, ny in pairs(ndb_nodes) do
		for x, nx in pairs(ny) do
			for z, cid in pairs(nx) do
				file:write(int_to_bytes(x))
				file:write(int_to_bytes(y))
				file:write(int_to_bytes(z))
				file:write(int_to_bytes(cid))
				cnt=cnt+1
			end
		end
	end
	--atdebug("saved nodes count ", cnt)
	file:close()
end



--function to get node. track database is not helpful here.
function ndb.get_node_or_nil(pos)
	-- FIX for bug found on linuxworks server:
	-- a loaded node might get read before the LBM has updated its state, resulting in wrongly set signals and switches
	-- -> Using the saved node prioritarily.
	local node = ndb.get_node_raw(pos)
	if node then
		return node
	else
		--try reading the node from the map
		return minetest.get_node_or_nil(pos)
	end
end
function ndb.get_node(pos)
	local n=ndb.get_node_or_nil(pos)
	if not n then
		return {name="ignore", param2=0}
	end
	return n
end
function ndb.get_node_raw(pos)
	local cid=ndbget(pos.x, pos.y, pos.z)
	if cid then
		local nodeid = ndb_nodeids[u14b(cid)]
		if nodeid then
			return {name=nodeid, param2 = l2b(cid)}
		end
	end
	return nil
end


function ndb.swap_node(pos, node, no_inval)
	if advtrains.is_node_loaded(pos) then
		minetest.swap_node(pos, node)
	end
	ndb.update(pos, node)
end

function ndb.update(pos, pnode)
	local node = pnode or minetest.get_node_or_nil(pos)
	if not node or node.name=="ignore" then return end
	if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].groups.save_in_at_nodedb then
		local nid
		for tnid, nname in pairs(ndb_nodeids) do
			if nname==node.name then
				nid=tnid
			end
		end
		if not nid then
			nid=#ndb_nodeids+1
			ndb_nodeids[nid]=node.name
		end
		local resid = (nid * 4) + (l2b(node.param2 or 0))
		ndbset(pos.x, pos.y, pos.z, resid )
		--atdebug("nodedb: updating node", pos, "stored nid",nid,"assigned",ndb_nodeids[nid],"resulting cid",resid)
		advtrains.invalidate_all_paths_ahead(pos)
	else
		--at this position there is no longer a node that needs to be tracked.
		--atdebug("nodedb: updating node", pos, "cleared")
		ndbset(pos.x, pos.y, pos.z, nil)
	end
end

function ndb.clear(pos)
	ndbset(pos.x, pos.y, pos.z, nil)
end


--get_node with pseudoload. now we only need track data, so we can use the trackdb as second fallback
--nothing new will be saved inside the trackdb.
--returns:
--true, conn1, conn2, rely1, rely2, railheight   in case everything's right.
--false  if it's not a rail or the train does not drive on this rail, but it is loaded or
--nil    if the node is neither loaded nor in trackdb
--the distraction between false and nil will be needed only in special cases.(train initpos)
function advtrains.get_rail_info_at(pos, drives_on)
	local rdp=advtrains.round_vector_floor_y(pos)
	
	local node=ndb.get_node_or_nil(rdp)
	if not node then return end
	
	local nodename=node.name
	if(not advtrains.is_track_and_drives_on(nodename, drives_on)) then
		return false
	end
	local conns, railheight, tracktype=advtrains.get_track_connections(node.name, node.param2)
	
	return true, conns, railheight
end

local IGNORE_WORLD = advtrains.IGNORE_WORLD

ndb.run_lbm = function(pos, node)
		local cid=ndbget(pos.x, pos.y, pos.z)
		if cid then
			--if in database, detect changes and apply.
			local nodeid = ndb_nodeids[u14b(cid)]
			local param2 = l2b(cid)
			if not nodeid then
				--something went wrong
				atwarn("Node Database corruption, couldn't determine node to set at", pos)
				ndb.update(pos, node)
			else
				if (nodeid~=node.name or param2~=node.param2) then
					--atprint("nodedb: lbm replaced", pos, "with nodeid", nodeid, "param2", param2, "cid is", cid)
					local newnode = {name=nodeid, param2 = param2}
					minetest.swap_node(pos, newnode)
					local ndef=minetest.registered_nodes[nodeid]
					if ndef and ndef.advtrains and ndef.advtrains.on_updated_from_nodedb then
						ndef.advtrains.on_updated_from_nodedb(pos, newnode)
					end
					return true
				end
			end
		else
			--if not in database, take it.
			--atlog("Node Database:", pos, "was not found in the database, have you used worldedit?")
			ndb.update(pos, node)
		end
		return false
end


minetest.register_lbm({
        name = "advtrains:nodedb_on_load_update",
        nodenames = {"group:save_in_at_nodedb"},
        run_at_every_load = true,
        run_on_every_load = true,
        action = ndb.run_lbm,
        interval=30,
        chance=1,
    })

--used when restoring stuff after a crash
ndb.restore_all = function()
	--atlog("Updating the map from the nodedb, this may take a while")
	local t1 = os.clock()
	local cnt=0
	local dcnt=0
	for y, ny in pairs(ndb_nodes) do
		for x, nx in pairs(ny) do
			for z, _ in pairs(nx) do
				local pos={x=x, y=y, z=z}
				local node=minetest.get_node_or_nil(pos)
				if node then
					local ori_ndef=minetest.registered_nodes[node.name]
					local ndbnode=ndb.get_node_raw(pos)
					if (ori_ndef and ori_ndef.groups.save_in_at_nodedb) or IGNORE_WORLD then --check if this node has been worldedited, and don't replace then
						if (ndbnode.name~=node.name or ndbnode.param2~=node.param2) then
							minetest.swap_node(pos, ndbnode)
							--atlog("Replaced",node.name,"@",pos,"with",ndbnode.name)
							cnt=cnt+1
						end
					else
						ndb.clear(pos)
						dcnt=dcnt+1
						--atlog("Found ghost node (former",ndbnode and ndbnode.name,") @",pos,"deleting")
					end
				end
			end
		end
	end
	local text="Restore node database: Replaced "..cnt.." nodes, removed "..dcnt.." ghost nodes. (took "..math.floor((os.clock()-t1) * 1000).."ms)"
	atlog(text)
	return text
end
    
minetest.register_on_dignode(function(pos, oldnode, digger)
		ndb.clear(pos)
end)

function ndb.get_nodes()
	return ndb_nodes
end
function ndb.get_nodeids()
	return ndb_nodeids
end


advtrains.ndb=ndb

local ptime=0

minetest.register_chatcommand("at_sync_ndb",
	{
        params = "", -- Short parameter description
        description = "Write node db back to map and find ghost nodes", -- Full description
        privs = {train_operator=true}, 
        func = function(name, param)
				if os.time() < ptime+30 and not minetest.get_player_privs(name, "server") then
					return false, "Please wait at least 30s from the previous execution of /at_restore_ndb!"
				end
				local text = ndb.restore_all()
				ptime=os.time()
				return true, text
        end,
    })