advtrains compat (#6)

* advtrains compat

* save / load

* log advtrains data loading

* advtrains autosave

* save behavior

* ts compare

* cleanup

* cleanup

* various fixes

---------

Co-authored-by: BuckarooBanzay <BuckarooBanzay@users.noreply.github.com>

Author: BuckarooBanzay

.luacheckrc

@@ -4,7 +4,10 @@ globals = {
 	"mapsync",
 	"worldedit",
 	"minetest",
-	"travelnet"
+	-- mods
+	"travelnet",
+	"advtrains",
+	"serialize_lib"
 }
 
 read_globals = {

data.lua

@@ -31,16 +31,27 @@ function mapsync.load_data(key)
     return value
 end
 
+-- returns the path of the data file, nil if not available
+function mapsync.get_data_file_path(key)
+    local data_backend_def = mapsync.get_data_backend()
+    if not data_backend_def then
+        -- no data backend defined
+        return
+    end
+
+    return data_backend_def.path .. "/" .. key
+end
+
 -- returns a file to write to in the data-storage, nil if not available
 function mapsync.get_data_file(key, mode)
     -- default to read
     mode = mode or "r"
 
-    local data_backend_def = mapsync.get_data_backend()
-    if not data_backend_def then
+    local path = mapsync.get_data_file_path(key)
+    if not path then
         -- no data backend defined
         return
     end
 
-    return global_env.io.open(data_backend_def.path .. "/" .. key, mode)
+    return global_env.io.open(path, mode)
 end

functions.lua

@@ -156,47 +156,3 @@ end
 function mapsync.get_chunk_zip_path(prefix, chunk_pos)
     return prefix .. "/chunk_" .. minetest.pos_to_string(chunk_pos) .. ".zip"
 end
-
--- https://gist.github.com/SafeteeWoW/080e784e5ebfda42cad486c58e6d26e4
--- license: zlib
-
--- Calculate xor for two unsigned 8bit numbers (0 <= a,b <= 255)
-local function Xor8(a, b)
-	local ret = 0
-	local fact = 128
-	while fact > a and fact > b do
-		fact = fact / 2
-	end
-	while fact >= 1 do
-		ret = ret + (((a >= fact or b >= fact)
-			and (a < fact or b < fact)) and fact or 0)
-		a = a - ((a >= fact) and fact or 0)
-		b = b - ((b >= fact) and fact or 0)
-		fact = fact / 2
-	end
-	return ret
-end
-
--- table to cache the result of uint8 xor(x, y)  (0<=x,y<=255)
-local _xor8_table
-
-local function GenerateXorTable()
-	assert(not _xor8_table)
-	_xor8_table = {}
-	for i = 0, 255 do
-		local t = {}
-		_xor8_table[i] = t
-		for j = 0, 255 do
-			t[j] = Xor8(i, j)
-		end
-	end
-end
-
--- generate xor table on startup, it is only 256*256 bytes long and took about 8ms in the tests
-GenerateXorTable()
-
--- end of library copy
-
-function mapsync.xor(a, b)
-    return _xor8_table[a][b]
-end

functions.spec.lua

@@ -58,12 +58,3 @@ mtt.register("mapsync.deep_compare", function(callback)
 
     callback()
 end)
-
-mtt.register("mapsync.xor", function(callback)
-    assert(mapsync.xor(0x00, 0x00) == 0x00)
-    assert(mapsync.xor(0x01, 0x01) == 0x00)
-    assert(mapsync.xor(0xFF, 0x01) == 0xFE)
-    assert(mapsync.xor(0x55, 0xAA) == 0xFF)
-    assert(mapsync.xor(0x01, 0x02) == 0x03)
-    callback()
-end)

init.lua

@@ -60,6 +60,10 @@ if minetest.get_modpath("travelnet") then
 	dofile(MP.."/integrations/travelnet.lua")
 end
 
+if minetest.get_modpath("advtrains") then
+	dofile(MP.."/integrations/advtrains.lua")
+end
+
 -- testing
 if minetest.get_modpath("mtt") and mtt.enabled then
 	dofile(MP.."/init.spec.lua")

integrations/advtrains.lua

@@ -0,0 +1,110 @@
+-- advtrains compat
+-- saves a snapshot of the advtrains-data with the `/mapsync_save_advtrains` command
+-- loads the snapshot if available on startup, defaults to the worldfolder if no snapshot found
+
+-- sanity checks
+assert(type(advtrains.load_version_4) == "function")
+assert(type(advtrains.ndb.save_callback) == "function")
+assert(type(advtrains.ndb.load_callback) == "function")
+assert(type(advtrains.read_component) == "function")
+assert(type(advtrains.save_component) == "function")
+assert(type(advtrains.save) == "function")
+assert(type(serialize_lib.load_atomic) == "function")
+assert(type(serialize_lib.save_atomic_multiple) == "function")
+assert(type(advtrains.fpath) == "string")
+
+-- local old_advtrains_read_component = advtrains.read_component
+function advtrains.read_component(name)
+    assert(name == "version")
+    -- currently supported version
+    return 4
+end
+
+-- local old_advtrains_save_component = advtrains.save_component
+function advtrains.save_component()
+    -- no-op
+end
+
+-- load from data- or world-path
+local old_load_atomic = serialize_lib.load_atomic
+function serialize_lib.load_atomic(filename, load_callback)
+    local relpath = string.sub(filename, #advtrains.fpath + 2)
+    local timestamp_storage_key = "advtrains_timestamp_" .. relpath
+
+    -- check world- and snapshot-timestamp
+    local snapshot_timestamp = mapsync.load_data("advtrains_timestamp") or 0
+    local world_timestamp = mapsync.storage:get_int(timestamp_storage_key)
+    -- snapshot exists and has a different timestamp
+    local load_snapshot = snapshot_timestamp ~= world_timestamp
+
+    local data_file = mapsync.get_data_file("advtrains_" .. relpath)
+    if data_file and load_snapshot then
+        -- apply snapshot timestamp to world
+        mapsync.storage:set_int(timestamp_storage_key, snapshot_timestamp)
+        -- data-snapshot available, load it
+        local data_path = mapsync.get_data_file_path("advtrains_" .. relpath)
+        minetest.log("action", "[mapsync] loading advtrains data from '" .. data_path ..
+            "' snapshot_timestamp: " .. snapshot_timestamp ..
+            " world_timestamp: " .. world_timestamp)
+        return old_load_atomic(data_path, load_callback)
+    else
+        -- no data snapshot available, load default from world-folder
+        return old_load_atomic(filename, load_callback)
+    end
+end
+
+local advtrains_parts = {"atlatc.ls", "interlocking.ls", "core.ls", "lines.ls", "ndb4.ls"}
+
+local function copy_advtrains_files()
+    if not mapsync.get_data_backend() then
+        return false, "no data-backend configured"
+    end
+
+    -- copy files to data-directory
+    local count = 0
+    for _, part in ipairs(advtrains_parts) do
+        local path = advtrains.fpath .. "_" .. part
+        local src = io.open(path, "rb")
+        if not src then
+            return false, "open failed for '" .. path .. "'"
+        end
+
+        local dst = mapsync.get_data_file("advtrains_" .. part, "wb")
+        local data = src:read("*all")
+        count = count + #data
+        dst:write(data)
+        dst:close()
+        src:close()
+    end
+    -- write timestamp
+    mapsync.save_data("advtrains_timestamp", os.time())
+
+    minetest.log("action", "[mapsync] saved " .. count .. " bytes of advtrains data")
+    return count
+end
+
+local old_advtrains_save = advtrains.save
+function advtrains.save(remove_players_from_wagons)
+    -- save advtrains state
+    old_advtrains_save(remove_players_from_wagons)
+
+    if mapsync.autosave then
+        -- save to data-directory
+        copy_advtrains_files()
+    end
+end
+
+minetest.register_chatcommand("mapsync_save_advtrains", {
+    privs = { mapsync = true },
+    func = function()
+        -- save advtrains data first
+        old_advtrains_save()
+
+        local count, err = copy_advtrains_files()
+        if err then
+            return false, err
+        end
+
+        return true, "saved " .. count .. " bytes of advtrains data"
+    end
+})

mod.conf

@@ -1,3 +1,3 @@
 name = mapsync
 depends = mtzip
-optional_depends = worldedit, screwdriver2, mtt, travelnet
+optional_depends = worldedit, screwdriver2, mtt, travelnet, advtrains, serialize_lib

parse_chunk.lua

@@ -3,28 +3,6 @@ local global_env = ...
 -- local vars for faster access
 local insert, byte, decode_uint16 = table.insert, string.byte, mapsync.decode_uint16
 
--- parses the key information of the chunk (if available)
-function mapsync.parse_chunk_key(filename)
-    local f = global_env.io.open(filename, "rb")
-    local zip, err_msg = mtzip.unzip(f)
-    if not zip then
-        return false, err_msg
-    end
-
-    local key_entry = zip:get_entry("key.json")
-    if not key_entry then
-        -- no key found, unencrypted chunk
-        return nil
-    end
-
-    -- parse key info
-    local key_str, m_err_msg = zip:get("key.json")
-    if not key_str then
-        return false, m_err_msg
-    end
-    return minetest.parse_json(key_str)
-end
-
 -- parses an exported chunk file
 function mapsync.parse_chunk(filename)
     local f = global_env.io.open(filename, "rb")