From bec3e608806ed5f27ffc949b704b22a3104dc379 Mon Sep 17 00:00:00 2001 From: AnturK Date: Sat, 26 Oct 2019 10:06:05 +0200 Subject: [PATCH] Multiz and isolated ruins support. (#47336) Two new always_load_with options for ruins. Use PLACE_ISOLATED to load the secondary ruin part in separate z level. Use PLACE_BELOW to load it on the z level below. --- code/__DEFINES/maps.dm | 9 ++- code/controllers/subsystem/mapping.dm | 42 +++++++++----- code/modules/mapping/ruins.dm | 82 +++++++++++++++++++-------- 3 files changed, 92 insertions(+), 41 deletions(-) diff --git a/code/__DEFINES/maps.dm b/code/__DEFINES/maps.dm index 300a9b1a376..9e446fbd48a 100644 --- a/code/__DEFINES/maps.dm +++ b/code/__DEFINES/maps.dm @@ -36,6 +36,7 @@ require only minor tweaks. #define ZTRAIT_AWAY "Away Mission" #define ZTRAIT_SPACE_RUINS "Space Ruins" #define ZTRAIT_LAVA_RUINS "Lava Ruins" +#define ZTRAIT_ISOLATED_RUINS "Isolated Ruins" //Placing ruins on z levels with this trait will use turf reservation instead of usual placement. // number - bombcap is multiplied by this before being applied to bombs #define ZTRAIT_BOMBCAP_MULTIPLIER "Bombcap Multiplier" @@ -91,6 +92,8 @@ require only minor tweaks. #define PLACEMENT_TRIES 100 //How many times we try to fit the ruin somewhere until giving up (really should just swap to some packing algo) #define PLACE_DEFAULT "random" -#define PLACE_SAME_Z "same" -#define PLACE_SPACE_RUIN "space" -#define PLACE_LAVA_RUIN "lavaland" +#define PLACE_SAME_Z "same" //On same z level as original ruin +#define PLACE_SPACE_RUIN "space" //On space ruin z level(s) +#define PLACE_LAVA_RUIN "lavaland" //On lavaland ruin z levels(s) +#define PLACE_BELOW "below" //On z levl below - centered on same tile +#define PLACE_ISOLATED "isolated" //On isolated ruin z level diff --git a/code/controllers/subsystem/mapping.dm b/code/controllers/subsystem/mapping.dm index 41004cc1654..997a38e4ce2 100644 --- a/code/controllers/subsystem/mapping.dm +++ b/code/controllers/subsystem/mapping.dm @@ -16,6 +16,7 @@ SUBSYSTEM_DEF(mapping) var/list/ruins_templates = list() var/list/space_ruins_templates = list() var/list/lava_ruins_templates = list() + var/datum/space_level/isolated_ruins_z //Created on demand during ruin loading. var/list/shuttle_templates = list() var/list/shelter_templates = list() @@ -27,6 +28,7 @@ SUBSYSTEM_DEF(mapping) var/list/datum/turf_reservations //list of turf reservations var/list/used_turfs = list() //list of turf = datum/turf_reservation + var/list/reservation_ready = list() var/clearing_reserved_turfs = FALSE // Z-manager stuff @@ -100,7 +102,7 @@ SUBSYSTEM_DEF(mapping) // Set up Z-level transitions. setup_map_transitions() generate_station_area_list() - initialize_reserved_level() + initialize_reserved_level(transit.z_value) return ..() /datum/controller/subsystem/mapping/proc/wipe_reservations(wipe_safety_delay = 100) @@ -451,7 +453,7 @@ GLOBAL_LIST_EMPTY(the_station_areas) GLOB.the_gateway.wait = world.time /datum/controller/subsystem/mapping/proc/RequestBlockReservation(width, height, z, type = /datum/turf_reservation, turf_type_override) - UNTIL(initialized && !clearing_reserved_turfs) + UNTIL(reservation_ready["[z]"] && !clearing_reserved_turfs) var/datum/turf_reservation/reserve = new type if(turf_type_override) reserve.turf_type = turf_type_override @@ -461,8 +463,9 @@ GLOBAL_LIST_EMPTY(the_station_areas) return reserve //If we didn't return at this point, theres a good chance we ran out of room on the exisiting reserved z levels, so lets try a new one num_of_res_levels += 1 - var/newReserved = add_new_zlevel("Transit/Reserved [num_of_res_levels]", list(ZTRAIT_RESERVED = TRUE)) - if(reserve.Reserve(width, height, newReserved)) + var/datum/space_level/newReserved = add_new_zlevel("Transit/Reserved [num_of_res_levels]", list(ZTRAIT_RESERVED = TRUE)) + initialize_reserved_level(newReserved.z_value) + if(reserve.Reserve(width, height, newReserved.z_value)) return reserve else if(!level_trait(z, ZTRAIT_RESERVED)) @@ -474,19 +477,22 @@ GLOBAL_LIST_EMPTY(the_station_areas) QDEL_NULL(reserve) //This is not for wiping reserved levels, use wipe_reservations() for that. -/datum/controller/subsystem/mapping/proc/initialize_reserved_level() +/datum/controller/subsystem/mapping/proc/initialize_reserved_level(z) UNTIL(!clearing_reserved_turfs) //regardless, lets add a check just in case. clearing_reserved_turfs = TRUE //This operation will likely clear any existing reservations, so lets make sure nothing tries to make one while we're doing it. - for(var/i in levels_by_trait(ZTRAIT_RESERVED)) - var/turf/A = get_turf(locate(SHUTTLE_TRANSIT_BORDER,SHUTTLE_TRANSIT_BORDER,i)) - var/turf/B = get_turf(locate(world.maxx - SHUTTLE_TRANSIT_BORDER,world.maxy - SHUTTLE_TRANSIT_BORDER,i)) - var/block = block(A, B) - for(var/t in block) - // No need to empty() these, because it's world init and they're - // already /turf/open/space/basic. - var/turf/T = t - T.flags_1 |= UNUSED_RESERVATION_TURF_1 - unused_turfs["[i]"] = block + if(!level_trait(z,ZTRAIT_RESERVED)) + clearing_reserved_turfs = FALSE + CRASH("Invalid z level prepared for reservations.") + var/turf/A = get_turf(locate(SHUTTLE_TRANSIT_BORDER,SHUTTLE_TRANSIT_BORDER,z)) + var/turf/B = get_turf(locate(world.maxx - SHUTTLE_TRANSIT_BORDER,world.maxy - SHUTTLE_TRANSIT_BORDER,z)) + var/block = block(A, B) + for(var/t in block) + // No need to empty() these, because it's world init and they're + // already /turf/open/space/basic. + var/turf/T = t + T.flags_1 |= UNUSED_RESERVATION_TURF_1 + unused_turfs["[z]"] = block + reservation_ready["[z]"] = TRUE clearing_reserved_turfs = FALSE /datum/controller/subsystem/mapping/proc/reserve_turfs(list/turfs) @@ -522,3 +528,9 @@ GLOBAL_LIST_EMPTY(the_station_areas) for(var/B in areas) var/area/A = B A.reg_in_areas_in_z() + +/datum/controller/subsystem/mapping/proc/get_isolated_ruin_z() + if(!isolated_ruins_z) + isolated_ruins_z = add_new_zlevel("Isolated Ruins/Reserved", list(ZTRAIT_RESERVED = TRUE, ZTRAIT_ISOLATED_RUINS = TRUE)) + initialize_reserved_level(isolated_ruins_z.z_value) + return isolated_ruins_z.z_value diff --git a/code/modules/mapping/ruins.dm b/code/modules/mapping/ruins.dm index 99e4e15d453..f8302c7c5eb 100644 --- a/code/modules/mapping/ruins.dm +++ b/code/modules/mapping/ruins.dm @@ -1,10 +1,12 @@ -/datum/map_template/ruin/proc/try_to_place(z,allowed_areas) - var/sanity = PLACEMENT_TRIES +/datum/map_template/ruin/proc/try_to_place(z,allowed_areas,turf/forced_turf) + var/sanity = forced_turf ? 1 : PLACEMENT_TRIES + if(SSmapping.level_trait(z,ZTRAIT_ISOLATED_RUINS)) + return place_on_isolated_level(z) while(sanity > 0) sanity-- var/width_border = TRANSITIONEDGE + SPACERUIN_MAP_EDGE_PAD + round(width / 2) var/height_border = TRANSITIONEDGE + SPACERUIN_MAP_EDGE_PAD + round(height / 2) - var/turf/central_turf = locate(rand(width_border, world.maxx - width_border), rand(height_border, world.maxy - height_border), z) + var/turf/central_turf = forced_turf ? forced_turf : locate(rand(width_border, world.maxx - width_border), rand(height_border, world.maxy - height_border), z) var/valid = TRUE for(var/turf/check in get_affected_turfs(central_turf,1)) @@ -34,8 +36,20 @@ T.flags_1 |= NO_RUINS_1 new /obj/effect/landmark/ruin(central_turf, src) - return TRUE - return FALSE + return central_turf + +/datum/map_template/ruin/proc/place_on_isolated_level(z) + var/datum/turf_reservation/reservation = SSmapping.RequestBlockReservation(width, height, z) //Make the new level creation work with different traits. + if(!reservation) + return + var/turf/placement = locate(reservation.bottom_left_coords[1],reservation.bottom_left_coords[2],reservation.bottom_left_coords[3]) + load(placement) + loaded++ + for(var/turf/T in get_affected_turfs(placement)) + T.flags_1 |= NO_RUINS_1 + var/turf/center = locate(placement.x + round(width/2),placement.y + round(height/2),placement.z) + new /obj/effect/landmark/ruin(center, src) + return center /proc/seedRuins(list/z_levels = null, budget = 0, whitelist = /area/space, list/potentialRuins) @@ -51,9 +65,8 @@ var/list/ruins = potentialRuins.Copy() - var/list/forced_ruins = list() //These go first on the z level associated (same random one by default) + var/list/forced_ruins = list() //These go first on the z level associated (same random one by default) or if the assoc value is a turf to the specified turf. var/list/ruins_availible = list() //we can try these in the current pass - var/forced_z //If set we won't pick z level and use this one instead. //Set up the starting ruin list for(var/key in ruins) @@ -65,31 +78,51 @@ if(R.unpickable) continue ruins_availible[R] = R.placement_weight - while(budget > 0 && (ruins_availible.len || forced_ruins.len)) var/datum/map_template/ruin/current_pick var/forced = FALSE + var/forced_z //If set we won't pick z level and use this one instead. + var/forced_turf //If set we place the ruin centered on the given turf if(forced_ruins.len) //We have something we need to load right now, so just pick it for(var/ruin in forced_ruins) current_pick = ruin - if(forced_ruins[ruin] > 0) //Load into designated z + if(isturf(forced_ruins[ruin])) + var/turf/T = forced_ruins[ruin] + forced_z = T.z //In case of chained ruins + forced_turf = T + else if(forced_ruins[ruin] > 0) //Load into designated z forced_z = forced_ruins[ruin] forced = TRUE break else //Otherwise just pick random one current_pick = pickweight(ruins_availible) - - var/placement_tries = PLACEMENT_TRIES + + var/placement_tries = forced_turf ? 1 : PLACEMENT_TRIES //Only try once if we target specific turf var/failed_to_place = TRUE - var/z_placed = 0 - while(placement_tries > 0) - placement_tries-- - z_placed = pick(z_levels) - if(!current_pick.try_to_place(forced_z ? forced_z : z_placed,whitelist)) - continue - else - failed_to_place = FALSE - break + var/target_z = 0 + var/turf/placed_turf //Where the ruin ended up if we succeeded + outer: + while(placement_tries > 0) + placement_tries-- + target_z = pick(z_levels) + if(forced_z) + target_z = forced_z + if(current_pick.always_spawn_with) //If the ruin has part below, make sure that z exists. + for(var/v in current_pick.always_spawn_with) + if(current_pick.always_spawn_with[v] == PLACE_BELOW) + var/turf/T = locate(1,1,target_z) + if(!SSmapping.get_turf_below(T)) + if(forced_z) + continue outer + else + break outer + + placed_turf = current_pick.try_to_place(target_z,whitelist,forced_turf) + if(!placed_turf) + continue + else + failed_to_place = FALSE + break //That's done remove from priority even if it failed if(forced) @@ -120,18 +153,21 @@ if(istype(linked,v)) switch(current_pick.always_spawn_with[v]) if(PLACE_SAME_Z) - forced_ruins[linked] = forced_z ? forced_z : z_placed //I guess you might want a chain somehow + forced_ruins[linked] = target_z //I guess you might want a chain somehow if(PLACE_LAVA_RUIN) forced_ruins[linked] = pick(SSmapping.levels_by_trait(ZTRAIT_LAVA_RUINS)) if(PLACE_SPACE_RUIN) forced_ruins[linked] = pick(SSmapping.levels_by_trait(ZTRAIT_SPACE_RUINS)) if(PLACE_DEFAULT) forced_ruins[linked] = -1 - forced_z = 0 + if(PLACE_BELOW) + forced_ruins[linked] = SSmapping.get_turf_below(placed_turf) + if(PLACE_ISOLATED) + forced_ruins[linked] = SSmapping.get_isolated_ruin_z() //Update the availible list for(var/datum/map_template/ruin/R in ruins_availible) if(R.cost > budget) ruins_availible -= R - + log_world("Ruin loader finished with [budget] left to spend.")