250 lines
7.3 KiB
Lua
250 lines
7.3 KiB
Lua
local S = minetest.get_translator("mcl_maps")
|
|
local storage = minetest.get_mod_storage()
|
|
local modpath = minetest.get_modpath("mcl_maps")
|
|
local worldpath = minetest.get_worldpath()
|
|
local map_textures_path = worldpath .. "/mcl_maps/"
|
|
local last_finished_id = storage:get_int("next_id") - 1
|
|
|
|
minetest.mkdir(map_textures_path)
|
|
|
|
local function load_json_file(name)
|
|
local file = assert(io.open(modpath .. "/" .. name .. ".json", "r"))
|
|
local data = minetest.parse_json(file:read())
|
|
file:close()
|
|
return data
|
|
end
|
|
|
|
local texture_colors = load_json_file("colors")
|
|
local palettes = load_json_file("palettes")
|
|
|
|
local color_cache = {}
|
|
|
|
local creating_maps = {}
|
|
local loading_maps = {}
|
|
local loaded_maps = {}
|
|
|
|
local c_air = minetest.get_content_id("air")
|
|
|
|
-- Turn empty map into filled map by rightclick
|
|
local make_filled_map = function(itemstack, placer, pointed_thing)
|
|
local new_map = ItemStack("mcl_maps:filled_map")
|
|
if minetest.settings:get_bool("enable_real_maps", true) then
|
|
local meta = new_map:get_meta()
|
|
local id = storage:get_int("next_id")
|
|
storage:set_int("next_id", id + 1)
|
|
local texture_file = "mcl_maps_map_texture_" .. id .. ".tga"
|
|
local texture_path = map_textures_path .. texture_file
|
|
local texture = "[combine:140x140:0,0=mcl_maps_map_background.png:6,6=" .. texture_file
|
|
meta:set_int("mcl_maps:id", id)
|
|
meta:set_string("mcl_maps:texture", texture)
|
|
meta:set_string("mcl_maps:texture_path", texture_path)
|
|
tt.reload_itemstack_description(new_map)
|
|
creating_maps[texture] = true
|
|
local pos = placer:get_pos()
|
|
local minp = vector.multiply(vector.floor(vector.divide(pos, 128)), 128)
|
|
local maxp = vector.add(minp, vector.new(127, 127, 127))
|
|
minetest.emerge_area(minp, maxp, function(blockpos, action, calls_remaining)
|
|
if calls_remaining < 1 then
|
|
local vm = minetest.get_voxel_manip()
|
|
local emin, emax = vm:read_from_map(minp, maxp)
|
|
local data = vm:get_data()
|
|
local param2data = vm:get_param2_data()
|
|
local area = VoxelArea:new({MinEdge = emin, MaxEdge = emax})
|
|
local pixels = {}
|
|
local last_heightmap
|
|
for x = 1, 128 do
|
|
local map_x = minp.x - 1 + x
|
|
local heightmap = {}
|
|
for z = 1, 128 do
|
|
local map_z = minp.z - 1 + z
|
|
local color
|
|
for map_y = maxp.y, minp.y, -1 do
|
|
local index = area:index(map_x, map_y, map_z)
|
|
local c_id = data[index]
|
|
|
|
if c_id ~= c_air then
|
|
color = color_cache[c_id]
|
|
|
|
if color == nil then
|
|
local nodename = minetest.get_name_from_content_id(c_id)
|
|
local def = minetest.registered_nodes[nodename]
|
|
|
|
if def then
|
|
local texture
|
|
|
|
if def.palette then
|
|
texture = def.palette
|
|
elseif def.tiles then
|
|
texture = def.tiles[1]
|
|
|
|
if type(texture) == "table" then
|
|
texture = texture.name
|
|
end
|
|
end
|
|
|
|
if texture then
|
|
texture = texture:match("([^=^%^]-([^.]+))$"):split("^")[1]
|
|
end
|
|
|
|
if def.palette then
|
|
local palette = palettes[texture]
|
|
color = palette and {palette = palette}
|
|
else
|
|
color = texture_colors[texture]
|
|
end
|
|
end
|
|
end
|
|
|
|
if color and color.palette then
|
|
color = color.palette[param2data[index] + 1]
|
|
else
|
|
color_cache[c_id] = color or false
|
|
end
|
|
|
|
if color and last_heightmap then
|
|
local last_height = last_heightmap[z]
|
|
if last_height < map_y then
|
|
color = {
|
|
math.min(255, color[1] + 16),
|
|
math.min(255, color[2] + 16),
|
|
math.min(255, color[3] + 16),
|
|
}
|
|
elseif last_height > map_y then
|
|
color = {
|
|
math.max(0, color[1] - 16),
|
|
math.max(0, color[2] - 16),
|
|
math.max(0, color[3] - 16),
|
|
}
|
|
end
|
|
end
|
|
|
|
height = map_y
|
|
break
|
|
end
|
|
end
|
|
heightmap[z] = height
|
|
pixels[z] = pixels[z] or {}
|
|
pixels[z][x] = color or {0, 0, 0}
|
|
end
|
|
last_heightmap = heightmap
|
|
end
|
|
|
|
tga_encoder.image(pixels):save(texture_path)
|
|
|
|
creating_maps[texture] = false
|
|
end
|
|
end)
|
|
end
|
|
itemstack:take_item()
|
|
if itemstack:is_empty() then
|
|
return new_map
|
|
else
|
|
local inv = placer:get_inventory()
|
|
if inv:room_for_item("main", new_map) then
|
|
inv:add_item("main", new_map)
|
|
else
|
|
minetest.add_item(placer:get_pos(), new_map)
|
|
end
|
|
return itemstack
|
|
end
|
|
end
|
|
|
|
minetest.register_craftitem("mcl_maps:empty_map", {
|
|
description = S("Empty Map"),
|
|
_doc_items_longdesc = S("Empty maps are not useful as maps, but they can be stacked and turned to maps which can be used."),
|
|
_doc_items_usagehelp = S("Rightclick to create a filled map (which can't be stacked anymore)."),
|
|
inventory_image = "mcl_maps_map_empty.png",
|
|
groups = { not_in_creative_inventory = 1 },
|
|
on_place = make_filled_map,
|
|
on_secondary_use = make_filled_map,
|
|
stack_max = 64,
|
|
})
|
|
|
|
minetest.register_craftitem("mcl_maps:filled_map", {
|
|
description = S("Map"),
|
|
_tt_help = S("Shows a map image."),
|
|
_doc_items_longdesc = S("When created, the map saves the nearby area as an image that can be viewed any time by holding the map."),
|
|
_doc_items_usagehelp = S("Hold the map in your hand. This will display a map on your screen."),
|
|
groups = { tool = 1 },
|
|
inventory_image = "mcl_maps_map_filled.png^(mcl_maps_map_filled_markings.png^[colorize:#000000)",
|
|
stack_max = 1,
|
|
})
|
|
|
|
tt.register_priority_snippet(function(itemstring, _, itemstack)
|
|
if itemstack and itemstring == "mcl_maps:filled_map" then
|
|
local id = itemstack:get_meta():get_string("mcl_maps:id")
|
|
if id ~= "" then
|
|
return "#" .. id, mcl_colors.GRAY
|
|
end
|
|
end
|
|
end)
|
|
|
|
minetest.register_craft({
|
|
output = "mcl_maps:empty_map",
|
|
recipe = {
|
|
{ "mcl_core:paper", "mcl_core:paper", "mcl_core:paper" },
|
|
{ "mcl_core:paper", "group:compass", "mcl_core:paper" },
|
|
{ "mcl_core:paper", "mcl_core:paper", "mcl_core:paper" },
|
|
}
|
|
})
|
|
|
|
local maps = {}
|
|
local huds = {}
|
|
|
|
minetest.register_on_joinplayer(function(player)
|
|
huds[player] = player:hud_add({
|
|
hud_elem_type = "image",
|
|
text = "blank.png",
|
|
position = {x = 1, y = 1},
|
|
alignment = {x = -1, y = -1},
|
|
offset = {x = -125, y = -50},
|
|
scale = {x = 2, y = 2},
|
|
})
|
|
end)
|
|
|
|
minetest.register_on_leaveplayer(function(player)
|
|
maps[player] = nil
|
|
huds[player] = nil
|
|
end)
|
|
|
|
local function is_holding_map(player)
|
|
local wield = player:get_wielded_item()
|
|
if wield:get_name() ~= "mcl_maps:filled_map" then
|
|
return
|
|
end
|
|
local meta = wield:get_meta()
|
|
local texture = meta:get_string("mcl_maps:texture")
|
|
if texture == "" then
|
|
return
|
|
end
|
|
if loaded_maps[texture] then
|
|
return texture
|
|
end
|
|
local path = meta:get_string("mcl_maps:texture_path")
|
|
if not creating_maps[texture] and not loading_maps[texture] then
|
|
loading_maps[texture] = true
|
|
local player_name = player:get_player_name()
|
|
minetest.dynamic_add_media(path, function(finished_name)
|
|
if player_name == finished_name then
|
|
loading_maps[texture] = false
|
|
loaded_maps[texture] = true
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
minetest.register_globalstep(function(dtime)
|
|
for _, player in pairs(minetest.get_connected_players()) do
|
|
local texture = is_holding_map(player)
|
|
if texture then
|
|
if texture ~= maps[player] then
|
|
player:hud_change(huds[player], "text", texture)
|
|
maps[player] = texture
|
|
end
|
|
elseif maps[player] then
|
|
player:hud_change(huds[player], "text", "blank.png")
|
|
maps[player] = nil
|
|
end
|
|
end
|
|
end)
|