Add support for games without default game (MTG) (#25)

* Add support for games without `default`

This adds support for games like Mineclonia, and any game xcompat adds
support for. The only asterix is dye support, the pattern for dyes has
been expanded for common dye mods, but if a new dye mod has different
dye names those might not work without an update to the pattern.

* Refactor & fix Farlands dye support

* Add some mcl colors, make names & their order consistent

* Fix old crafting bug & refacfor crafting

* Minor refactor & reorder for clarity

* Fix for Farlands `get_name` returning "" not nil

Farlands seems to return "" instead of nil/0 when no item is present.
By accounting for this, this commit fixes an issue where any empty slot
repaired the glider.

* Separate color handling to new module

* Luacheck fix

* Ignore empty `do end` luacheck warnings

* Replace `minetest.` with `core.`

.luacheckrc

@@ -5,8 +5,16 @@ globals = {
 
 read_globals = {
 	"minetest",
+	"core",
 	"vector", "ItemStack",
 
 	"player_monoids",
+	"pova",
 	"unifieddyes",
+	"xcompat",
 }
+
+ignore = {
+	"541", -- Empty "do end" block warning
+}
+

README.md

@@ -31,17 +31,3 @@ The hang glider will wear out every time you use it. The hang glider can be repa
 If the `areas` mod is installed, airspace restrictions can be added to areas using the `/area_flak` command.
 
 When using a hang glider in an area with flak enabled, you will get shot down a few seconds after entering the area, this reduces your HP to 1 and destroys your hang glider.
-
-## API
-
-#### Custom "can fly" checks
-
-```lua
-hangglider.add_fly_check(function(name, player)
-	-- `name` is the playername
-	-- `player` is the PlayerRef
-	-- Add your code here
-	-- Must return `true` (can fly) or `false` (can't fly)
-	return true
-end)
-```

colors.lua

@@ -0,0 +1,91 @@
+local S = hangglider.translator
+local module = {}
+
+local has_unifieddyes = core.get_modpath("unifieddyes")
+local dye_prefix_pattern_universal = "^.*dyes?:" -- Known dye prefix matches: dyes, mcl_dyes, mcl_dye, fl_dyes.
+local dye_suffix_pattern_farlands  = "_dye$"     -- A suffix appended to dye names in the Farlands game.
+
+local dye_colors = {
+	black      = "111111",
+	blue       = "0000ff",
+	brown      = "592c00",
+	cyan       = "00ffff",
+	dark_green = "005900",
+	dark_grey  = "444444",
+	green      = "00ff00",
+	grey       = "888888",
+	light_blue = "258ec9",
+	lime       = "60ac19",
+	magenta    = "ff00ff",
+	orange     = "ff7f00",
+	pink       = "ff7f9f",
+	purple     = "6821a0",
+	red        = "ff0000",
+	silver     = "818177",
+	violet     = "8000ff",
+	white      = "ffffff",
+	yellow     = "ffff00",
+}
+
+local translated_colors = {
+	black      = S("Black"),
+	blue       = S("Blue"),
+	brown      = S("Brown"),
+	cyan       = S("Cyan"),
+	dark_green = S("Dark Green"),
+	dark_grey  = S("Dark Grey"),
+	green      = S("Green"),
+	grey       = S("Grey"),
+	light_blue = S("Light Blue"),
+	lime       = S("Lime"),
+	magenta    = S("Magenta"),
+	orange     = S("Orange"),
+	pink       = S("Pink"),
+	purple     = S("Purple"),
+	red        = S("Red"),
+	silver     = S("Light Grey"),
+	violet     = S("Violet"),
+	white      = S("White"),
+	yellow     = S("Yellow"),
+}
+
+
+
+function module.get_dye_name(name)
+	-- Remove prefix and potential suffix
+	name = string.gsub(name, dye_suffix_pattern_farlands, "")
+	name = string.match(name, dye_prefix_pattern_universal.."(.+)$")
+	return name
+end
+
+
+function module.get_dye_color(name)
+	local color
+	if has_unifieddyes then
+		color = unifieddyes.get_color_from_dye_name(name)
+	end
+
+	if not color then
+		color = module.get_dye_name(name)
+		if color then
+			color = dye_colors[color]
+		end
+	end
+	return color
+end
+
+function module.get_color_name(name)
+	return translated_colors[module.get_dye_name(name)]
+end
+
+function module.get_color_name_from_color(color)
+	for name, color_hex in pairs(dye_colors) do
+		if color == color_hex then
+			return translated_colors[name]
+		end
+	end
+	return nil
+end
+
+
+return module

crafts.lua

@@ -1,105 +1,82 @@
-
 local S = hangglider.translator
+local colors = assert(dofile(core.get_modpath("hangglider").."/colors.lua"))
 
-local has_unifieddyes = minetest.get_modpath("unifieddyes")
+local repair_items      = {"group:wool", xcompat.materials.paper}
+local repair_percentage = 100
 
-local dye_colors = {
-	white      = "ffffff",
-	grey       = "888888",
-	dark_grey  = "444444",
-	black      = "111111",
-	violet     = "8000ff",
-	blue       = "0000ff",
-	cyan       = "00ffff",
-	dark_green = "005900",
-	green      = "00ff00",
-	yellow     = "ffff00",
-	brown      = "592c00",
-	orange     = "ff7f00",
-	red        = "ff0000",
-	magenta    = "ff00ff",
-	pink       = "ff7f9f",
-}
 
-local translated_colors = {
+-- Placeholder repairing recipes (Doesn't directly apply repair, see handler)
-	white      = S("White"),
+core.register_craft({
-	grey       = S("Grey"),
+	output = "hangglider:hangglider",
-	dark_grey  = S("Dark_grey"),
+	recipe = {
-	black      = S("Black"),
+		{xcompat.materials.paper, xcompat.materials.paper, xcompat.materials.paper},
-	violet     = S("Violet"),
+		{xcompat.materials.paper, "hangglider:hangglider", xcompat.materials.paper},
-	blue       = S("Blue"),
+		{xcompat.materials.paper, xcompat.materials.paper, xcompat.materials.paper},
-	cyan       = S("Cyan"),
+	},
-	dark_green = S("Dark_green"),
+})
-	green      = S("Green"),
-	yellow     = S("Yellow"),
-	brown      = S("Brown"),
-	orange     = S("Orange"),
-	red        = S("Red"),
-	magenta    = S("Magenta"),
-	pink       = S("Pink"),
-}
 
-local function get_dye_color(name)
+core.register_craft({
-	local color
+	output = "hangglider:hangglider",
-	if has_unifieddyes then
+	recipe = {"hangglider:hangglider", "group:wool"},
-		color = unifieddyes.get_color_from_dye_name(name)
+	type = "shapeless",
-	end
+})
-	if not color then
-		color = string.match(name, "^dye:(.+)$")
-		if color then
-			color = dye_colors[color]
-		end
-	end
-	return color
-end
 
-local function get_color_name(name)
+-- Placeholder color recipe (Doesn't drectly apply color, see handler)
-	name = string.gsub(name, "^dye:", "")
-	return translated_colors[name]
-end
-
-local function get_color_name_from_color(color)
-	for name, color_hex in pairs(dye_colors) do
-		if color == color_hex then
-			return translated_colors[name]
-		end
-	end
-end
-
--- This recipe is just a placeholder
 do
 	local item = ItemStack("hangglider:hangglider")
 	item:get_meta():set_string("description", S("Colored Glider"))
-	minetest.register_craft({
+	core.register_craft({
 		output = item:to_string(),
 		recipe = {"hangglider:hangglider", "group:dye"},
 		type = "shapeless",
 	})
 end
 
--- This is what actually creates the colored hangglider
+-- Recipe handler (This is what applies color and repair)
-minetest.register_on_craft(function(crafted_item, _, old_craft_grid)
+local function crafting_callback_handle_placeholder_recipe(crafted_item, _, old_craft_grid)
 	if crafted_item:get_name() ~= "hangglider:hangglider" then
+		-- Function called for an unrelated crafting recipe
 		return
 	end
-	local wear, color, color_name
+	-- Get existing state and present materials
+	local wear, repaired, dye_name, color, color_name = 0, false, nil, nil, nil
 	for _,stack in ipairs(old_craft_grid) do
 		local name = stack:get_name()
-		if name == "hangglider:hangglider" then
+		if not name or name == "" then
-			wear = stack:get_wear()
+			do end -- The stack is empty, do nothing and skip all checks for this stack.
-			color = stack:get_meta():get("hangglider_color")
+		elseif name == "hangglider:hangglider" then
-			color_name = get_color_name_from_color(color)
+			wear       = stack:get_wear()
-		elseif minetest.get_item_group(name, "dye") ~= 0 then
+			color      = stack:get_meta():get("hangglider_color")
-			color = get_dye_color(name)
+			color_name = colors.get_color_name_from_color(color)
-			color_name = get_color_name(name)
+		elseif core.get_item_group(name, "dye") ~= 0 then
-		elseif "wool:white" == stack:get_name()
+			dye_name = name
-			or "default:paper" == stack:get_name()
+		else
-		then
+			for _,repair_item in ipairs(repair_items) do
-			wear = 0
+				if name == repair_item
+					or core.get_item_group(name, string.match(repair_item, "^group:(.*)$")) ~= 0
+				then
+					repaired = true
+				end
+			end
 		end
 	end
+
+	-- Overwrite color with dye if present
+	if dye_name then
+		color      = colors.get_dye_color(dye_name)
+		color_name = colors.get_color_name(dye_name)
+	end
+
+	-- Repair if any repair item present
+	if repaired then
+		wear = wear - (65535 * (repair_percentage / 100))
+		if wear < 0 then wear = 0 end
+	end
+
+	-- Apply item changes if valid
 	if wear and color and color_name then
 		if color == "ffffff" then
+			-- Return an uncolored glider
 			return ItemStack({name = "hangglider:hangglider", wear = wear})
 		end
 		local meta = crafted_item:get_meta()
@@ -109,30 +86,17 @@ minetest.register_on_craft(function(crafted_item, _, old_craft_grid)
 		crafted_item:set_wear(wear)
 		return crafted_item
 	end
-end)
+end
+-- Register handler as a callback for any crafting action
+core.register_on_craft(crafting_callback_handle_placeholder_recipe)
 
--- Repairing
-minetest.register_craft({
-	output = "hangglider:hangglider",
-	recipe = {
-		{"default:paper", "default:paper", "default:paper"},
-		{"default:paper", "hangglider:hangglider", "default:paper"},
-		{"default:paper", "default:paper", "default:paper"},
-	},
-})
-minetest.register_craft({
-	output = "hangglider:hangglider",
-	recipe = {
-		{"hangglider:hangglider", "wool:white"},
-	},
-})
 
--- Main craft
+-- Hangglider recipe
-minetest.register_craft({
+core.register_craft({
 	output = "hangglider:hangglider",
 	recipe = {
-		{"wool:white", "wool:white", "wool:white"},
+		{"group:wool", "group:wool", "group:wool"},
-		{"default:stick", "", "default:stick"},
+		{xcompat.materials.stick, "", xcompat.materials.stick},
-		{"", "default:stick", ""},
+		{"", xcompat.materials.stick, ""},
 	}
 })

init.lua

@@ -1,27 +1,29 @@
-hangglider = {}
 
 hangglider = {
-	translator = minetest.get_translator('hangglider'),
+	translator = core.get_translator('hangglider'),
 }
 local S = hangglider.translator
 
-local has_player_monoids = minetest.get_modpath("player_monoids")
+local has_player_monoids = core.get_modpath("player_monoids")
-local has_areas = minetest.get_modpath("areas")
+local has_pova = core.get_modpath("pova")
+local has_areas = core.get_modpath("areas")
 
-local enable_hud_overlay = minetest.settings:get_bool("hangglider.enable_hud_overlay", true)
+local enable_hud_overlay = core.settings:get_bool("hangglider.enable_hud_overlay", true)
-local enable_flak = has_areas and minetest.settings:get_bool("hangglider.enable_flak", true)
+local enable_flak = has_areas and core.settings:get_bool("hangglider.enable_flak", true)
-local flak_warning_time = tonumber(minetest.settings:get("hangglider.flak_warning_time")) or 2
+local flak_warning_time = tonumber(core.settings:get("hangglider.flak_warning_time")) or 2
-local hangglider_uses = tonumber(minetest.settings:get("hangglider.uses")) or 250
+local hangglider_uses = tonumber(core.settings:get("hangglider.uses")) or 250
 
 local flak_warning = S("You have entered restricted airspace!@n"
 	.. "You will be shot down in @1 seconds by anti-aircraft guns!",
 	flak_warning_time)
 
 local hanggliding_players = {}
+local physics_overrides = {}
 local hud_overlay_ids = {}
 
+
 if enable_flak then
-	minetest.register_chatcommand("area_flak", {
+	core.register_chatcommand("area_flak", {
 		params = S("<ID>"),
 		description = S("Toggle airspace restrictions for area <ID>."),
 		func = function(name, param)
@@ -42,85 +44,126 @@ if enable_flak then
 	})
 end
 
-local function set_hud_overlay(player, name, image)
+function hangglider.is_gliding(player)
+	if not player then
+		return false
+	end
+	return hanggliding_players[player:get_player_name()]
+end
+
+local function set_hud_overlay(player, name, show)
 	if not enable_hud_overlay then
 		return
 	end
-	if not hud_overlay_ids[name] then
+	if not hud_overlay_ids[name] and show == true then
 		hud_overlay_ids[name] = player:hud_add({
-			hud_elem_type = "image",
+			[core.features.hud_def_type_field and "type" or "hud_elem_type"] = "image",
-			text = image,
+			text = "hangglider_overlay.png",
 			position = {x = 0, y = 0},
 			scale = {x = -100, y = -100},
 			alignment = {x = 1, y = 1},
 			offset = {x = 0, y = 0},
 			z_index = -150
 		})
-	else
+	elseif hud_overlay_ids[name] and show == false then
-		player:hud_change(hud_overlay_ids[name], "text", image)
+		player:hud_remove(hud_overlay_ids[name])
+		hud_overlay_ids[name] = nil
 	end
 end
 
 local function set_physics_overrides(player, overrides)
+	local player_name = player:get_player_name()
 	if has_player_monoids then
 		for name, value in pairs(overrides) do
 			player_monoids[name]:add_change(player, value, "hangglider:glider")
 		end
+	elseif has_pova then
+		pova.add_override(player_name, "hangglider:glider",
+				{jump = 0, speed = overrides.speed, gravity = overrides.gravity})
+		pova.do_override(player)
 	else
-		player:set_physics_override(overrides)
+		local def = player:get_physics_override()
+		if not physics_overrides[player_name] then
+			physics_overrides[player_name] = {
+				physics = {
+					speed = def.speed,
+					jump = def.jump,
+					gravity = def.gravity,
+				},
+				deltas = {speed = 0, jump = 0, gravity = 0},
+			}
+		end
+		-- Compute the new delta to apply (relative to current physics)
+		local delta = {
+			speed = (overrides.speed or def.speed) - def.speed,
+			jump = (overrides.jump or def.jump) - def.jump,
+			gravity = (overrides.gravity or def.gravity) - def.gravity,
+		}
+		-- Track the sum of all deltas for this session.
+		physics_overrides[player_name].deltas.speed = physics_overrides[player_name].deltas.speed + delta.speed
+		physics_overrides[player_name].deltas.jump = physics_overrides[player_name].deltas.jump + delta.jump
+		physics_overrides[player_name].deltas.gravity = physics_overrides[player_name].deltas.gravity + delta.gravity
+		-- Apply new delta on top of current physics
+		player:set_physics_override({
+			speed = def.speed + delta.speed,
+			jump = def.jump + delta.jump,
+			gravity = def.gravity + delta.gravity,
+		})
 	end
 end
 
 local function remove_physics_overrides(player)
+	local player_name = player:get_player_name()
 	if has_player_monoids then
 		for _, name in pairs({"jump", "speed", "gravity"}) do
 			player_monoids[name]:del_change(player, "hangglider:glider")
 		end
+	elseif has_pova then
+		pova.del_override(player_name, "hangglider:glider")
+		pova.do_override(player)
 	else
-		player:set_physics_override({jump = 1, speed = 1, gravity = 1})
+		local def = player:get_physics_override()
-	end
+		if physics_overrides[player_name]
-end
+			and physics_overrides[player_name].physics
+			and physics_overrides[player_name].deltas then
 
-local fly_checks = {}
+			-- Subtract total delta from current values
-
+			player:set_physics_override({
-function hangglider.add_fly_check(func)
+				speed = def.speed - physics_overrides[player_name].deltas.speed,
-	table.insert(fly_checks, func)
+				jump = def.jump - physics_overrides[player_name].deltas.jump,
-end
+				gravity = def.gravity - physics_overrides[player_name].deltas.gravity,
-
+			})
-local function can_fly_flak(name, pos)
+			physics_overrides[player_name] = nil
-	-- Area flak check
+		else
-	if enable_flak then
+			player:set_physics_override({speed = 1, jump = 1, gravity = 1})
-		local flak = false
-		local owners = {}
-		for _, area in pairs(areas:getAreasAtPos(pos)) do
-			if area.flak then
-				flak = true
-			end
-			owners[area.owner] = true
-		end
-		if flak and not owners[name] then
-			return false
 		end
 	end
 end
 
-local function can_fly_custom(name, player)
+local function can_fly(pos, name)
-	-- Custom checks set by other mods
+	if not enable_flak then
-	for _, func in ipairs(fly_checks) do
+		return true
-		local ret = func(name, player)
+	end
-		if ret == false then
+	local flak = false
-			return false
+	local owners = {}
+	for _, area in pairs(areas:getAreasAtPos(pos)) do
+		if area.flak then
+			flak = true
 		end
+		owners[area.owner] = true
+	end
+	if flak and not owners[name] then
+		return false
 	end
 	return true
 end
 
 local function safe_node_below(pos)
-	local node = minetest.get_node_or_nil(vector.new(pos.x, pos.y - 0.5, pos.z))
+	local node = core.get_node_or_nil(vector.new(pos.x, pos.y - 0.5, pos.z))
 	if not node then
 		return false
 	end
-	local def = minetest.registered_nodes[node.name]
+	local def = core.registered_nodes[node.name]
 	if def and (def.walkable or (def.liquidtype ~= "none" and def.damage_per_second <= 0)) then
 		return true
 	end
@@ -128,7 +171,7 @@ local function safe_node_below(pos)
 end
 
 local function shoot_flak_sound(pos)
-	minetest.sound_play("hangglider_flak_shot", {
+	core.sound_play("hangglider_flak_shot", {
 		pos = pos,
 		max_hear_distance = 30,
 		gain = 10.0,
@@ -166,11 +209,11 @@ local function hangglider_step(self, dtime)
 					})
 				end
 			end
-			if not can_fly_flak(name, pos) then
+			if not can_fly(pos, name) then
 				if not self.flak_timer then
 					self.flak_timer = 0
 					shoot_flak_sound(pos)
-					minetest.chat_send_player(name, flak_warning)
+					core.chat_send_player(name, flak_warning)
 				else
 					self.flak_timer = self.flak_timer + dtime
 				end
@@ -181,13 +224,10 @@ local function hangglider_step(self, dtime)
 					gliding = false
 				end
 			end
-			if not can_fly_custom(name, player) then
-				gliding = false
-			end
 			if not gliding then
 				remove_physics_overrides(player)
 				hanggliding_players[name] = nil
-				set_hud_overlay(player, name, "blank.png")
+				set_hud_overlay(player, name, false)
 			end
 		end
 	end
@@ -204,17 +244,17 @@ local function hangglider_use(stack, player)
 	local pos = player:get_pos()
 	local name = player:get_player_name()
 	if not hanggliding_players[name] then
-		minetest.sound_play("hanggliger_equip", {pos = pos, max_hear_distance = 8, gain = 1.0}, true)
+		core.sound_play("hanggliger_equip", {pos = pos, max_hear_distance = 8, gain = 1.0}, true)
-		local entity = minetest.add_entity(pos, "hangglider:glider")
+		local entity = core.add_entity(pos, "hangglider:glider")
 		if entity then
 			entity:set_attach(player, "", vector.new(0, 10, 0), vector.new(0, 0, 0))
 			local color = stack:get_meta():get("hangglider_color")
 			if color then
 				entity:set_properties({
-					textures = {"wool_white.png^[multiply:#"..color, "default_wood.png"}
+					textures = {xcompat.textures.wool.white.."^[multiply:#"..color, xcompat.textures.wood.apple.planks}
 				})
 			end
-			set_hud_overlay(player, name, "hangglider_overlay.png")
+			set_hud_overlay(player, name, true)
 			set_physics_overrides(player, {jump = 0, gravity = 0.25})
 			hanggliding_players[name] = true
 			if hangglider_uses > 0 then
@@ -223,26 +263,26 @@ local function hangglider_use(stack, player)
 			return stack
 		end
 	else
-		set_hud_overlay(player, name, "blank.png")
+		set_hud_overlay(player, name, false)
 		remove_physics_overrides(player)
 		hanggliding_players[name] = nil
 	end
 end
 
-minetest.register_on_dieplayer(function(player)
+core.register_on_dieplayer(function(player)
 	local name = player:get_player_name()
 	hanggliding_players[name] = nil
 	remove_physics_overrides(player)
 end)
 
-minetest.register_on_leaveplayer(function(player)
+core.register_on_leaveplayer(function(player)
 	local name = player:get_player_name()
 	hanggliding_players[name] = nil
 	hud_overlay_ids[name] = nil
 	remove_physics_overrides(player)
 end)
 
-minetest.register_on_player_hpchange(function(player, hp_change, reason)
+core.register_on_player_hpchange(function(player, hp_change, reason)
 	local name = player:get_player_name()
 	if hanggliding_players[name] and reason.type == "fall" then
 		-- Stop all fall damage when hanggliding
@@ -251,22 +291,24 @@ minetest.register_on_player_hpchange(function(player, hp_change, reason)
 	return hp_change
 end, true)
 
-minetest.register_entity("hangglider:glider", {
+core.register_entity("hangglider:glider", {
-	visual = "mesh",
+	initial_properties = {
-	visual_size = {x = 12, y = 12},
+		visual = "mesh",
-	collisionbox = {0,0,0,0,0,0},
+		visual_size = {x = 12, y = 12},
-	mesh = "hangglider.obj",
+		collisionbox = {0,0,0,0,0,0},
-	immortal = true,
+		mesh = "hangglider.obj",
-	static_save = false,
+		textures = {xcompat.textures.wool.white, xcompat.textures.wood.apple.planks},
-	textures = {"wool_white.png", "default_wood.png"},
+		immortal = true,
+		static_save = false,
+	},
 	on_step = hangglider_step,
 })
 
-minetest.register_tool("hangglider:hangglider", {
+core.register_tool("hangglider:hangglider", {
 	description = S("Glider"),
 	inventory_image = "hangglider_item.png",
 	sound = {breaks = "default_tool_breaks"},
 	on_use = hangglider_use,
 })
 
-dofile(minetest.get_modpath("hangglider").."/crafts.lua")
+dofile(core.get_modpath("hangglider").."/crafts.lua")

mod.conf

@@ -1,5 +1,5 @@
 name = hangglider
 description = Adds a functional hang glider for exploring
-depends = default, wool, dye
+depends = xcompat
-optional_depends = areas, player_monoids, unifieddyes
+optional_depends = areas, player_monoids, pova, unifieddyes
 min_minetest_version = 5.0