From 38f6804a799b23706fd525a1dbd9c6e96e3317d2 Mon Sep 17 00:00:00 2001 From: Wuzzy Date: Tue, 19 Feb 2019 20:16:12 +0100 Subject: [PATCH] Update tsm_railcorridors to 0.14.0 --- mods/MAPGEN/tsm_railcorridors/README.md | 13 +- mods/MAPGEN/tsm_railcorridors/init.lua | 789 ++++++++++++------ .../MAPGEN/tsm_railcorridors/settingtypes.txt | 19 +- 3 files changed, 557 insertions(+), 264 deletions(-) diff --git a/mods/MAPGEN/tsm_railcorridors/README.md b/mods/MAPGEN/tsm_railcorridors/README.md index 9b2b745b2..de9df489e 100644 --- a/mods/MAPGEN/tsm_railcorridors/README.md +++ b/mods/MAPGEN/tsm_railcorridors/README.md @@ -1,11 +1,10 @@ # Railway corridors [`tsm_railcorridors`] MineClone 2 adaption. NO TREASURER SUPPORT! -* Current version 0.12.0 +* Current version 0.14.0 -Minetest mod for adding underground corridors with rails and wood constructions with -a few treasure chests now and then. Optional Treasurer support is available for adding -treasures from various mods. +Minetest mod for adding underground corridors with rails and wood constructions with a few treasure chests now and then. +Optional support for the Treasurer mod is available for adding treasures from various mods. Cobwebs are added if the `mobs_monster` mod is found. Use the advanced settings to finetune the railway corridors. @@ -13,6 +12,6 @@ Use the advanced settings to finetune the railway corridors. * Forum thread: https://forum.minetest.net/viewtopic.php?t=10339 * License: MIT License. -## Info for modders -Want to include this mod in a game, but you hate the dependencies? -You can edit the node names in gameconfig.lua to fit your needs. :-) +## Info for game makers +Want to include this mod in a game, but you have problems with the dependencies? +Edit `gameconfig.lua` to fit your needs. :-) diff --git a/mods/MAPGEN/tsm_railcorridors/init.lua b/mods/MAPGEN/tsm_railcorridors/init.lua index 57c183794..d6de8198a 100644 --- a/mods/MAPGEN/tsm_railcorridors/init.lua +++ b/mods/MAPGEN/tsm_railcorridors/init.lua @@ -12,15 +12,13 @@ local P = function (float) return math.floor(32767 * float) end --- Wahrscheinlichkeit für jeden Chunk, solche Gänge mit Schienen zu bekommen --- Probability for every newly generated chunk to get corridors -local probability_railcaves_in_chunk = P(0.3) -setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_railcaves_in_chunk")) +-- Probability for every newly generated mapchunk to get corridors +local probability_railcaves_in_mapchunk = P(0.33333) +setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_railcaves_in_mapchunk")) if setting then - probability_railcaves_in_chunk = P(setting) + probability_railcaves_in_mapchunk = P(setting) end --- Innerhalb welcher Parameter soll sich die Pfadlänge bewegen? (Forks heben den Maximalwert auf) -- Minimal and maximal value of path length (forks don't look up this value) local way_min = 4; local way_max = 7; @@ -33,7 +31,6 @@ if setting then way_max = setting end --- Wahrsch. für jeden geraden Teil eines Korridors, Fackeln zu bekommen -- Probability for every horizontal part of a corridor to be with torches local probability_torches_in_segment = P(0.5) setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_torches_in_segment")) @@ -41,7 +38,6 @@ if setting then probability_torches_in_segment = P(setting) end --- Wahrsch. für jeden Teil eines Korridors, nach oben oder nach unten zu gehen -- Probability for every part of a corridor to go up or down local probability_up_or_down = P(0.2) setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_up_or_down")) @@ -49,7 +45,6 @@ if setting then probability_up_or_down = P(setting) end --- Wahrscheinlichkeit für jeden Teil eines Korridors, sich zu verzweigen – vorsicht, wenn fast jeder Gang sich verzweigt, kann der Algorithums unlösbar werden und MT hängt sich auf -- Probability for every part of a corridor to fork – caution, too high values may cause MT to hang on. local probability_fork = P(0.04) setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_fork")) @@ -57,7 +52,6 @@ if setting then probability_fork = P(setting) end --- Wahrscheinlichkeit für jeden geraden Teil eines Korridors eine Kiste zu enthalten -- Probability for every part of a corridor to contain a chest local probability_chest = P(0.05) setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_chest")) @@ -66,17 +60,11 @@ if setting then end -- Probability for every part of a corridor to contain a cart --- Disabled because cart spawning creates error message spam: --- “m_static_exists=true but static data doesn't actually exist in (x,y,z) --- TODO: Set back to 0.05 when this is fixed. --- TODO: Remove minecarts from loot table when minecarts spawn on rails. -local probability_cart = P(0) ---[[ +local probability_cart = P(0.05) setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_cart")) if setting then probability_cart = P(setting) end -]] -- Probability for a rail corridor system to be damaged local probability_damage = P(1.0) @@ -111,27 +99,50 @@ local height_max = mcl_worlds.layer_to_y(60) -- Chaos Mode: If enabled, rail corridors don't stop generating when hitting obstacles local chaos_mode = minetest.settings:get_bool("tsm_railcorridors_chaos") or false --- Parameter Ende +-- End of parameters --- Random generators -local pr, webperlin_major, webperlin_minor -local pr_initialized = false +if not tsm_railcorridors.nodes.corridor_woods_function then + local accumulated_chance = 0 + for w=1, #tsm_railcorridors.nodes.corridor_woods do + accumulated_chance = accumulated_chance + tsm_railcorridors.nodes.corridor_woods[w].chance + end + assert(accumulated_chance == 1000, "Rail corridor wood chances add up to "..accumulated_chance.." per mille! (should be 1000 per mille)") +end + +-- Random Perlin noise generators +local pr, pr_carts, pr_treasures, pr_deco, webperlin_major, webperlin_minor local function InitRandomizer(seed) -- Mostly used for corridor gen. pr = PseudoRandom(seed) + -- Dirt room decorations + pr_deco = PseudoRandom(seed+25) + -- Separate randomizer for carts because spawning carts is very timing-dependent + pr_carts = PseudoRandom(seed-654) + -- Chest contents randomizer + pr_treasures = PseudoRandom(seed+777) -- Used for cobweb generation, both noises have to reach a high value for cobwebs to appear webperlin_major = PerlinNoise(934, 3, 0.6, 500) webperlin_minor = PerlinNoise(834, 3, 0.6, 50) - pr_initialized = true + pr_inited = true end +local carts_table = {} + +local dirt_room_coords + +-- Returns true if pos is inside the dirt room of the current corridor system +local function IsInDirtRoom(pos) + local min = dirt_room_coords.min + local max = dirt_room_coords.max + return pos.x >= min.x and pos.x <= max.x and pos.y >= min.y and pos.y <= max.y and pos.z >= min.z and pos.z <= max.z +end -- Checks if the mapgen is allowed to carve through this structure and only sets -- the node if it is allowed. Does never build in liquids. -- If check_above is true, don't build if the node above is attached (e.g. rail) -- or a liquid. -local function SetNodeIfCanBuild(pos, node, check_above) +local function SetNodeIfCanBuild(pos, node, check_above, can_replace_rail) if check_above then local abovename = minetest.get_node({x=pos.x,y=pos.y+1,z=pos.z}).name local abovedef = minetest.registered_nodes[abovename] @@ -144,8 +155,13 @@ local function SetNodeIfCanBuild(pos, node, check_above) end local name = minetest.get_node(pos).name local def = minetest.registered_nodes[name] - if name ~= "unknown" and name ~= "ignore" and def.is_ground_content and - (def.liquidtype == "none" or name == tsm_railcorridors.nodes.cobweb) then + if name ~= "unknown" and name ~= "ignore" and + ((def.is_ground_content and def.liquidtype == "none") or + name == tsm_railcorridors.nodes.cobweb or + name == tsm_railcorridors.nodes.torch_wall or + name == tsm_railcorridors.nodes.torch_floor or + (can_replace_rail and name == tsm_railcorridors.nodes.rail) + ) then minetest.set_node(pos, node) return true else @@ -175,8 +191,9 @@ end -- Returns true if rails are allowed to be placed on top of this node local function IsRailSurface(pos) local nodename = minetest.get_node(pos).name + local nodename_above = minetest.get_node({x=pos.x,y=pos.y+2,z=pos.z}).name local nodedef = minetest.registered_nodes[nodename] - return nodename ~= "unknown" and nodename ~= "ignore" and nodedef.walkable and (nodedef.node_box == nil or nodedef.node_box.type == "regular") + return nodename ~= "unknown" and nodename ~= "ignore" and nodedef.walkable and (nodedef.node_box == nil or nodedef.node_box.type == "regular") and nodename_above ~= tsm_railcorridors.nodes.rail end -- Checks if the node is empty space which requires to be filled by a platform @@ -184,36 +201,91 @@ local function NeedsPlatform(pos) local node = minetest.get_node({x=pos.x,y=pos.y-1,z=pos.z}) local node2 = minetest.get_node({x=pos.x,y=pos.y-2,z=pos.z}) local nodedef = minetest.registered_nodes[node.name] - return node.name ~= "ignore" and node.name ~= "unknown" and nodedef.is_ground_content and ((nodedef.walkable == false and node2.name ~= tsm_railcorridors.nodes.dirt) or (nodedef.groups and nodedef.groups.falling_node)) + local falling = minetest.get_item_group(node.name, "falling_node") == 1 + return + -- Node can be replaced if ground content or rail + (node.name ~= "ignore" and node.name ~= "unknown" and nodedef.is_ground_content) and + -- Node needs platform if node below is not walkable. + -- Unless 2 nodes below there is dirt: This is a special case for the starter cube. + ((nodedef.walkable == false and node2.name ~= tsm_railcorridors.nodes.dirt) or + -- Falling nodes always need to be replaced by a platform, we want a solid and safe ground + falling), + -- second return value + falling end -- Create a cube filled with the specified nodes -- Specialties: --- * Avoids floating rails for non-solid nodes like air +-- * Avoids floating rails +-- * May cut into wood structures of the corridors (alongside with their torches) +-- Arguments: +-- * p: Center position +-- * radius: How many nodes from the center the cube will extend +-- * node: Node to set +-- * replace_air_only: If true, only air can be replaced +-- * wood, post: Wood and post nodes of the railway corridor to cut into (optional) + -- Returns true if all nodes could be set -- Returns false if setting one or more nodes failed -local function Cube(p, radius, node, replace_air_only) +local function Cube(p, radius, node, replace_air_only, wood, post) local y_top = p.y+radius local nodedef = minetest.registered_nodes[node.name] local solid = nodedef.walkable and (nodedef.node_box == nil or nodedef.node_box.type == "regular") and nodedef.liquidtype == "none" -- Check if all the nodes could be set local built_all = true - for zi = p.z-radius, p.z+radius do - for yi = y_top, p.y-radius, -1 do - for xi = p.x-radius, p.x+radius do + + -- If wood has been removed, remod + local cleanup_torches = {} + for xi = p.x-radius, p.x+radius do + for zi = p.z-radius, p.z+radius do + local column_last_attached = nil + for yi = y_top, p.y-radius, -1 do local ok = false - if not solid and yi == y_top then - local topdef = minetest.registered_nodes[minetest.get_node({x=xi,y=yi+1,z=zi}).name] - if not (topdef.groups and topdef.groups.attached_node) and topdef.liquidtype == "none" then + local thisnode = minetest.get_node({x=xi,y=yi,z=zi}) + if not solid then + if yi == y_top then + local topnode = minetest.get_node({x=xi,y=yi+1,z=zi}) + local topdef = minetest.registered_nodes[topnode.name] + if minetest.get_item_group(topnode.name, "attached_node") ~= 1 and topdef.liquidtype == "none" then + ok = true + end + elseif column_last_attached and yi == column_last_attached - 1 then + ok = false + else ok = true end + if minetest.get_item_group(thisnode.name, "attached_node") == 1 then + column_last_attached = yi + end else ok = true end local built = false if ok then if replace_air_only ~= true then - built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, node) + -- Cut into wood structures (post/wood) + if post and (xi == p.x or zi == p.z) and thisnode.name == post then + minetest.set_node({x=xi,y=yi,z=zi}, node) + built = true + elseif wood and (xi == p.x or zi == p.z) and thisnode.name == wood then + local topnode = minetest.get_node({x=xi,y=yi+1,z=zi}) + local topdef = minetest.registered_nodes[topnode.name] + if topdef.walkable and topnode.name ~= wood then + minetest.set_node({x=xi,y=yi,z=zi}, node) + -- Check for torches around the wood and schedule them + -- for removal + if node.name == "air" then + table.insert(cleanup_torches, {x=xi+1,y=yi,z=zi}) + table.insert(cleanup_torches, {x=xi-1,y=yi,z=zi}) + table.insert(cleanup_torches, {x=xi,y=yi,z=zi+1}) + table.insert(cleanup_torches, {x=xi,y=yi,z=zi-1}) + end + built = true + end + -- Set node normally + else + built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, node) + end else if minetest.get_node({x=xi,y=yi,z=zi}).name == "air" then built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, node) @@ -226,15 +298,74 @@ local function Cube(p, radius, node, replace_air_only) end end end + -- Remove torches we have detected before + for c=1, #cleanup_torches do + local check = minetest.get_node(cleanup_torches[c]) + if check.name == tsm_railcorridors.nodes.torch_wall or check.name == tsm_railcorridors.nodes.torch_floor then + minetest.set_node(cleanup_torches[c], node) + end + end return built_all end -local function Platform(p, radius, node) +local function DirtRoom(p, radius, height, dirt_mode, decorations_mode) + local y_bottom = p.y + local y_top = y_bottom + height + 1 + dirt_room_coords = { + min = { x = p.x-radius, y = y_bottom, z = p.z-radius }, + max = { x = p.x+radius, y = y_top, z = p.z+radius }, + } + local built_all = true + for xi = p.x-radius, p.x+radius do + for zi = p.z-radius, p.z+radius do + for yi = y_top, y_bottom, -1 do + local thisnode = minetest.get_node({x=xi,y=yi,z=zi}) + local built = false + if xi == p.x-radius or xi == p.x+radius or zi == p.z-radius or zi == p.z+radius or yi == y_bottom or yi == y_top then + if dirt_mode == 1 or yi == y_bottom then + built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, {name=tsm_railcorridors.nodes.dirt}) + elseif (dirt_mode == 2 or dirt_mode == 3) and yi == y_top then + if minetest.get_item_group(thisnode.name, "falling_node") == 1 then + built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, {name=tsm_railcorridors.nodes.dirt}) + end + end + else + if yi == y_bottom + 1 then + -- crazy rails + if decorations_mode == 1 then + local r = pr_deco:next(1,3) + if r == 2 then + built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, {name=tsm_railcorridors.nodes.rail}) + end + end + end + if not built then + built = SetNodeIfCanBuild({x=xi,y=yi,z=zi}, {name="air"}) + end + end + if not built then + built_all = false + end + end + end + end + return built_all +end + +local function Platform(p, radius, node, node2) + -- node2 is secondary platform material for replacing falling nodes + if not node2 then + node2 = { name = tsm_railcorridors.nodes.dirt } + end for zi = p.z-radius, p.z+radius do for xi = p.x-radius, p.x+radius do - local np = NeedsPlatform({x=xi,y=p.y,z=zi}) + local np, np2 = NeedsPlatform({x=xi,y=p.y,z=zi}) if np then - minetest.set_node({x=xi,y=p.y-1,z=zi}, node) + if np2 then + minetest.set_node({x=xi,y=p.y-1,z=zi}, node2) + else + minetest.set_node({x=xi,y=p.y-1,z=zi}, node) + end end end end @@ -253,36 +384,24 @@ local function PlaceChest(pos, param2) end -- This function checks if a cart has ACTUALLY been spawned. --- If not, it tries to spawn it again, and again, until it succeeded or --- it failed too often. -- To be calld by minetest.after. --- This is a HORRIBLE workaround thanks to the fact that minetest.add_entity is unreliable as fuck +-- This is a workaround thanks to the fact that minetest.add_entity is unreliable as fuck -- See: https://github.com/minetest/minetest/issues/4759 -- FIXME: Kill this horrible hack with fire as soon you can. local function RecheckCartHack(params) local pos = params[1] local cart_id = params[2] - local tries = params[3] - tries = tries - 1 -- Find cart for _, obj in ipairs(minetest.get_objects_inside_radius(pos, 1)) do if obj ~= nil and obj:get_luaentity().name == cart_id then -- Cart found! We can now safely call the callback func. -- (calling it earlier has the danger of failing) + minetest.log("info", "[tsm_railcorridors] Cart spawn succeeded: "..minetest.pos_to_string(pos)) tsm_railcorridors.on_construct_cart(pos, obj) return end end - if tries <= 0 then - -- Abort if too many tries to avoid excessive function calls - return - end - -- No cart found! :-( Try again … - if minetest.get_node(pos).name == tsm_railcorridors.nodes.rail then - minetest.add_entity(pos, cart_id) - minetest.after(5, RecheckCartHack, {pos, cart_id, tries}) - end - -- The rail may have been destroyed in the meantime, that's why the node is checked. + minetest.log("info", "[tsm_railcorridors] Cart spawn FAILED: "..minetest.pos_to_string(pos)) end -- Try to place a cobweb. @@ -321,27 +440,108 @@ local function TryPlaceCobweb(pos, needs_check, side_vector) return false end end - -local function WoodBulk(pos, wood) - SetNodeIfCanBuild({x=pos.x+1, y=pos.y, z=pos.z+1}, {name=wood}) - SetNodeIfCanBuild({x=pos.x-1, y=pos.y, z=pos.z+1}, {name=wood}) - SetNodeIfCanBuild({x=pos.x+1, y=pos.y, z=pos.z-1}, {name=wood}) - SetNodeIfCanBuild({x=pos.x-1, y=pos.y, z=pos.z-1}, {name=wood}) + +-- 4 wooden pillars around pos at height +local function WoodBulk(pos, height, wood) + for y=0, height-1 do + SetNodeIfCanBuild({x=pos.x+1, y=pos.y+y, z=pos.z+1}, {name=wood}, false, true) + SetNodeIfCanBuild({x=pos.x-1, y=pos.y+y, z=pos.z+1}, {name=wood}, false, true) + SetNodeIfCanBuild({x=pos.x+1, y=pos.y+y, z=pos.z-1}, {name=wood}, false, true) + SetNodeIfCanBuild({x=pos.x-1, y=pos.y+y, z=pos.z-1}, {name=wood}, false, true) + end end --- Gänge mit Schienen --- Corridors with rails +-- Build a wooden support frame +local function WoodSupport(p, wood, post, torches, dir, torchdir) + local node_wood = {name=wood} + local node_fence = {name=post} + + local calc = { + p.x+dir[1], p.z+dir[2], -- X and Z, added by direction + p.x-dir[1], p.z-dir[2], -- subtracted + p.x+dir[2], p.z+dir[1], -- orthogonal + p.x-dir[2], p.z-dir[1], -- orthogonal, the other way + } + --[[ Shape: + WWW + P.P + PrP + pfp + W = wood + P = post (above floor level) + p = post (in floor level, only placed if no floor) + + From previous generation (for reference): + f = floor + r = rail + . = air + ]] + + -- Don't place those wood structs below open air + if not (minetest.get_node({x=calc[1], y=p.y+2, z=calc[2]}).name == "air" and + minetest.get_node({x=calc[3], y=p.y+2, z=calc[4]}).name == "air" and + minetest.get_node({x=p.x, y=p.y+2, z=p.z}).name == "air") then + + -- Left post and planks + local left_ok + left_ok = SetNodeIfCanBuild({x=calc[1], y=p.y-1, z=calc[2]}, node_fence) + if left_ok then left_ok = SetNodeIfCanBuild({x=calc[1], y=p.y , z=calc[2]}, node_fence) end + if left_ok then left_ok = SetNodeIfCanBuild({x=calc[1], y=p.y+1, z=calc[2]}, node_wood, false, true) end + + -- Right post and planks + local right_ok + right_ok = SetNodeIfCanBuild({x=calc[3], y=p.y-1, z=calc[4]}, node_fence) + if right_ok then right_ok = SetNodeIfCanBuild({x=calc[3], y=p.y , z=calc[4]}, node_fence) end + if right_ok then right_ok = SetNodeIfCanBuild({x=calc[3], y=p.y+1, z=calc[4]}, node_wood, false, true) end + + -- Middle planks + local top_planks_ok = false + if left_ok and right_ok then top_planks_ok = SetNodeIfCanBuild({x=p.x, y=p.y+1, z=p.z}, node_wood) end + + if minetest.get_node({x=p.x,y=p.y-2,z=p.z}).name=="air" then + if left_ok then SetNodeIfCanBuild({x=calc[1], y=p.y-2, z=calc[2]}, node_fence) end + if right_ok then SetNodeIfCanBuild({x=calc[3], y=p.y-2, z=calc[4]}, node_fence) end + end + -- Torches on the middle planks + if torches and top_planks_ok then + -- Place torches at horizontal sides + SetNodeIfCanBuild({x=calc[5], y=p.y+1, z=calc[6]}, {name=tsm_railcorridors.nodes.torch_wall, param2=torchdir[1]}, true) + SetNodeIfCanBuild({x=calc[7], y=p.y+1, z=calc[8]}, {name=tsm_railcorridors.nodes.torch_wall, param2=torchdir[2]}, true) + end + elseif torches then + -- Try to build torches instead of the wood structs + local node = {name=tsm_railcorridors.nodes.torch_floor, param2=minetest.dir_to_wallmounted({x=0,y=-1,z=0})} + + -- Try two different height levels + local pos1 = {x=calc[1], y=p.y-2, z=calc[2]} + local pos2 = {x=calc[3], y=p.y-2, z=calc[4]} + local nodedef1 = minetest.registered_nodes[minetest.get_node(pos1).name] + local nodedef2 = minetest.registered_nodes[minetest.get_node(pos2).name] + + if nodedef1.walkable then + pos1.y = pos1.y + 1 + end + SetNodeIfCanBuild(pos1, node, true) + + if nodedef2.walkable then + pos2.y = pos2.y + 1 + end + SetNodeIfCanBuild(pos2, node, true) + + end +end + +-- Dig out a single corridor section and place wooden structures and torches -- Returns , -- success: true if corridor could be placed entirely -- segments: Number of segments successfully placed -local function corridor_part(start_point, segment_vector, segment_count, wood, post, first_or_final, up_or_down_prev) +local function dig_corridor_section(start_point, segment_vector, segment_count, wood, post, up_or_down_prev) local p = {x=start_point.x, y=start_point.y, z=start_point.z} local torches = pr:next() < probability_torches_in_segment local dir = {0, 0} local torchdir = {1, 1} local node_wood = {name=wood} - local node_fence = {name=post} if segment_vector.x == 0 and segment_vector.z ~= 0 then dir = {1, 0} torchdir = {5, 4} @@ -350,7 +550,12 @@ local function corridor_part(start_point, segment_vector, segment_count, wood, p torchdir = {3, 2} end for segmentindex = 0, segment_count-1 do - local dug = Cube(p, 1, {name="air"}) + local dug + if segment_vector.y == 0 then + dug = Cube(p, 1, {name="air"}, false, wood, post) + else + dug = Cube(p, 1, {name="air"}, false) + end if not chaos_mode and segmentindex > 0 and not dug then return false, segmentindex end -- Add wooden platform, if neccessary. To avoid floating rails if segment_vector.y == 0 then @@ -364,92 +569,27 @@ local function corridor_part(start_point, segment_vector, segment_count, wood, p -- Normal 3×3 platform Platform({x=p.x, y=p.y-1, z=p.z}, 1, node_wood) end + else + -- Sloped bridge + Platform({x=p.x-dir[1], y=p.y-2, z=p.z-dir[2]}, 0, node_wood) + Platform({x=p.x, y=p.y-2, z=p.z}, 0, node_wood) + Platform({x=p.x+dir[1], y=p.y-2, z=p.z+dir[2]}, 0, node_wood) end - -- Diese komischen Holz-Konstruktionen - -- These strange wood structs if segmentindex % 2 == 1 and segment_vector.y == 0 then - local calc = { - p.x+dir[1], p.z+dir[2], -- X and Z, added by direction - p.x-dir[1], p.z-dir[2], -- subtracted - p.x+dir[2], p.z+dir[1], -- orthogonal - p.x-dir[2], p.z-dir[1], -- orthogonal, the other way - } - --[[ Shape: - WWW - P.P - PrP - pfp - W = wood - P = post (above floor level) - p = post (in floor level, only placed if no floor) - - From previous generation (for reference): - f = floor - r = rail - . = air - ]] - - -- Don't place those wood structs below open air - if not (minetest.get_node({x=calc[1], y=p.y+2, z=calc[2]}).name == "air" and - minetest.get_node({x=calc[3], y=p.y+2, z=calc[4]}).name == "air" and - minetest.get_node({x=p.x, y=p.y+2, z=p.z}).name == "air") then - - -- Left post and planks - local left_ok = true - left_ok = SetNodeIfCanBuild({x=calc[1], y=p.y-1, z=calc[2]}, node_fence) - if left_ok then left_ok = SetNodeIfCanBuild({x=calc[1], y=p.y , z=calc[2]}, node_fence) end - if left_ok then left_ok = SetNodeIfCanBuild({x=calc[1], y=p.y+1, z=calc[2]}, node_wood) end - - -- Right post and planks - local right_ok = true - right_ok = SetNodeIfCanBuild({x=calc[3], y=p.y-1, z=calc[4]}, node_fence) - if right_ok then right_ok = SetNodeIfCanBuild({x=calc[3], y=p.y , z=calc[4]}, node_fence) end - if right_ok then right_ok = SetNodeIfCanBuild({x=calc[3], y=p.y+1, z=calc[4]}, node_wood) end - - -- Middle planks - local top_planks_ok = false - if left_ok and right_ok then top_planks_ok = SetNodeIfCanBuild({x=p.x, y=p.y+1, z=p.z}, node_wood) end - - if minetest.get_node({x=p.x,y=p.y-2,z=p.z}).name=="air" then - if left_ok then SetNodeIfCanBuild({x=calc[1], y=p.y-2, z=calc[2]}, node_fence) end - if right_ok then SetNodeIfCanBuild({x=calc[3], y=p.y-2, z=calc[4]}, node_fence) end - end - -- Torches on the middle planks - if torches and top_planks_ok then - -- Place torches at horizontal sides - SetNodeIfCanBuild({x=calc[5], y=p.y+1, z=calc[6]}, {name=tsm_railcorridors.nodes.torch_wall, param2=torchdir[1]}, true) - SetNodeIfCanBuild({x=calc[7], y=p.y+1, z=calc[8]}, {name=tsm_railcorridors.nodes.torch_wall, param2=torchdir[2]}, true) - end - elseif torches then - -- Try to build torches instead of the wood structs - local node = {name=tsm_railcorridors.nodes.torch_floor, param2=minetest.dir_to_wallmounted({x=0,y=-1,z=0})} - - -- Try two different height levels - local pos1 = {x=calc[1], y=p.y-2, z=calc[2]} - local pos2 = {x=calc[3], y=p.y-2, z=calc[4]} - local nodedef1 = minetest.registered_nodes[minetest.get_node(pos1).name] - local nodedef2 = minetest.registered_nodes[minetest.get_node(pos2).name] - - if nodedef1.walkable then - pos1.y = pos1.y + 1 - end - SetNodeIfCanBuild(pos1, node, true) - - if nodedef2.walkable then - pos2.y = pos2.y + 1 - end - SetNodeIfCanBuild(pos2, node, true) - - end + WoodSupport(p, wood, post, torches, dir, torchdir) end - - -- nächster Punkt durch Vektoraddition - -- next way point + + -- Next way point p = vector.add(p, segment_vector) end -- End of the corridor segment; create the final piece - local dug = Cube(p, 1, {name="air"}) + local dug + if segment_vector.y == 0 then + dug = Cube(p, 1, {name="air"}, false, wood, post) + else + dug = Cube(p, 1, {name="air"}, false) + end if not chaos_mode and not dug then return false, segment_count end if segment_vector.y == 0 then Platform({x=p.x, y=p.y-1, z=p.z}, 1, node_wood) @@ -457,7 +597,11 @@ local function corridor_part(start_point, segment_vector, segment_count, wood, p return true, segment_count end -local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, up_or_down_prev, up, wood, post, first_or_final, damage, no_spawner) +-- Generate a corridor section. Corridor sections are part of a corridor line. +-- This is one short part of a corridor line. It can be one straight section or it goes up or down. +-- It digs out the corridor and places wood structs and torches using the helper function dig_corridor_function, +-- then it places rails, chests, and other goodies. +local function create_corridor_section(waypoint, axis, sign, up_or_down, up_or_down_next, up_or_down_prev, up, wood, post, first_or_final, damage, no_spawner) local segamount = 3 if up_or_down then segamount = 1 @@ -467,12 +611,12 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, end local vek = {x=0,y=0,z=0}; local start = table.copy(waypoint) - if coord == "x" then + if axis == "x" then vek.x=segamount if up_or_down and up == false then start.x=start.x+segamount end - elseif coord == "z" then + elseif axis == "z" then vek.z=segamount if up_or_down and up == false then start.z=start.z+segamount @@ -487,20 +631,19 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, end local segcount = pr:next(4,6) if up_or_down and up == false then - Cube(waypoint, 1, {name="air"}) + Cube(waypoint, 1, {name="air"}, false) end - local corridor_dug, corridor_segments_dug = corridor_part(start, vek, segcount, wood, post, first_or_final, up_or_down_prev) + local corridor_dug, corridor_segments_dug = dig_corridor_section(start, vek, segcount, wood, post, up_or_down_prev) local corridor_vek = {x=vek.x*segcount, y=vek.y*segcount, z=vek.z*segcount} - -- nachträglich Schienen legen - -- after this: rails + -- After this: rails segamount = 1 if sign then segamount = 0-segamount end - if coord == "x" then + if axis == "x" then vek.x=segamount - elseif coord == "z" then + elseif axis == "z" then vek.z=segamount end if up_or_down then @@ -541,7 +684,7 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, -- Randomly returns either the left or right side of the main rail. -- Also returns offset as second return value. local left_or_right = function(pos, vek) - local off, facedir + local off if pr:next(1, 2) == 1 then -- left off = {x = -vek.z, y= 0, z = vek.x} @@ -565,32 +708,30 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, -- Chest if i == chestplace then local cpos, offset = left_or_right(p, vek) - if minetest.get_node(cpos).name == post then + if minetest.get_node(cpos).name == post or IsInDirtRoom(p) then chestplace = chestplace + 1 else PlaceChest(cpos, minetest.dir_to_facedir(offset)) end end - -- Rail and cart - if i == cartplace then + -- A rail at the side of the track to put a cart on + if i == cartplace and #tsm_railcorridors.carts > 0 then local cpos = left_or_right(p, vek) if minetest.get_node(cpos).name == post then cartplace = cartplace + 1 else - local placed = PlaceRail(cpos, damage) + local placed + if IsRailSurface({x=cpos.x, y=cpos.y-1, z=cpos.z}) then + placed = PlaceRail(cpos, damage) + else + placed = false + end if placed then - local cart_type = pr:next(1, #tsm_railcorridors.carts) - -- FIXME: The cart sometimes fails to spawn - -- See - local cart_id = tsm_railcorridors.carts[cart_type] - local cart = minetest.add_entity(cpos, cart_id) - - -- This checks if the cart is actually spawned, it's a giant hack! - -- Note that the callback function is also called there. - -- TODO: Move callback function to this position when the - -- minetest.add_entity bug has been fixed. - minetest.after(2, RecheckCartHack, {cpos, cart_id, 10}) + -- We don't put on a cart yet, we put it in the carts table + -- for later placement + local cart_type = pr_carts:next(1, #tsm_railcorridors.carts) + table.insert(carts_table, {pos = cpos, cart_type = cart_type}) end end end @@ -649,7 +790,7 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, end end - + local offset = table.copy(corridor_vek) local final_point = vector.add(waypoint, offset) if up_or_down then @@ -657,12 +798,13 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, offset.y = offset.y - 1 final_point = vector.add(waypoint, offset) else - offset[coord] = offset[coord] + segamount + offset[axis] = offset[axis] + segamount final_point = vector.add(waypoint, offset) - -- After going up or down, 1 missing rail piece must be added - if IsRailSurface({x=final_point.x,y=final_point.y-2,z=final_point.z}) then - PlaceRail({x=final_point.x,y=final_point.y-1,z=final_point.z}, damage) - end + end + -- After going up or down, 1 missing rail piece must be added + Platform({x=final_point.x,y=final_point.y-1,z=final_point.z}, 0, {name=wood}) + if IsRailSurface({x=final_point.x,y=final_point.y-2,z=final_point.z}) then + PlaceRail({x=final_point.x,y=final_point.y-1,z=final_point.z}, damage) end end if not corridor_dug then @@ -672,34 +814,46 @@ local function corridor_func(waypoint, coord, sign, up_or_down, up_or_down_next, end end -local function start_corridor(waypoint, coord, sign, length, psra, wood, post, damage, no_spawner) +-- Generate a line of corridors. +-- The corridor can go up/down, take turns and it can branch off, creating more corridor lines. +local function create_corridor_line(waypoint, axis, sign, length, wood, post, damage, no_spawner) local wp = waypoint - local c = coord + local a = axis local s = sign - local ud = false -- up or down - local udn = false -- up or down is next - local udp = false -- up or down was previous - local up + local ud = false -- Up or down + local udn = false -- Up or down is next + local udp = false -- Up or down was previous + local up = false -- true if going up + local upp = false -- true if was going up previously for i=1,length do - local needs_platform -- Update previous up/down status udp = ud + -- Can't go up/down if a platform is needed at waypoint + local needs_platform = NeedsPlatform({x=wp.x,y=wp.y-2,z=wp.z}) -- Update current up/down status - if udn then - needs_platform = NeedsPlatform(wp) - if needs_platform then - ud = false - end + if udn and not needs_platform then ud = true -- Force direction near the height limits if wp.y >= height_max - 12 then + if udp then + ud = false + end up = false elseif wp.y <= height_min + 12 then + if udp then + ud = false + end up = true else - -- Chose random direction in between - up = pr:next(0, 2) < 1 + -- If previous was up/down, keep the vertical direction + if udp and not chaos_mode then + up = upp + else + -- Chose random direction + up = pr:next(1, 2) == 1 + end end + upp = up else ud = false end @@ -709,71 +863,141 @@ local function start_corridor(waypoint, coord, sign, length, psra, wood, post, d elseif udn and not needs_platform then udn = false end - -- Make corridor / Korridor graben + -- Make corridor local first_or_final if i == length then first_or_final = "final" elseif i == 1 then first_or_final = "first" end - wp, no_spawner = corridor_func(wp,c,s, ud, udn, udp, up, wood, post, first_or_final, damage, no_spawner) + wp, no_spawner = create_corridor_section(wp,a,s, ud, udn, udp, up, wood, post, first_or_final, damage, no_spawner) if wp == false then return end - -- Verzweigung? - -- Fork? + -- Fork in the road? If so, starts 2-3 new corridor lines and terminates the current one. if pr:next() < probability_fork then + -- 75% chance to fork off in 3 directions (making a crossing) + -- 25% chance to fork off in 2 directions (making a t-junction) + local is_crossing = pr:next(0, 3) < 3 + local forks = 2 + if is_crossing then + forks = 3 + end local p = {x=wp.x, y=wp.y, z=wp.z} - start_corridor(wp, c, s, pr:next(way_min,way_max), psra, wood, post, damage, no_spawner) - if c == "x" then c="z" else c="x" end - start_corridor(wp, c, s, pr:next(way_min,way_max), psra, wood, post, damage, no_spawner) - start_corridor(wp, c, not s, pr:next(way_min,way_max), psra, wood, post, damage, no_spawner) - WoodBulk({x=p.x, y=p.y-1, z=p.z}, wood) - WoodBulk({x=p.x, y=p.y, z=p.z}, wood) - WoodBulk({x=p.x, y=p.y+1, z=p.z}, wood) - WoodBulk({x=p.x, y=p.y+2, z=p.z}, wood) + local a2 + if a == "x" then + a2="z" + else + a2="x" + end + local fork_dirs = { + {a2, s}, -- to the side + {a2, not s}, -- to the other side + {a, s}, -- straight ahead + } + for f=1, forks do + local r = pr:next(1, #fork_dirs) + create_corridor_line(wp, fork_dirs[r][1], fork_dirs[r][2], pr:next(way_min,way_max), wood, post, damage, no_spawner) + table.remove(fork_dirs, r) + end + if is_crossing and not IsInDirtRoom(p) then + -- 4 large wooden pillars around the center rail + WoodBulk({x=p.x, y=p.y-1, z=p.z}, 4, wood) + end return end - -- coord und sign verändern - -- randomly change sign and coord - if c=="x" then - c="z" - elseif c=="z" then - c="x" + -- Randomly change sign, toggle axis. + -- In other words, take a turn. + if a=="x" then + a="z" + elseif a=="z" then + a="x" end; - s = pr:next(0, 2) < 1 + s = pr:next(1, 2) == 1 end end -local function place_corridors(main_cave_coords, psra) - --[[ ALWAYS start building in the ground. Prevents corridors starting - in mid-air or in liquids. ]] - if not IsGround(main_cave_coords) then - return +-- Spawns all carts in the carts table and clears the carts table afterwards +local function spawn_carts() + for c=1, #carts_table do + local cpos = carts_table[c].pos + local cart_type = carts_table[c].cart_type + local node = minetest.get_node(cpos) + if node.name == tsm_railcorridors.nodes.rail then + -- FIXME: The cart sometimes fails to spawn + -- See + local cart_id = tsm_railcorridors.carts[cart_type] + minetest.log("info", "[tsm_railcorridors] Cart spawn attempt: "..minetest.pos_to_string(cpos)) + minetest.add_entity(cpos, cart_id) + + -- This checks if the cart is actually spawned, it's a giant hack! + -- Note that the callback function is also called there. + -- TODO: Move callback function to this position when the + -- minetest.add_entity bug has been fixed. + minetest.after(3, RecheckCartHack, {cpos, cart_id}) + end end + carts_table = {} +end + +-- Start generation of a rail corridor system +-- main_cave_coords is the center of the floor of the dirt room, from which +-- all corridors expand. +local function create_corridor_system(main_cave_coords) + + -- Dirt room size + local maxsize = 6 + if chaos_mode then + maxsize = 9 + end + local size = pr:next(3, maxsize) + + --[[ Only build if starter coords are in the ground. + Prevents corridors starting in mid-air or in liquids. ]] + local check_coords = { + -- Center of the room, on the floor + {x=0,y=0,z=0}, + -- Also check near the 4 bottom corners of the dirt room + {x= size-1, y=0, z=size-1}, + {x=-size+1, y=0, z=size-1}, + {x= size-1, y=0, z=-size+1}, + {x=-size+1, y=0, z=-size+1}, + } + for c=1, #check_coords do + if not IsGround(vector.add(main_cave_coords, check_coords[c])) then + return false + end + end + local center_node = minetest.get_node(main_cave_coords) + local height = pr:next(4, 7) + if height > size then + height = size + end + local floor_diff = 1 + if pr:next(0, 100) < 50 then + floor_diff = 0 + end + local dirt_mode = pr:next(1,2) + local rnd = pr:next(1,1000) + -- Small chance to fill dirt room with random rails + local decorations_mode = 0 + if rnd == 1000 then + decorations_mode = 1 + end + + --[[ Starting point: A big hollow dirt cube from which the corridors will extend. + Corridor generation starts here. ]] + DirtRoom(main_cave_coords, size, height, dirt_mode, decorations_mode) + main_cave_coords.y = main_cave_coords.y + 2 + floor_diff + -- Determine if this corridor system is “damaged” (some rails removed) and to which extent local damage = 0 if pr:next() < probability_damage then damage = pr:next(10, 50) end - --[[ Starter cube: A big hollow dirt cube from which the corridors will extend. - Corridor generation starts here. ]] - if pr:next(0, 100) < 50 then - Cube(main_cave_coords, 4, {name=tsm_railcorridors.nodes.dirt}) - Cube(main_cave_coords, 3, {name="air"}) - -- Center rail - PlaceRail({x=main_cave_coords.x, y=main_cave_coords.y-3, z=main_cave_coords.z}, damage) - main_cave_coords.y =main_cave_coords.y - 1 - else - Cube(main_cave_coords, 3, {name=tsm_railcorridors.nodes.dirt}) - Cube(main_cave_coords, 2, {name="air"}) - -- Center rail - PlaceRail({x=main_cave_coords.x, y=main_cave_coords.y-2, z=main_cave_coords.z}, damage) - end - local xs = pr:next(0, 2) < 1 - local zs = pr:next(0, 2) < 1; -- Get wood and fence post types, using gameconfig. + local wood, post if tsm_railcorridors.nodes.corridor_woods_function then -- Get wood type by gameconfig function @@ -787,10 +1011,6 @@ local function place_corridors(main_cave_coords, psra) for w=1, #tsm_railcorridors.nodes.corridor_woods do local woodtable = tsm_railcorridors.nodes.corridor_woods[w] accumulated_chance = accumulated_chance + woodtable.chance - if accumulated_chance > 1000 then - minetest.log("warning", "[tsm_railcorridors] Warning: Wood chances add up to over 100%!") - break - end if rnd <= accumulated_chance then woodtype = w break @@ -800,31 +1020,98 @@ local function place_corridors(main_cave_coords, psra) post = tsm_railcorridors.nodes.corridor_woods[woodtype].post end - start_corridor(main_cave_coords, "x", xs, pr:next(way_min,way_max), psra, wood, post, damage, false) - start_corridor(main_cave_coords, "z", zs, pr:next(way_min,way_max), psra, wood, post, damage, false) - -- Auch mal die andere Richtung? - -- Try the other direction? - if pr:next(0, 100) < 70 then - start_corridor(main_cave_coords, "x", not xs, pr:next(way_min,way_max), psra, wood, post, damage, false) + -- Start 2-4 corridors in each direction + local dirs = { + {axis="x", axis2="z", sign=false}, + {axis="x", axis2="z", sign=true}, + {axis="z", axis2="x", sign=false}, + {axis="z", axis2="x", sign=true}, + } + local first_corridor + local corridors = 2 + for _=1, 2 do + if pr:next(0,100) < 70 then + corridors = corridors + 1 + end end - if pr:next(0, 100) < 70 then - start_corridor(main_cave_coords, "z", not zs, pr:next(way_min,way_max), psra, wood, post, damage, false) + -- Chance for 5th corridor in Chaos Mode + if chaos_mode and size > 4 then + if pr:next(0,100) < 50 then + corridors = corridors + 1 + end end + local centered_crossing = false + if corridors <= 4 and pr:next(1, 20) >= 11 then + centered_crossing = true + end + -- This moves the start of the corridors in the dirt room back and forth + local d_max = 3 + if floor_diff == 1 and height <= 4 then + d_max = d_max + 1 + end + local from_center_base = size - pr:next(1,d_max) + for i=1, math.min(4, corridors) do + local d = pr:next(1, #dirs) + local dir = dirs[d] + local side_offset = 0 + if not centered_crossing and size > 3 then + if i==1 and corridors == 5 then + side_offset = pr:next(2, size-2) + if pr:next(1,2) == 1 then + side_offset = -side_offset + end + else + side_offset = pr:next(-size+2, size-2) + end + end + local from_center = from_center_base + if dir.sign then + from_center = -from_center + end + if i == 1 then + first_corridor = {sign=dir.sign, axis=dir.axis, axis2=dir.axis2, side_offset=side_offset, from_center=from_center} + end + local coords = vector.add(main_cave_coords, {[dir.axis] = from_center, y=0, [dir.axis2] = side_offset}) + create_corridor_line(coords, dir.axis, dir.sign, pr:next(way_min,way_max), wood, post, damage, false) + table.remove(dirs, d) + end + if corridors == 5 then + local special_coords = vector.add(main_cave_coords, {[first_corridor.axis2] = -first_corridor.side_offset, y=0, [first_corridor.axis] = first_corridor.from_center}) + create_corridor_line(special_coords, first_corridor.axis, first_corridor.sign, pr:next(way_min,way_max), wood, post, damage, false) + end + + -- At this point, all corridors were generated and all nodes were set. + -- We spawn the carts now + spawn_carts() + + return true end +-- The rail corridor algorithm starts here minetest.register_on_generated(function(minp, maxp, blockseed) + -- We re-init the randomizer for every mapchunk as we start generating in the middle of each mapchunk. + -- We can't use the mapgen seed as this would make the algorithm depending on the order the mapchunk generate. InitRandomizer(blockseed) - if minp.y < height_max and maxp.y > height_min and pr:next() < probability_railcaves_in_chunk then - -- Get semi-random height in chunk - + if minp.y < height_max and maxp.y > height_min and pr:next() < probability_railcaves_in_mapchunk then + -- Keep some distance from the upper/lower mapchunk limits local buffer = 5 - local y = pr:next(minp.y + buffer, maxp.y - buffer) - y = math.floor(math.max(height_min + buffer, math.min(height_max - buffer, y))) - -- Mid point of the chunk - local p = {x=minp.x+math.floor((maxp.x-minp.x)/2), y=y, z=minp.z+math.floor((maxp.z-minp.z)/2)} - -- Haupthöhle und alle weiteren - -- Corridors; starting with main cave out of dirt - place_corridors(p, pr) + -- Do up to 10 tries to start a corridor system + for t=1,10 do + -- Get semi-random height in mapchunk + local y = pr:next(minp.y + buffer, maxp.y - buffer) + y = math.floor(math.max(height_min + buffer, math.min(height_max - buffer, y))) + + -- Mid point of the mapchunk + local p = {x=minp.x+math.floor((maxp.x-minp.x)/2), y=y, z=minp.z+math.floor((maxp.z-minp.z)/2)} + -- Start corridor system at p. Might fail if p is in open air + minetest.log("verbose", "[tsm_railcorridors] Attempting to start rail corridor system at "..minetest.pos_to_string(p)) + if create_corridor_system(p, pr) then + minetest.log("info", "[tsm_railcorridors] Generated rail corridor system at "..minetest.pos_to_string(p)) + break + else + minetest.log("info", "[tsm_railcorridors] Rail corridor system generation attempt failed at "..minetest.pos_to_string(p).. " (try "..t..")") + end + end end end) diff --git a/mods/MAPGEN/tsm_railcorridors/settingtypes.txt b/mods/MAPGEN/tsm_railcorridors/settingtypes.txt index b21662c62..a28962907 100644 --- a/mods/MAPGEN/tsm_railcorridors/settingtypes.txt +++ b/mods/MAPGEN/tsm_railcorridors/settingtypes.txt @@ -1,5 +1,5 @@ -#Probability (0.0 to 1.0) for every newly generated chunk to get rail corridors. -tsm_railcorridors_probability_railcaves_in_chunk (Rail corridor probability) float 0.3 0.0 1.0 +#Probability (0.0 to 1.0) for every newly generated mapchunk to get rail corridors. +tsm_railcorridors_probability_railcaves_in_mapchunk (Rail corridor probability) float 0.33333 0.0 1.0 #Minimum rail corridor path length (excludes forks). tsm_railcorridors_way_min (Minimum rail corridor length) int 4 1 @@ -20,6 +20,17 @@ tsm_railcorridors_probability_fork (Fork probability) float 0.04 0.0 1.0 #Probability (0.0 to 1.0) for every part of a rail corridor to contain a treasure chest. tsm_railcorridors_probability_chest (Chest probability) float 0.05 0.0 1.0 +#Probability (0.0 to 1.0) for every part of a rail corridor to include a cart. +#Note: The rail may still be subject to rail damage, so the probability +#of finding a cart in rail corridors with high rail damage will be lower. +#NOTE: Due to a bug in Minetest +#carts often fail to spawn even if they should. +tsm_railcorridors_probability_cart (Cart probability) float 0.0 0.0 1.0 + +#If enabled, cobwebs may be placed in some corridors. +#Currently, cobwebs are only supported with the Mobs Redo mod. +tsm_railcorridors_place_cobwebs (Cobwebs) bool true + #Probability (0.0 to 1.0) for a rail corridor system to have damaged/incomplete railways tsm_railcorridors_probability_damage (Damaged railway probability) float 1.0 0.0 1.0 @@ -28,7 +39,3 @@ tsm_railcorridors_probability_damage (Damaged railway probability) float 1.0 0.0 #to pretty chaotic rail corridors, but they are also more free to spread. #If disabled, rail corridors spread in a orderly fashion. tsm_railcorridors_chaos (Chaos Mode) bool false - -#If enabled, cobwebs may be placed in some corridors. -#Currently, cobwebs are only supported with the Mobs Redo mod. -tsm_railcorridors_place_cobwebs (Cobwebs) bool true