mirror of
https://github.com/ParadiseSS13/Paradise.git
synced 2026-08-21 11:07:12 +01:00
mport2004@gmail.com
b6f8b3fb77
Moved an unchecked file into unused, please put any unchecked files out of WIP or FEA into unused that way if you see an unchecked file you know it should be checked. DM loves to uncheck files when you are messing around with folders in the editor. Moved the old TEG defines into the proper files. Commented out some old nonfunctioning FEA debug code. Removed some commented out codechunks from FEA and attempted to clean up a few of the files a bit. git-svn-id: http://tgstation13.googlecode.com/svn/trunk@3852 316c924e-a436-60f5-8080-3fe189b3f50e
279 lines
9.1 KiB
Plaintext
279 lines
9.1 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(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/turf/simulated/member in members)
|
|
member.process_cell()
|
|
return
|
|
|
|
//check if we're skipping this tick
|
|
if (next_check > 0)
|
|
next_check--
|
|
return 1
|
|
next_check += check_delay + rand(0,check_delay/2)
|
|
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/turf/simulated/member in members)
|
|
member.update_visuals(air)
|
|
|
|
|
|
if(air.temperature > FIRE_MINIMUM_TEMPERATURE_TO_EXIST)
|
|
for(var/turf/simulated/member in members)
|
|
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 |