mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-10 10:12:45 +00:00
5bb06b184c
- Added a verb that breaks all airgroups into individually processing tiles and a verb that forces a group-rejoin attempt on all airgroups. Once the verb to break all air groups is used, they will not attempt to recreate until the recreate verb is used. In other words, this is for debugging, not goofing around. Verbs available in debug verbs. - Some atmos code standardization - Decreased the pressure resistance of most items by a factor of 10, meaning pressure will finally actually move items around! I also attempted to speed up air movement, but it caused runtimes and everything moved in checkered patterns and I got scared so I didn't include it in this commit. git-svn-id: http://tgstation13.googlecode.com/svn/trunk@5554 316c924e-a436-60f5-8080-3fe189b3f50e
286 lines
9.2 KiB
Plaintext
286 lines
9.2 KiB
Plaintext
datum/air_group
|
|
var/group_processing = 1 //Processing all tiles as one large tile if 1
|
|
|
|
var/datum/gas_mixture/air = new
|
|
|
|
var/current_cycle = 0 //cycle that oxygen value represents
|
|
var/archived_cycle = 0 //cycle that oxygen_archived value represents
|
|
//The use of archived cycle saves processing power by permitting the archiving step of FET
|
|
// to be rolled into the updating step
|
|
|
|
//optimization vars
|
|
var/next_check = 0 //number of ticks before this group updates
|
|
var/check_delay = 10 //number of ticks between updates, starts fairly high to get boring groups out of the way
|
|
|
|
proc/members()
|
|
//Returns the members of the group
|
|
proc/process_group()
|
|
|
|
|
|
var/list/borders //Tiles that connect this group to other groups/individual tiles
|
|
var/list/members //All tiles in this group
|
|
|
|
var/list/space_borders
|
|
var/length_space_border = 0
|
|
|
|
|
|
proc/suspend_group_processing()
|
|
group_processing = 0
|
|
update_tiles_from_group()
|
|
check_delay=0
|
|
next_check=0
|
|
|
|
|
|
//Copy group air information to individual tile air
|
|
//Used right before turning on group processing
|
|
proc/update_group_from_tiles()
|
|
var/sample_member = pick(members)
|
|
var/datum/gas_mixture/sample_air = sample_member:air
|
|
|
|
air.copy_from(sample_air)
|
|
air.group_multiplier = members.len
|
|
return 1
|
|
|
|
|
|
//Copy group air information to individual tile air
|
|
//Used right before turning off group processing
|
|
proc/update_tiles_from_group()
|
|
for(var/member in members)
|
|
member:air.copy_from(air)
|
|
if (istype(member,/turf/simulated))
|
|
var/turf/simulated/turfmem=member
|
|
turfmem.reset_delay()
|
|
|
|
|
|
proc/archive()
|
|
air.archive()
|
|
archived_cycle = air_master.current_cycle
|
|
|
|
|
|
//If individually processing tiles, checks all member tiles to see if they are close enough that the group may resume group processing
|
|
//Warning: Do not call, called by air_master.process()
|
|
proc/check_regroup()
|
|
//Purpose: Checks to see if group processing should be turned back on
|
|
//Returns: group_processing
|
|
if(prevent_airgroup_regroup)
|
|
return 0
|
|
|
|
if(group_processing) return 1
|
|
|
|
var/turf/simulated/sample = pick(members)
|
|
for(var/member in members)
|
|
if(member:active_hotspot)
|
|
return 0
|
|
if(member:air.compare(sample.air)) continue
|
|
else
|
|
return 0
|
|
|
|
update_group_from_tiles()
|
|
group_processing = 1
|
|
return 1
|
|
|
|
|
|
//Look into this
|
|
turf/process_group()
|
|
current_cycle = air_master.current_cycle
|
|
if(!group_processing) //Revert to individual processing then end
|
|
for(var/T in members)
|
|
var/turf/simulated/member = T
|
|
member.process_cell()
|
|
return
|
|
|
|
//check if we're skipping this tick
|
|
if (next_check > 0)
|
|
next_check--
|
|
return 1
|
|
var/player_count = max(player_list.len, 3) / 3
|
|
next_check += check_delay + rand(player_count, player_count * 1.5)
|
|
check_delay++
|
|
|
|
var/turf/simulated/list/border_individual = list()
|
|
var/datum/air_group/list/border_group = list()
|
|
|
|
var/turf/simulated/list/enemies = list() //used to send the appropriate border tile of a group to the group proc
|
|
var/turf/simulated/list/self_group_borders = list()
|
|
var/turf/simulated/list/self_tile_borders = list()
|
|
|
|
if(archived_cycle < air_master.current_cycle)
|
|
archive()
|
|
//Archive air data for use in calculations
|
|
//But only if another group didn't store it for us
|
|
|
|
for(var/turf/simulated/border_tile in src.borders)
|
|
for(var/direction in cardinal) //Go through all border tiles and get bordering groups and individuals
|
|
if(border_tile.group_border&direction)
|
|
var/turf/simulated/enemy_tile = get_step(border_tile, direction) //Add found tile to appropriate category
|
|
if(istype(enemy_tile) && enemy_tile.parent && enemy_tile.parent.group_processing)
|
|
border_group += enemy_tile.parent
|
|
enemies += enemy_tile
|
|
self_group_borders += border_tile
|
|
else
|
|
border_individual += enemy_tile
|
|
self_tile_borders += border_tile
|
|
|
|
var/abort_group = 0
|
|
|
|
// Process connections to adjacent groups
|
|
var/border_index = 1
|
|
for(var/datum/air_group/AG in border_group)
|
|
if(AG.archived_cycle < archived_cycle) //archive other groups information if it has not been archived yet this cycle
|
|
AG.archive()
|
|
if(AG.current_cycle < current_cycle)
|
|
//This if statement makes sure two groups only process their individual connections once!
|
|
//Without it, each connection would be processed a second time as the second group is evaluated
|
|
|
|
var/connection_difference = 0
|
|
var/turf/simulated/floor/self_border = self_group_borders[border_index]
|
|
var/turf/simulated/floor/enemy_border = enemies[border_index]
|
|
|
|
var/result = air.check_gas_mixture(AG.air)
|
|
if(result == 1)
|
|
connection_difference = air.share(AG.air)
|
|
else if(result == -1)
|
|
AG.suspend_group_processing()
|
|
connection_difference = air.share(enemy_border.air)
|
|
else
|
|
abort_group = 1
|
|
break
|
|
|
|
if(connection_difference)
|
|
if(connection_difference > 0)
|
|
self_border.consider_pressure_difference(connection_difference, get_dir(self_border,enemy_border))
|
|
else
|
|
var/turf/enemy_turf = enemy_border
|
|
if(!isturf(enemy_turf))
|
|
enemy_turf = enemy_border.loc
|
|
enemy_turf.consider_pressure_difference(-connection_difference, get_dir(enemy_turf,self_border))
|
|
|
|
border_index++
|
|
|
|
// Process connections to adjacent tiles
|
|
border_index = 1
|
|
if(!abort_group)
|
|
for(var/atom/enemy_tile in border_individual)
|
|
var/connection_difference = 0
|
|
var/turf/simulated/floor/self_border = self_tile_borders[border_index]
|
|
|
|
if(istype(enemy_tile, /turf/simulated))
|
|
if(enemy_tile:archived_cycle < archived_cycle) //archive tile information if not already done
|
|
enemy_tile:archive()
|
|
if(enemy_tile:current_cycle < current_cycle)
|
|
if(air.check_gas_mixture(enemy_tile:air))
|
|
connection_difference = air.share(enemy_tile:air)
|
|
else
|
|
abort_group = 1
|
|
break
|
|
else if(isturf(enemy_tile))
|
|
if(air.check_turf(enemy_tile))
|
|
connection_difference = air.mimic(enemy_tile)
|
|
else
|
|
abort_group = 1
|
|
break
|
|
|
|
if(connection_difference)
|
|
if(connection_difference > 0)
|
|
self_border.consider_pressure_difference(connection_difference, get_dir(self_border,enemy_tile))
|
|
else
|
|
var/turf/enemy_turf = enemy_tile
|
|
if(!isturf(enemy_turf))
|
|
enemy_turf = enemy_tile.loc
|
|
enemy_turf.consider_pressure_difference(-connection_difference, get_dir(enemy_tile,enemy_turf))
|
|
|
|
// Process connections to space
|
|
border_index = 1
|
|
if(!abort_group)
|
|
if(length_space_border > 0)
|
|
var/turf/space/sample = locate()
|
|
var/connection_difference = 0
|
|
|
|
if(air.check_turf(sample))
|
|
connection_difference = air.mimic(sample, length_space_border)
|
|
else
|
|
abort_group = 1
|
|
|
|
if(connection_difference)
|
|
for(var/turf/simulated/self_border in space_borders)
|
|
self_border.consider_pressure_difference_space(connection_difference)
|
|
|
|
if(abort_group)
|
|
suspend_group_processing()
|
|
else
|
|
if(air.check_tile_graphic())
|
|
for(var/T in members)
|
|
var/turf/simulated/member = T
|
|
member.update_visuals(air)
|
|
|
|
|
|
if(air.temperature > FIRE_MINIMUM_TEMPERATURE_TO_EXIST)
|
|
for(var/T in members)
|
|
var/turf/simulated/member = T
|
|
member.hotspot_expose(air.temperature, CELL_VOLUME)
|
|
member.consider_superconductivity(starting=1)
|
|
|
|
air.react()
|
|
return
|
|
|
|
|
|
|
|
object/process_group()
|
|
current_cycle = air_master.current_cycle
|
|
|
|
if(!group_processing) return //See if processing this group as a group
|
|
|
|
var/turf/simulated/list/border_individual = list()
|
|
var/datum/air_group/list/border_group = list()
|
|
|
|
var/turf/simulated/list/enemies = list() //used to send the appropriate border tile of a group to the group proc
|
|
var/enemy_index = 1
|
|
|
|
if(archived_cycle < air_master.current_cycle)
|
|
archive()
|
|
//Archive air data for use in calculations
|
|
//But only if another group didn't store it for us
|
|
|
|
enemy_index = 1
|
|
var/abort_group = 0
|
|
for(var/datum/air_group/AG in border_group)
|
|
if(AG.archived_cycle < archived_cycle) //archive other groups information if it has not been archived yet this cycle
|
|
AG.archive()
|
|
if(AG.current_cycle < current_cycle)
|
|
//This if statement makes sure two groups only process their individual connections once!
|
|
//Without it, each connection would be processed a second time as the second group is evaluated
|
|
|
|
var/result = air.check_gas_mixture(AG.air)
|
|
if(result == 1)
|
|
air.share(AG.air)
|
|
else if(result == -1)
|
|
AG.suspend_group_processing()
|
|
var/turf/simulated/floor/enemy_border = enemies[enemy_index]
|
|
air.share(enemy_border.air)
|
|
else
|
|
abort_group = 0
|
|
break
|
|
enemy_index++
|
|
|
|
if(!abort_group)
|
|
for(var/enemy_tile in border_individual)
|
|
if(istype(enemy_tile, /turf/simulated))
|
|
if(enemy_tile:archived_cycle < archived_cycle) //archive tile information if not already done
|
|
enemy_tile:archive()
|
|
if(enemy_tile:current_cycle < current_cycle)
|
|
if(air.check_gas_mixture(enemy_tile:air))
|
|
air.share(enemy_tile:air)
|
|
else
|
|
abort_group = 1
|
|
break
|
|
else
|
|
if(air.check_turf(enemy_tile))
|
|
air.mimic(enemy_tile)
|
|
else
|
|
abort_group = 1
|
|
break
|
|
|
|
if(abort_group)
|
|
suspend_group_processing()
|
|
|
|
return |