mirror of
https://github.com/Bubberstation/Bubberstation.git
synced 2026-01-29 02:21:44 +00:00
6d1cb94ffb
Speeds up gas movement significantly Documents the intent and finer details of the atmos system (Thanks dunc) Fixes excited groups constantly rebuilding, this broke 4 years ago Fixes superconductors just straight up not working Allows turfs to sleep while inside an excited group Adds a new subprocess to SSAir to support rebuilding in this state Most heat based behavior no longer relies on being inside a fire Adds a new element to support doing this cleanly Adds a new subprocess to SSAir to support doing this while a turf is asleep Refactors air_update_turf to allow for finer control Makes apcs take damage in heat to prevent infinite plasma fire diffs Cleans up immutable gas mixtures to make them work properly when the mix has gas in it Planetary turfs no longer create a new copy of themselves each time they process. We instead use a global immutable mix Cleans up a typed for loop in reactions Canisters will take damage from outside heat now Speeds up excited group dismantle Increases the superconductor threshold by 200k Cleans up some roundstart ATs on some ruins Uses /turf/open/var/excited to track if a turf is actively processing, preventing a |= Prevents openspace from trying to melt Tweaks a canister examine line Makes planetary turfs reset to base when broken down as part of an excited group Makes it impossible for planetary turfs to rebuild, just like space tiles Fixes closed turfs not activating their replacement when destroyed by moving closed -> open turf activation to the adjacent air subsystem. They were activating and then going back to sleep before adjacent air got a chance to tick. Fire alarms will trigger when the area gets too cold for humans
145 lines
4.5 KiB
Plaintext
145 lines
4.5 KiB
Plaintext
/atom/var/CanAtmosPass = ATMOS_PASS_YES
|
|
/atom/var/CanAtmosPassVertical = ATMOS_PASS_YES
|
|
|
|
/atom/proc/CanAtmosPass(turf/T)
|
|
switch (CanAtmosPass)
|
|
if (ATMOS_PASS_PROC)
|
|
return ATMOS_PASS_YES
|
|
if (ATMOS_PASS_DENSITY)
|
|
return !density
|
|
else
|
|
return CanAtmosPass
|
|
|
|
/turf/CanAtmosPass = ATMOS_PASS_NO
|
|
/turf/CanAtmosPassVertical = ATMOS_PASS_NO
|
|
|
|
/turf/open/CanAtmosPass = ATMOS_PASS_PROC
|
|
/turf/open/CanAtmosPassVertical = ATMOS_PASS_PROC
|
|
|
|
//Do NOT use this to see if 2 turfs are connected, it mutates state, and we cache that info anyhow. Use TURFS_CAN_SHARE or TURF_SHARES depending on your usecase
|
|
/turf/open/CanAtmosPass(turf/T, vertical = FALSE)
|
|
var/dir = vertical? get_dir_multiz(src, T) : get_dir(src, T)
|
|
var/opp = REVERSE_DIR(dir)
|
|
var/R = FALSE
|
|
if(vertical && !(zAirOut(dir, T) && T.zAirIn(dir, src)))
|
|
R = TRUE
|
|
if(blocks_air || T.blocks_air)
|
|
R = TRUE
|
|
if (T == src)
|
|
return !R
|
|
for(var/obj/O in contents+T.contents)
|
|
var/turf/other = (O.loc == src ? T : src)
|
|
if(!(vertical? (CANVERTICALATMOSPASS(O, other)) : (CANATMOSPASS(O, other))))
|
|
R = TRUE
|
|
if(O.BlockSuperconductivity()) //the direction and open/closed are already checked on CanAtmosPass() so there are no arguments
|
|
atmos_supeconductivity |= dir
|
|
T.atmos_supeconductivity |= opp
|
|
return FALSE //no need to keep going, we got all we asked
|
|
|
|
atmos_supeconductivity &= ~dir
|
|
T.atmos_supeconductivity &= ~opp
|
|
|
|
return !R
|
|
|
|
/atom/movable/proc/BlockSuperconductivity() // objects that block air and don't let superconductivity act. Only firelocks atm.
|
|
return FALSE
|
|
|
|
/turf/proc/ImmediateCalculateAdjacentTurfs()
|
|
var/canpass = CANATMOSPASS(src, src)
|
|
var/canvpass = CANVERTICALATMOSPASS(src, src)
|
|
for(var/direction in GLOB.cardinals_multiz)
|
|
var/turf/T = get_step_multiz(src, direction)
|
|
if(!isopenturf(T))
|
|
continue
|
|
if(!(blocks_air || T.blocks_air) && ((direction & (UP|DOWN))? (canvpass && CANVERTICALATMOSPASS(T, src)) : (canpass && CANATMOSPASS(T, src))) )
|
|
LAZYINITLIST(atmos_adjacent_turfs)
|
|
LAZYINITLIST(T.atmos_adjacent_turfs)
|
|
atmos_adjacent_turfs[T] = TRUE
|
|
T.atmos_adjacent_turfs[src] = TRUE
|
|
else
|
|
if (atmos_adjacent_turfs)
|
|
atmos_adjacent_turfs -= T
|
|
if (T.atmos_adjacent_turfs)
|
|
T.atmos_adjacent_turfs -= src
|
|
UNSETEMPTY(T.atmos_adjacent_turfs)
|
|
UNSETEMPTY(atmos_adjacent_turfs)
|
|
src.atmos_adjacent_turfs = atmos_adjacent_turfs
|
|
|
|
//returns a list of adjacent turfs that can share air with this one.
|
|
//alldir includes adjacent diagonal tiles that can share
|
|
// air with both of the related adjacent cardinal tiles
|
|
/turf/proc/GetAtmosAdjacentTurfs(alldir = 0)
|
|
var/adjacent_turfs
|
|
if (atmos_adjacent_turfs)
|
|
adjacent_turfs = atmos_adjacent_turfs.Copy()
|
|
else
|
|
adjacent_turfs = list()
|
|
|
|
if (!alldir)
|
|
return adjacent_turfs
|
|
|
|
var/turf/curloc = src
|
|
|
|
for (var/direction in GLOB.diagonals_multiz)
|
|
var/matchingDirections = 0
|
|
var/turf/S = get_step_multiz(curloc, direction)
|
|
if(!S)
|
|
continue
|
|
|
|
for (var/checkDirection in GLOB.cardinals_multiz)
|
|
var/turf/checkTurf = get_step(S, checkDirection)
|
|
if(!S.atmos_adjacent_turfs || !S.atmos_adjacent_turfs[checkTurf])
|
|
continue
|
|
|
|
if (adjacent_turfs[checkTurf])
|
|
matchingDirections++
|
|
|
|
if (matchingDirections >= 2)
|
|
adjacent_turfs += S
|
|
break
|
|
|
|
return adjacent_turfs
|
|
|
|
/atom/proc/air_update_turf(update = FALSE, remove = FALSE)
|
|
var/turf/T = get_turf(loc)
|
|
T.air_update_turf(update, remove)
|
|
|
|
/**
|
|
* A helper proc for dealing with atmos changes
|
|
*
|
|
* Ok so this thing is pretty much used as a catch all for all the situations someone might wanna change something
|
|
* About a turfs atmos. It's real clunky, and someone needs to clean it up, but not today.
|
|
* Arguments:
|
|
* * update - Has the state of the structures in the world changed? If so, update our adjacent atmos turf list, if not, don't.
|
|
* * remove - Are you removing an active turf (Read wall), or adding one
|
|
*/
|
|
/turf/air_update_turf(update = FALSE, remove = FALSE)
|
|
if(update)
|
|
ImmediateCalculateAdjacentTurfs()
|
|
if(remove)
|
|
SSair.remove_from_active(src)
|
|
else
|
|
SSair.add_to_active(src)
|
|
|
|
/atom/movable/proc/move_update_air(turf/T)
|
|
if(isturf(T))
|
|
T.air_update_turf(TRUE, FALSE) //You're empty now
|
|
air_update_turf(TRUE, TRUE) //You aren't
|
|
|
|
/atom/proc/atmos_spawn_air(text) //because a lot of people loves to copy paste awful code lets just make an easy proc to spawn your plasma fires
|
|
var/turf/open/T = get_turf(src)
|
|
if(!istype(T))
|
|
return
|
|
T.atmos_spawn_air(text)
|
|
|
|
/turf/open/atmos_spawn_air(text)
|
|
if(!text || !air)
|
|
return
|
|
|
|
var/datum/gas_mixture/G = new
|
|
G.parse_gas_string(text)
|
|
|
|
air.merge(G)
|
|
archive()
|
|
SSair.add_to_active(src)
|