From e7d8b3ba42fad25d4efe42bea918a8720e5992f9 Mon Sep 17 00:00:00 2001 From: FaceDeer Date: Sun, 21 Aug 2022 16:38:34 -0600 Subject: [PATCH] enable ores in MCL2, fix some undeclared globals, fix icecap growth in MCL (achievements are a good debugging tool) --- df_achievements/farming.lua | 2 +- df_achievements/init.lua | 5 +++ df_achievements/travel.lua | 16 ++++--- df_ambience/init.lua | 2 + df_dependencies/mapgen.lua | 61 +++++++++++++++++--------- df_trees/sapling_growth_conditions.lua | 3 +- looped_node_sound/init.lua | 2 +- 7 files changed, 61 insertions(+), 30 deletions(-) diff --git a/df_achievements/farming.lua b/df_achievements/farming.lua index 5a9fe1c..43cf1e7 100644 --- a/df_achievements/farming.lua +++ b/df_achievements/farming.lua @@ -66,7 +66,7 @@ minetest.register_on_placenode(function(pos, newnode, placer, oldnode, itemstack local achievement = plant_node_achievements[newnode.name] if not achievement then return end local achievement_name = achievement.achievement - if not player_awards or player_awards.unlocked[achievement_name] ~= achievement_name then + if not player_awards.unlocked or player_awards.unlocked[achievement_name] ~= achievement_name then -- all of the growable plants in DFCaverns are timer-based. If you place -- a seedling or seed and the resulting node has a timer running, then -- it's passed the checks to see if it was placed in a growable area. diff --git a/df_achievements/init.lua b/df_achievements/init.lua index d9e5140..2ef89fd 100644 --- a/df_achievements/init.lua +++ b/df_achievements/init.lua @@ -10,6 +10,9 @@ df_achievements = {} local old_awards_version = false if awards.run_trigger_callbacks then + -- older versions of awards crash when attempting to use newer versions of triggers + -- this "run_trigger_callbacks" API call is present in those older versions, so using that + -- as a fingerprint to discover them old_awards_version = true else -- used to track the progress of achievements that are based off of other achievements @@ -37,6 +40,8 @@ awards.register_achievement = function(achievement_name, achievement_def, ...) achievement_def.trigger = nil end + -- The achievement being registered has "parent" achievements that progress when it is unlocked, + -- track that here if achievement_def._dfcaverns_achievements then for _, parent_achievement in pairs(achievement_def._dfcaverns_achievements) do local parent_source_list = achievement_parents[parent_achievement] or {} diff --git a/df_achievements/travel.lua b/df_achievements/travel.lua index 377d3fd..4bdfa4b 100644 --- a/df_achievements/travel.lua +++ b/df_achievements/travel.lua @@ -59,18 +59,22 @@ minetest.register_globalstep(function(dtime) local player_name local player_awards + local unlocked local player_data + local biome + local totals -- loop through players for _, player in pairs(minetest.get_connected_players()) do player_name = player:get_player_name() player_awards = awards.player(player_name) - if player_awards.unlocked["dfcaverns_visit_all_caverns"] ~= "dfcaverns_visit_all_caverns" or - player_awards.unlocked["dfcaverns_visit_glowing_pit"] ~= "dfcaverns_visit_glowing_pit" then + unlocked = player_awards.unlocked or {} + + if unlocked["dfcaverns_visit_all_caverns"] ~= "dfcaverns_visit_all_caverns" or + unlocked["dfcaverns_visit_glowing_pit"] ~= "dfcaverns_visit_glowing_pit" then player_data = get_player_data(player) biome = player_data.biome totals = player_data.totals - if biome == "towercap" and check_nodes(node_types.towercap, totals) then awards.unlock(player_name, "dfcaverns_visit_tower_cap") elseif biome == "fungiwood" and check_nodes(node_types.fungiwood, totals) then @@ -106,7 +110,7 @@ minetest.register_globalstep(function(dtime) awards.unlock(player_name, "dfcaverns_visit_underworld") end if (totals["df_underworld_items:glow_amethyst"] or 0) > 1 and - player_awards.unlocked["dfcaverns_visit_glowing_pit"] ~= "dfcaverns_visit_glowing_pit" then + unlocked["dfcaverns_visit_glowing_pit"] ~= "dfcaverns_visit_glowing_pit" then local player_pos = player:get_pos() local pit = df_caverns.get_nearest_glowing_pit(player_pos) pit.location.y = player_pos.y @@ -122,10 +126,10 @@ minetest.register_globalstep(function(dtime) awards.unlock(player_name, "dfcaverns_visit_primordial_jungle") end end - if player_awards.unlocked["dfcaverns_visit_chasm"] ~= "dfcaverns_visit_chasm" and chasms.is_in_chasm(player:get_pos()) then + if unlocked["dfcaverns_visit_chasm"] ~= "dfcaverns_visit_chasm" and chasms.is_in_chasm(player:get_pos()) then awards.unlock(player_name, "dfcaverns_visit_chasm") end - if player_awards.unlocked["dfcaverns_visit_pit"] ~= "dfcaverns_visit_pit" then + if unlocked["dfcaverns_visit_pit"] ~= "dfcaverns_visit_pit" then local pos = player:get_pos() local pos_y = pos.y if pos_y < -30 then -- ignore pits when near the surface diff --git a/df_ambience/init.lua b/df_ambience/init.lua index fb1a89a..c323dfb 100644 --- a/df_ambience/init.lua +++ b/df_ambience/init.lua @@ -95,6 +95,8 @@ minetest.register_globalstep(function(dtime) timer = 0 local player_name + local number + local ambience -- loop through players for _, player in pairs(minetest.get_connected_players()) do diff --git a/df_dependencies/mapgen.lua b/df_dependencies/mapgen.lua index 0fe3e60..f6f2d1a 100644 --- a/df_dependencies/mapgen.lua +++ b/df_dependencies/mapgen.lua @@ -37,7 +37,10 @@ df_dependencies.mods_required.mcl_mapgen = true local old_overworld_min +local ores_extended = false local extend_ores = function() + if ores_extended then return end -- should only do this once. + ores_extended = true local ores_registered = {} for key, val in pairs(minetest.registered_ores) do ores_registered[val.ore] = true @@ -75,16 +78,19 @@ local extend_ores = function() local blob_copy = deep_copy(stone_blobs) blob_copy.ore = ore blob_copy.clust_num_ores = cluster_size + blob_copy.clust_size = math.ceil(math.sqrt(cluster_size)) + blob_copy.clust_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot blob_copy.seed = localseed - blob_copy.cluster_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot blob_copy.y_min = ymin or stone_blobs.y_min blob_copy.y_max = ymax or stone_blobs.y_max + --minetest.debug(dump(blob_copy)) + minetest.register_ore(blob_copy) end local scattered_ore = { wherein = wherein_stonelike, ore_type = "scatter", - ore = "mcl_core:stone_with_coal", + --ore = "mcl_core:stone_with_coal", clust_scarcity = 525*3, clust_num_ores = 5, clust_size = 3, @@ -94,24 +100,27 @@ local extend_ores = function() noise_threshold= 0, } - local register_scattered_internal = function(ore, cluster_size, cluster_scarcity_cuberoot, threshold, ymin, ymax) + local register_scattered_internal = function(ore, cluster_size, cluster_scarcity_cuberoot, threshold, ymin, ymax, wherein) local scattered_copy = deep_copy(scattered_ore) scattered_copy.ore = ore - scattered_copy.cluster_size = cluster_size*cluster_size*cluster_size - scattered_copy.clust_num_ores = math.ceil(scattered_copy.cluster_size/3) + scattered_copy.clust_size = cluster_size*cluster_size*cluster_size + scattered_copy.clust_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot + scattered_copy.clust_num_ores = math.ceil(scattered_copy.clust_size/3) scattered_copy.seed = localseed - scattered_copy.cluster_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot scattered_copy.threshold = threshold scattered_copy.y_min = ymin or scattered_ore.y_min scattered_copy.y_max = ymax or scattered_ore.y_max + scattered_copy.wherein = wherein or scattered_ore.wherein + --minetest.debug(dump(scattered_copy)) + minetest.register_ore(scattered_copy) end - local register_scattered = function(ore, cluster_size, cluster_scarcity_cuberoot, ymin, ymax) + local register_scattered = function(ore, cluster_size, cluster_scarcity_cuberoot, ymin, ymax, wherein) assert(not (ymin and ymax) or ymin < ymax, "Elevation parameter error for register_scattered") localseed = localseed + 1 -- increment this every time it's called to ensure different distributions -- same seed makes the noise patterns overlap. -- one produces widespread smaller clusters, other produces larger clusters at the peaks of the noise in addition to the smaller ones - register_scattered_internal(ore, cluster_size, cluster_scarcity_cuberoot, 0, ymin, ymax) - register_scattered_internal(ore, cluster_size*2, cluster_scarcity_cuberoot, 0.25, ymin, ymax) + register_scattered_internal(ore, cluster_size, cluster_scarcity_cuberoot, 0, ymin, ymax, wherein) + register_scattered_internal(ore, cluster_size*2, cluster_scarcity_cuberoot, 0.25, ymin, ymax, wherein) end if ores_registered["mcl_core:diorite"] then @@ -130,7 +139,10 @@ local extend_ores = function() table.insert(wherein_stonelike, "mcl_core:granite") end if ores_registered["mcl_core:dirt"] then - register_blob("mcl_core:dirt", 33, 15) + register_blob("mcl_core:dirt", 33, 15, config.sunless_sea_min) + if config.enable_primordial then + register_blob("mcl_core:dirt", 33, 15, config.primordial_min, config.primoridal_max) + end end if ores_registered["mcl_core:gravel"] then register_blob("mcl_core:gravel", 33, 14) @@ -181,19 +193,22 @@ local extend_ores = function() register_scattered("mcl_core:stone_with_copper", 3, 18) end + if ores_registered["mcl_deepslate:deepslate"] then + register_blob("mcl_deepslate:deepslate", 33, 15, lowest_elevation, config.sunless_sea_min) -- it's called deepslate, so put it deep + end + if ores_registered["mcl_deepslate:tuff"] then + register_blob("mcl_deepslate:tuff", 33, 15, lowest_elevation, config.sunless_sea_min) + end - -- more blobs - --"mcl_deepslate:deepslate" - --"mcl_deepslate:tuff" - - -- apparently very rare - --"mcl_deepslate:deepslate_with_emerald" - --"mcl_core:stone_with_emerald" + if ores_registered["mcl_deepslate:deepslate_with_emerald"] then + register_scattered("mcl_deepslate:deepslate_with_emerald", 1, 25, lowest_elevation, config.sunless_sea_min, "mcl_deepslate:deepslate") + end + if ores_registered["mcl_core:stone_with_emerald"] then + register_scattered("mcl_core:stone_with_emerald", 1, 25, lowest_elevation, config.sunless_sea_min) + end end - - if minetest.get_modpath("mcl_init") then -- Mineclone 2 old_overworld_min = mcl_vars.mg_overworld_min -- remember this for weather control @@ -203,9 +218,11 @@ if minetest.get_modpath("mcl_init") then -- Mineclone 2 mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + 10 mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000 - if minetest.settings:get_bool("mcl_generate_ores", true) then + -- shouldn't need to worry about the setting, extend_ores checks if the ores + -- have already been registered. + --if minetest.settings:get_bool("mcl_generate_ores", true) then extend_ores() - end + --end df_dependencies.mods_required.mcl_structures = true -- never mind - add dependency on mcl_strongholds and these will get generated before overworld_min gets changed. @@ -248,6 +265,8 @@ if minetest.get_modpath("mcl_mapgen") then -- Mineclone 5 .."does not have an mcl_mapgen.on_settings_changed method. This will likely result in " .."altitudes below the original bedrock being inaccessible to players.") end + + extend_ores() end if minetest.get_modpath("mcl_worlds") then local old_has_weather = mcl_worlds.has_weather diff --git a/df_trees/sapling_growth_conditions.lua b/df_trees/sapling_growth_conditions.lua index dbad310..846ea29 100644 --- a/df_trees/sapling_growth_conditions.lua +++ b/df_trees/sapling_growth_conditions.lua @@ -26,7 +26,8 @@ end df_trees.nether_cap_growth_permitted = function(pos) local below_name = minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name - return minetest.get_item_group(below_name, "cools_lava") > 0 and minetest.get_item_group(below_name, "nether_cap") == 0 + return (minetest.get_item_group(below_name, "cools_lava") > 0 or minetest.get_item_group(below_name, "ice") > 0) + and minetest.get_item_group(below_name, "nether_cap") == 0 end df_trees.spindlestem_growth_permitted = function(pos) diff --git a/looped_node_sound/init.lua b/looped_node_sound/init.lua index bad1a1a..e569339 100644 --- a/looped_node_sound/init.lua +++ b/looped_node_sound/init.lua @@ -16,7 +16,7 @@ looped_node_sound.register = function(def) local max_hear_distance = def.max_hear_distance or 32 -- Update sound for player - function update_player_sound(player) + local function update_player_sound(player) local player_name = player:get_player_name() -- Search for nodes in radius around player local ppos = player:get_pos()