mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-10 18:22:39 +00:00
1031 lines
39 KiB
Plaintext
1031 lines
39 KiB
Plaintext
/*
|
|
What are the archived variables for?
|
|
Calculations are done using the archived variables with the results merged into the regular variables.
|
|
This prevents race conditions that arise based on the order of tile processing.
|
|
*/
|
|
|
|
#define QUANTIZE(variable) (round(variable,0.0001))
|
|
#define TRANSFER_FRACTION 5 //What fraction (1/#) of the air difference to try and transfer
|
|
|
|
datum
|
|
gas //These are used for the "Trace Gases" stuff, but is buggy.
|
|
sleeping_agent
|
|
specific_heat = 40
|
|
|
|
oxygen_agent_b
|
|
specific_heat = 300
|
|
|
|
volatile_fuel
|
|
specific_heat = 30
|
|
|
|
var
|
|
moles = 0
|
|
specific_heat = 0
|
|
|
|
moles_archived = 0
|
|
|
|
gas_mixture
|
|
var //Holds the "moles" of each of the four gases.
|
|
oxygen = 0
|
|
carbon_dioxide = 0
|
|
nitrogen = 0
|
|
toxins = 0
|
|
total_moles = 0 //Updated when a reaction occurs.
|
|
|
|
volume = CELL_VOLUME
|
|
|
|
temperature = 0 //in Kelvin, use calculate_temperature() to modify
|
|
|
|
group_multiplier = 1
|
|
//Size of the group this gas_mixture is representing.
|
|
//=1 for singletons
|
|
|
|
graphic
|
|
|
|
list/datum/gas/trace_gases = list() //Seemed to be a good idea that was abandoned
|
|
|
|
tmp //These are variables for use with the archived data
|
|
oxygen_archived
|
|
carbon_dioxide_archived
|
|
nitrogen_archived
|
|
toxins_archived
|
|
|
|
temperature_archived
|
|
|
|
graphic_archived = 0
|
|
fuel_burnt = 0
|
|
|
|
//FOR THE LOVE OF GOD PLEASE USE THIS PROC
|
|
//Call it with negative numbers to remove gases.
|
|
|
|
proc/adjust(o2 = 0, co2 = 0, n2 = 0, tx = 0, list/datum/gas/traces = list())
|
|
//Purpose: Adjusting the gases within a airmix
|
|
//Called by: Nothing, yet!
|
|
//Inputs: The values of the gases to adjust
|
|
//Outputs: null
|
|
|
|
oxygen = max(0, oxygen + o2)
|
|
carbon_dioxide = max(0, carbon_dioxide + co2)
|
|
nitrogen = max(0, nitrogen + n2)
|
|
toxins = max(0, toxins + tx)
|
|
|
|
//handle trace gasses
|
|
for(var/datum/gas/G in traces)
|
|
var/datum/gas/T = locate(G.type) in trace_gases
|
|
if(T)
|
|
T.moles = max(G.moles + T.moles, 0)
|
|
else if(G.moles > 0)
|
|
trace_gases |= G
|
|
update_values()
|
|
return
|
|
|
|
//tg seems to like using these a lot
|
|
proc/return_temperature()
|
|
return temperature
|
|
|
|
|
|
proc/return_volume()
|
|
return max(0, volume)
|
|
|
|
|
|
proc/thermal_energy()
|
|
return temperature*heat_capacity()
|
|
|
|
///////////////////////////////
|
|
//PV=nRT - related procedures//
|
|
///////////////////////////////
|
|
|
|
|
|
proc/heat_capacity()
|
|
//Purpose: Returning the heat capacity of the gas mix
|
|
//Called by: UNKNOWN
|
|
//Inputs: None
|
|
//Outputs: Heat capacity
|
|
|
|
var/heat_capacity = HEAT_CAPACITY_CALCULATION(oxygen,carbon_dioxide,nitrogen,toxins)
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
heat_capacity += trace_gas.moles*trace_gas.specific_heat
|
|
|
|
return max(MINIMUM_HEAT_CAPACITY,heat_capacity)
|
|
|
|
proc/heat_capacity_archived()
|
|
//Purpose: Returning the archived heat capacity of the gas mix
|
|
//Called by: UNKNOWN
|
|
//Inputs: None
|
|
//Outputs: Archived heat capacity
|
|
|
|
var/heat_capacity_archived = HEAT_CAPACITY_CALCULATION(oxygen_archived,carbon_dioxide_archived,nitrogen_archived,toxins_archived)
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
heat_capacity_archived += trace_gas.moles_archived*trace_gas.specific_heat
|
|
|
|
return max(MINIMUM_HEAT_CAPACITY,heat_capacity_archived)
|
|
|
|
proc/total_moles()
|
|
return total_moles
|
|
/*var/moles = oxygen + carbon_dioxide + nitrogen + toxins
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
moles += trace_gas.moles
|
|
return moles*/
|
|
|
|
proc/return_pressure()
|
|
//Purpose: Calculating Current Pressure
|
|
//Called by:
|
|
//Inputs: None
|
|
//Outputs: Gas pressure.
|
|
|
|
if(volume>0)
|
|
return total_moles()*R_IDEAL_GAS_EQUATION*temperature/volume
|
|
return 0
|
|
|
|
// proc/return_temperature()
|
|
//Purpose:
|
|
//Inputs:
|
|
//Outputs:
|
|
|
|
// return temperature
|
|
|
|
// proc/return_volume()
|
|
//Purpose:
|
|
//Inputs:
|
|
//Outputs:
|
|
|
|
// return max(0, volume)
|
|
|
|
// proc/thermal_energy()
|
|
//Purpose:
|
|
//Inputs:
|
|
//Outputs:
|
|
|
|
// return temperature*heat_capacity()
|
|
|
|
proc/update_values()
|
|
//Purpose: Calculating and storing values which were normally called CONSTANTLY
|
|
//Called by: Anything that changes values within a gas mix.
|
|
//Inputs: None
|
|
//Outputs: None
|
|
|
|
total_moles = oxygen + carbon_dioxide + nitrogen + toxins
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
total_moles += trace_gas.moles
|
|
|
|
return
|
|
|
|
////////////////////////////////////////////
|
|
//Procedures used for very specific events//
|
|
////////////////////////////////////////////
|
|
|
|
|
|
proc/check_tile_graphic()
|
|
//Purpose: Calculating the graphic for a tile
|
|
//Called by: Turfs updating
|
|
//Inputs: None
|
|
//Outputs: 1 if graphic changed, 0 if unchanged
|
|
|
|
graphic = 0
|
|
if(toxins > MOLES_PLASMA_VISIBLE)
|
|
graphic = 1
|
|
else if(length(trace_gases))
|
|
var/datum/gas/sleeping_agent = locate(/datum/gas/sleeping_agent) in trace_gases
|
|
if(sleeping_agent && (sleeping_agent.moles > 1))
|
|
graphic = 2
|
|
else
|
|
graphic = 0
|
|
|
|
return graphic != graphic_archived
|
|
|
|
proc/react(atom/dump_location)
|
|
//Purpose: Calculating if it is possible for a fire to occur in the airmix
|
|
//Called by: Air mixes updating?
|
|
//Inputs: None
|
|
//Outputs: If a fire occured
|
|
|
|
var/reacting = 0 //set to 1 if a notable reaction occured (used by pipe_network)
|
|
|
|
if(temperature > FIRE_MINIMUM_TEMPERATURE_TO_EXIST)
|
|
if(zburn(null) > 0)
|
|
reacting = 1
|
|
|
|
return reacting
|
|
|
|
proc/fire()
|
|
//Purpose: Calculating any fire reactions.
|
|
//Called by: react() (See above)
|
|
//Inputs: None
|
|
//Outputs: How much fuel burned
|
|
|
|
return zburn(null)
|
|
|
|
/*var/energy_released = 0
|
|
var/old_heat_capacity = heat_capacity()
|
|
|
|
var/datum/gas/volatile_fuel/fuel_store = locate(/datum/gas/volatile_fuel) in trace_gases
|
|
if(fuel_store) //General volatile gas burn
|
|
var/burned_fuel = 0
|
|
|
|
if(oxygen < fuel_store.moles)
|
|
burned_fuel = oxygen
|
|
fuel_store.moles -= burned_fuel
|
|
oxygen = 0
|
|
else
|
|
burned_fuel = fuel_store.moles
|
|
oxygen -= fuel_store.moles
|
|
del(fuel_store)
|
|
|
|
energy_released += FIRE_CARBON_ENERGY_RELEASED * burned_fuel
|
|
carbon_dioxide += burned_fuel
|
|
fuel_burnt += burned_fuel
|
|
|
|
//Handle plasma burning
|
|
if(toxins > MINIMUM_HEAT_CAPACITY)
|
|
var/plasma_burn_rate = 0
|
|
var/oxygen_burn_rate = 0
|
|
//more plasma released at higher temperatures
|
|
var/temperature_scale
|
|
if(temperature > PLASMA_UPPER_TEMPERATURE)
|
|
temperature_scale = 1
|
|
else
|
|
temperature_scale = (temperature-PLASMA_MINIMUM_BURN_TEMPERATURE)/(PLASMA_UPPER_TEMPERATURE-PLASMA_MINIMUM_BURN_TEMPERATURE)
|
|
if(temperature_scale > 0)
|
|
oxygen_burn_rate = 1.4 - temperature_scale
|
|
if(oxygen > toxins*PLASMA_OXYGEN_FULLBURN)
|
|
plasma_burn_rate = (toxins*temperature_scale)/4
|
|
else
|
|
plasma_burn_rate = (temperature_scale*(oxygen/PLASMA_OXYGEN_FULLBURN))/4
|
|
if(plasma_burn_rate > MINIMUM_HEAT_CAPACITY)
|
|
toxins -= plasma_burn_rate
|
|
oxygen -= plasma_burn_rate*oxygen_burn_rate
|
|
carbon_dioxide += plasma_burn_rate
|
|
|
|
energy_released += FIRE_PLASMA_ENERGY_RELEASED * (plasma_burn_rate)
|
|
|
|
fuel_burnt += (plasma_burn_rate)*(1+oxygen_burn_rate)
|
|
|
|
if(energy_released > 0)
|
|
var/new_heat_capacity = heat_capacity()
|
|
if(new_heat_capacity > MINIMUM_HEAT_CAPACITY)
|
|
temperature = (temperature*old_heat_capacity + energy_released)/new_heat_capacity
|
|
update_values()
|
|
|
|
return fuel_burnt*/
|
|
|
|
//////////////////////////////////////////////
|
|
//Procs for general gas spread calculations.//
|
|
//////////////////////////////////////////////
|
|
|
|
|
|
proc/archive()
|
|
//Purpose: Archives the current gas values
|
|
//Called by: UNKNOWN
|
|
//Inputs: None
|
|
//Outputs: 1
|
|
|
|
oxygen_archived = oxygen
|
|
carbon_dioxide_archived = carbon_dioxide
|
|
nitrogen_archived = nitrogen
|
|
toxins_archived = toxins
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
trace_gas.moles_archived = trace_gas.moles
|
|
|
|
temperature_archived = temperature
|
|
|
|
graphic_archived = graphic
|
|
|
|
return 1
|
|
|
|
proc/check_then_merge(datum/gas_mixture/giver)
|
|
//Purpose: Similar to merge(...) but first checks to see if the amount of air assumed is small enough
|
|
// that group processing is still accurate for source (aborts if not)
|
|
//Called by: airgroups/machinery expelling air, ?
|
|
//Inputs: The gas to try and merge
|
|
//Outputs: 1 on successful merge. 0 otherwise.
|
|
|
|
if(!giver)
|
|
return 0
|
|
if(((giver.oxygen > MINIMUM_AIR_TO_SUSPEND) && (giver.oxygen >= oxygen*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((giver.carbon_dioxide > MINIMUM_AIR_TO_SUSPEND) && (giver.carbon_dioxide >= carbon_dioxide*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((giver.nitrogen > MINIMUM_AIR_TO_SUSPEND) && (giver.nitrogen >= nitrogen*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((giver.toxins > MINIMUM_AIR_TO_SUSPEND) && (giver.toxins >= toxins*MINIMUM_AIR_RATIO_TO_SUSPEND)))
|
|
return 0
|
|
if(abs(giver.temperature - temperature) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND)
|
|
return 0
|
|
|
|
if(giver.trace_gases.len)
|
|
for(var/datum/gas/trace_gas in giver.trace_gases)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in trace_gases
|
|
if((trace_gas.moles > MINIMUM_AIR_TO_SUSPEND) && (!corresponding || (trace_gas.moles >= corresponding.moles*MINIMUM_AIR_RATIO_TO_SUSPEND)))
|
|
return 0
|
|
|
|
return merge(giver)
|
|
|
|
proc/merge(datum/gas_mixture/giver)
|
|
//Purpose: Merges all air from giver into self. Deletes giver.
|
|
//Called by: Machinery expelling air, check_then_merge, ?
|
|
//Inputs: The gas to merge.
|
|
//Outputs: 1
|
|
|
|
if(!giver)
|
|
return 0
|
|
|
|
if(abs(temperature-giver.temperature)>MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/self_heat_capacity = heat_capacity()*group_multiplier
|
|
var/giver_heat_capacity = giver.heat_capacity()*giver.group_multiplier
|
|
var/combined_heat_capacity = giver_heat_capacity + self_heat_capacity
|
|
if(combined_heat_capacity != 0)
|
|
temperature = (giver.temperature*giver_heat_capacity + temperature*self_heat_capacity)/combined_heat_capacity
|
|
|
|
if((group_multiplier>1)||(giver.group_multiplier>1))
|
|
oxygen += giver.oxygen*giver.group_multiplier/group_multiplier
|
|
carbon_dioxide += giver.carbon_dioxide*giver.group_multiplier/group_multiplier
|
|
nitrogen += giver.nitrogen*giver.group_multiplier/group_multiplier
|
|
toxins += giver.toxins*giver.group_multiplier/group_multiplier
|
|
else
|
|
oxygen += giver.oxygen
|
|
carbon_dioxide += giver.carbon_dioxide
|
|
nitrogen += giver.nitrogen
|
|
toxins += giver.toxins
|
|
|
|
if(giver.trace_gases.len)
|
|
for(var/datum/gas/trace_gas in giver.trace_gases)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in trace_gases
|
|
if(!corresponding)
|
|
corresponding = new trace_gas.type()
|
|
trace_gases += corresponding
|
|
corresponding.moles += trace_gas.moles*giver.group_multiplier/group_multiplier
|
|
update_values()
|
|
|
|
// Let the garbage collector handle it, faster according to /tg/ testers
|
|
//del(giver)
|
|
return 1
|
|
|
|
proc/remove(amount)
|
|
//Purpose: Removes a certain number of moles from the air.
|
|
//Called by: ?
|
|
//Inputs: How many moles to remove.
|
|
//Outputs: Removed air.
|
|
|
|
var/sum = total_moles()
|
|
amount = min(amount,sum) //Can not take more air than tile has!
|
|
if(amount <= 0)
|
|
return null
|
|
|
|
var/datum/gas_mixture/removed = new
|
|
|
|
|
|
removed.oxygen = QUANTIZE((oxygen/sum)*amount)
|
|
removed.nitrogen = QUANTIZE((nitrogen/sum)*amount)
|
|
removed.carbon_dioxide = QUANTIZE((carbon_dioxide/sum)*amount)
|
|
removed.toxins = QUANTIZE((toxins/sum)*amount)
|
|
|
|
oxygen -= removed.oxygen/group_multiplier
|
|
nitrogen -= removed.nitrogen/group_multiplier
|
|
carbon_dioxide -= removed.carbon_dioxide/group_multiplier
|
|
toxins -= removed.toxins/group_multiplier
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
var/datum/gas/corresponding = new trace_gas.type()
|
|
removed.trace_gases += corresponding
|
|
|
|
corresponding.moles = (trace_gas.moles/sum)*amount
|
|
trace_gas.moles -= corresponding.moles/group_multiplier
|
|
|
|
removed.temperature = temperature
|
|
update_values()
|
|
removed.update_values()
|
|
|
|
return removed
|
|
|
|
proc/remove_ratio(ratio)
|
|
//Purpose: Removes a certain ratio of the air.
|
|
//Called by: ?
|
|
//Inputs: Percentage to remove.
|
|
//Outputs: Removed air.
|
|
|
|
if(ratio <= 0)
|
|
return null
|
|
|
|
ratio = min(ratio, 1)
|
|
|
|
var/datum/gas_mixture/removed = new
|
|
|
|
removed.oxygen = QUANTIZE(oxygen*ratio)
|
|
removed.nitrogen = QUANTIZE(nitrogen*ratio)
|
|
removed.carbon_dioxide = QUANTIZE(carbon_dioxide*ratio)
|
|
removed.toxins = QUANTIZE(toxins*ratio)
|
|
|
|
oxygen -= removed.oxygen/group_multiplier
|
|
nitrogen -= removed.nitrogen/group_multiplier
|
|
carbon_dioxide -= removed.carbon_dioxide/group_multiplier
|
|
toxins -= removed.toxins/group_multiplier
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
var/datum/gas/corresponding = new trace_gas.type()
|
|
removed.trace_gases += corresponding
|
|
|
|
corresponding.moles = trace_gas.moles*ratio
|
|
trace_gas.moles -= corresponding.moles/group_multiplier
|
|
|
|
removed.temperature = temperature
|
|
update_values()
|
|
removed.update_values()
|
|
|
|
return removed
|
|
|
|
proc/check_then_remove(amount)
|
|
//Purpose: Similar to remove(...) but first checks to see if the amount of air removed is small enough
|
|
// that group processing is still accurate for source (aborts if not)
|
|
//Called by: ?
|
|
//Inputs: Number of moles to remove
|
|
//Outputs: Removed air or 0 if it can remove air or not.
|
|
|
|
amount = min(amount,total_moles()) //Can not take more air than tile has!
|
|
|
|
if((amount > MINIMUM_AIR_RATIO_TO_SUSPEND) && (amount > total_moles()*MINIMUM_AIR_RATIO_TO_SUSPEND))
|
|
return 0
|
|
|
|
return remove(amount)
|
|
|
|
proc/copy_from(datum/gas_mixture/sample)
|
|
//Purpose: Duplicates the sample air mixture.
|
|
//Called by: airgroups splitting, ?
|
|
//Inputs: Gas to copy
|
|
//Outputs: 1
|
|
|
|
oxygen = sample.oxygen
|
|
carbon_dioxide = sample.carbon_dioxide
|
|
nitrogen = sample.nitrogen
|
|
toxins = sample.toxins
|
|
total_moles = sample.total_moles()
|
|
|
|
trace_gases.len=null
|
|
if(sample.trace_gases.len > 0)
|
|
for(var/datum/gas/trace_gas in sample.trace_gases)
|
|
var/datum/gas/corresponding = new trace_gas.type()
|
|
trace_gases += corresponding
|
|
|
|
corresponding.moles = trace_gas.moles
|
|
|
|
temperature = sample.temperature
|
|
|
|
return 1
|
|
|
|
proc/check_gas_mixture(datum/gas_mixture/sharer)
|
|
//Purpose: Telling if one or both airgroups needs to disable group processing.
|
|
//Called by: Airgroups sharing air, checking if group processing needs disabled.
|
|
//Inputs: Gas to compare from other airgroup
|
|
//Outputs: 0 if the self-check failed (local airgroup breaks?)
|
|
// then -1 if sharer-check failed (sharing airgroup breaks?)
|
|
// then 1 if both checks pass (share succesful?)
|
|
if(!istype(sharer))
|
|
return
|
|
|
|
var/delta_oxygen = QUANTIZE(oxygen_archived - sharer.oxygen_archived)/TRANSFER_FRACTION
|
|
var/delta_carbon_dioxide = QUANTIZE(carbon_dioxide_archived - sharer.carbon_dioxide_archived)/TRANSFER_FRACTION
|
|
var/delta_nitrogen = QUANTIZE(nitrogen_archived - sharer.nitrogen_archived)/TRANSFER_FRACTION
|
|
var/delta_toxins = QUANTIZE(toxins_archived - sharer.toxins_archived)/TRANSFER_FRACTION
|
|
|
|
var/delta_temperature = (temperature_archived - sharer.temperature_archived)
|
|
|
|
if(((abs(delta_oxygen) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_oxygen) >= oxygen_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_carbon_dioxide) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_carbon_dioxide) >= carbon_dioxide_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_nitrogen) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_nitrogen) >= nitrogen_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_toxins) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_toxins) >= toxins_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)))
|
|
return 0
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND)
|
|
return 0
|
|
|
|
if(sharer.trace_gases.len)
|
|
for(var/datum/gas/trace_gas in sharer.trace_gases)
|
|
if(trace_gas.moles_archived > MINIMUM_AIR_TO_SUSPEND*4)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in trace_gases
|
|
if(corresponding)
|
|
if(trace_gas.moles_archived >= corresponding.moles_archived*MINIMUM_AIR_RATIO_TO_SUSPEND*4)
|
|
return 0
|
|
else
|
|
return 0
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
if(trace_gas.moles_archived > MINIMUM_AIR_TO_SUSPEND*4)
|
|
if(!locate(trace_gas.type) in sharer.trace_gases)
|
|
return 0
|
|
|
|
if(((abs(delta_oxygen) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_oxygen) >= sharer.oxygen_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_carbon_dioxide) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_carbon_dioxide) >= sharer.carbon_dioxide_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_nitrogen) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_nitrogen) >= sharer.nitrogen_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_toxins) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_toxins) >= sharer.toxins_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)))
|
|
return -1
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
if(trace_gas.moles_archived > MINIMUM_AIR_TO_SUSPEND*4)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in sharer.trace_gases
|
|
if(corresponding)
|
|
if(trace_gas.moles_archived >= corresponding.moles_archived*MINIMUM_AIR_RATIO_TO_SUSPEND*4)
|
|
return -1
|
|
else
|
|
return -1
|
|
|
|
return 1
|
|
|
|
proc/check_turf(turf/model)
|
|
//Purpose: Used to compare the gases in an unsimulated turf with the gas in a simulated one.
|
|
//Called by: Sharing air (mimicing) with adjacent unsimulated turfs
|
|
//Inputs: Unsimulated turf
|
|
//Outputs: 1 if safe to mimic, 0 if needs to break airgroup.
|
|
|
|
var/delta_oxygen = (oxygen_archived - model.oxygen)/TRANSFER_FRACTION
|
|
var/delta_carbon_dioxide = (carbon_dioxide_archived - model.carbon_dioxide)/TRANSFER_FRACTION
|
|
var/delta_nitrogen = (nitrogen_archived - model.nitrogen)/TRANSFER_FRACTION
|
|
var/delta_toxins = (toxins_archived - model.toxins)/TRANSFER_FRACTION
|
|
|
|
var/delta_temperature = (temperature_archived - model.temperature)
|
|
|
|
if(((abs(delta_oxygen) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_oxygen) >= oxygen_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_carbon_dioxide) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_carbon_dioxide) >= carbon_dioxide_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_nitrogen) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_nitrogen) >= nitrogen_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)) \
|
|
|| ((abs(delta_toxins) > MINIMUM_AIR_TO_SUSPEND) && (abs(delta_toxins) >= toxins_archived*MINIMUM_AIR_RATIO_TO_SUSPEND)))
|
|
return 0
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND)
|
|
return 0
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
if(trace_gas.moles_archived > MINIMUM_AIR_TO_SUSPEND*4)
|
|
return 0
|
|
|
|
return 1
|
|
|
|
proc/share(datum/gas_mixture/sharer)
|
|
//Purpose: Used to transfer gas from a more pressurised tile to a less presurised tile
|
|
// (Two directional, if the other tile is more pressurised, air travels to current tile)
|
|
//Called by: Sharing air with adjacent simulated turfs
|
|
//Inputs: Air datum to share with
|
|
//Outputs: Amount of gas exchanged (Negative if lost air, positive if gained.)
|
|
|
|
|
|
if(!istype(sharer))
|
|
return
|
|
|
|
var/delta_oxygen = QUANTIZE(oxygen_archived - sharer.oxygen_archived)/TRANSFER_FRACTION
|
|
var/delta_carbon_dioxide = QUANTIZE(carbon_dioxide_archived - sharer.carbon_dioxide_archived)/TRANSFER_FRACTION
|
|
var/delta_nitrogen = QUANTIZE(nitrogen_archived - sharer.nitrogen_archived)/TRANSFER_FRACTION
|
|
var/delta_toxins = QUANTIZE(toxins_archived - sharer.toxins_archived)/TRANSFER_FRACTION
|
|
|
|
var/delta_temperature = (temperature_archived - sharer.temperature_archived)
|
|
|
|
var/old_self_heat_capacity = 0
|
|
var/old_sharer_heat_capacity = 0
|
|
|
|
var/heat_self_to_sharer = 0
|
|
var/heat_capacity_self_to_sharer = 0
|
|
var/heat_sharer_to_self = 0
|
|
var/heat_capacity_sharer_to_self = 0
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
|
|
var/delta_air = delta_oxygen+delta_nitrogen
|
|
if(delta_air)
|
|
var/air_heat_capacity = SPECIFIC_HEAT_AIR*delta_air
|
|
if(delta_air > 0)
|
|
heat_self_to_sharer += air_heat_capacity*temperature_archived
|
|
heat_capacity_self_to_sharer += air_heat_capacity
|
|
else
|
|
heat_sharer_to_self -= air_heat_capacity*sharer.temperature_archived
|
|
heat_capacity_sharer_to_self -= air_heat_capacity
|
|
|
|
if(delta_carbon_dioxide)
|
|
var/carbon_dioxide_heat_capacity = SPECIFIC_HEAT_CDO*delta_carbon_dioxide
|
|
if(delta_carbon_dioxide > 0)
|
|
heat_self_to_sharer += carbon_dioxide_heat_capacity*temperature_archived
|
|
heat_capacity_self_to_sharer += carbon_dioxide_heat_capacity
|
|
else
|
|
heat_sharer_to_self -= carbon_dioxide_heat_capacity*sharer.temperature_archived
|
|
heat_capacity_sharer_to_self -= carbon_dioxide_heat_capacity
|
|
|
|
if(delta_toxins)
|
|
var/toxins_heat_capacity = SPECIFIC_HEAT_TOXIN*delta_toxins
|
|
if(delta_toxins > 0)
|
|
heat_self_to_sharer += toxins_heat_capacity*temperature_archived
|
|
heat_capacity_self_to_sharer += toxins_heat_capacity
|
|
else
|
|
heat_sharer_to_self -= toxins_heat_capacity*sharer.temperature_archived
|
|
heat_capacity_sharer_to_self -= toxins_heat_capacity
|
|
|
|
old_self_heat_capacity = heat_capacity()*group_multiplier
|
|
old_sharer_heat_capacity = sharer.heat_capacity()*sharer.group_multiplier
|
|
|
|
oxygen -= delta_oxygen/group_multiplier
|
|
sharer.oxygen += delta_oxygen/sharer.group_multiplier
|
|
|
|
carbon_dioxide -= delta_carbon_dioxide/group_multiplier
|
|
sharer.carbon_dioxide += delta_carbon_dioxide/sharer.group_multiplier
|
|
|
|
nitrogen -= delta_nitrogen/group_multiplier
|
|
sharer.nitrogen += delta_nitrogen/sharer.group_multiplier
|
|
|
|
toxins -= delta_toxins/group_multiplier
|
|
sharer.toxins += delta_toxins/sharer.group_multiplier
|
|
|
|
var/moved_moles = (delta_oxygen + delta_carbon_dioxide + delta_nitrogen + delta_toxins)
|
|
|
|
var/list/trace_types_considered = list()
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in sharer.trace_gases
|
|
var/delta = 0
|
|
|
|
if(corresponding)
|
|
delta = QUANTIZE(trace_gas.moles_archived - corresponding.moles_archived)/TRANSFER_FRACTION
|
|
else
|
|
corresponding = new trace_gas.type()
|
|
sharer.trace_gases += corresponding
|
|
|
|
delta = trace_gas.moles_archived/TRANSFER_FRACTION
|
|
|
|
trace_gas.moles -= delta/group_multiplier
|
|
corresponding.moles += delta/sharer.group_multiplier
|
|
|
|
if(delta)
|
|
var/individual_heat_capacity = trace_gas.specific_heat*delta
|
|
if(delta > 0)
|
|
heat_self_to_sharer += individual_heat_capacity*temperature_archived
|
|
heat_capacity_self_to_sharer += individual_heat_capacity
|
|
else
|
|
heat_sharer_to_self -= individual_heat_capacity*sharer.temperature_archived
|
|
heat_capacity_sharer_to_self -= individual_heat_capacity
|
|
|
|
moved_moles += delta
|
|
|
|
trace_types_considered += trace_gas.type
|
|
|
|
|
|
if(sharer.trace_gases.len)
|
|
for(var/datum/gas/trace_gas in sharer.trace_gases)
|
|
if(trace_gas.type in trace_types_considered) continue
|
|
else
|
|
var/datum/gas/corresponding
|
|
var/delta = 0
|
|
|
|
corresponding = new trace_gas.type()
|
|
trace_gases += corresponding
|
|
|
|
delta = trace_gas.moles_archived/TRANSFER_FRACTION
|
|
|
|
trace_gas.moles -= delta/sharer.group_multiplier
|
|
corresponding.moles += delta/group_multiplier
|
|
|
|
//Guaranteed transfer from sharer to self
|
|
var/individual_heat_capacity = trace_gas.specific_heat*delta
|
|
heat_sharer_to_self += individual_heat_capacity*sharer.temperature_archived
|
|
heat_capacity_sharer_to_self += individual_heat_capacity
|
|
|
|
moved_moles += -delta
|
|
update_values()
|
|
sharer.update_values()
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/new_self_heat_capacity = old_self_heat_capacity + heat_capacity_sharer_to_self - heat_capacity_self_to_sharer
|
|
var/new_sharer_heat_capacity = old_sharer_heat_capacity + heat_capacity_self_to_sharer - heat_capacity_sharer_to_self
|
|
|
|
if(new_self_heat_capacity > MINIMUM_HEAT_CAPACITY)
|
|
temperature = (old_self_heat_capacity*temperature - heat_capacity_self_to_sharer*temperature_archived + heat_capacity_sharer_to_self*sharer.temperature_archived)/new_self_heat_capacity
|
|
|
|
if(new_sharer_heat_capacity > MINIMUM_HEAT_CAPACITY)
|
|
sharer.temperature = (old_sharer_heat_capacity*sharer.temperature-heat_capacity_sharer_to_self*sharer.temperature_archived + heat_capacity_self_to_sharer*temperature_archived)/new_sharer_heat_capacity
|
|
|
|
if(abs(old_sharer_heat_capacity) > MINIMUM_HEAT_CAPACITY)
|
|
if(abs(new_sharer_heat_capacity/old_sharer_heat_capacity - 1) < 0.10) // <10% change in sharer heat capacity
|
|
temperature_share(sharer, OPEN_HEAT_TRANSFER_COEFFICIENT)
|
|
|
|
if((delta_temperature > MINIMUM_TEMPERATURE_TO_MOVE) || abs(moved_moles) > MINIMUM_MOLES_DELTA_TO_MOVE)
|
|
var/delta_pressure = temperature_archived*(total_moles() + moved_moles) - sharer.temperature_archived*(sharer.total_moles() - moved_moles)
|
|
return delta_pressure*R_IDEAL_GAS_EQUATION/volume
|
|
|
|
else
|
|
return 0
|
|
|
|
proc/mimic(turf/model, border_multiplier)
|
|
//Purpose: Used transfer gas from a more pressurised tile to a less presurised unsimulated tile.
|
|
//Called by: "sharing" from unsimulated to simulated turfs.
|
|
//Inputs: Unsimulated turf, Multiplier for gas transfer (optional)
|
|
//Outputs: Amount of gas exchanged
|
|
|
|
var/delta_oxygen = QUANTIZE(oxygen_archived - model.oxygen)/TRANSFER_FRACTION
|
|
var/delta_carbon_dioxide = QUANTIZE(carbon_dioxide_archived - model.carbon_dioxide)/TRANSFER_FRACTION
|
|
var/delta_nitrogen = QUANTIZE(nitrogen_archived - model.nitrogen)/TRANSFER_FRACTION
|
|
var/delta_toxins = QUANTIZE(toxins_archived - model.toxins)/TRANSFER_FRACTION
|
|
|
|
var/delta_temperature = (temperature_archived - model.temperature)
|
|
|
|
var/heat_transferred = 0
|
|
var/old_self_heat_capacity = 0
|
|
var/heat_capacity_transferred = 0
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
|
|
var/delta_air = delta_oxygen+delta_nitrogen
|
|
if(delta_air)
|
|
var/air_heat_capacity = SPECIFIC_HEAT_AIR*delta_air
|
|
heat_transferred -= air_heat_capacity*model.temperature
|
|
heat_capacity_transferred -= air_heat_capacity
|
|
|
|
if(delta_carbon_dioxide)
|
|
var/carbon_dioxide_heat_capacity = SPECIFIC_HEAT_CDO*delta_carbon_dioxide
|
|
heat_transferred -= carbon_dioxide_heat_capacity*model.temperature
|
|
heat_capacity_transferred -= carbon_dioxide_heat_capacity
|
|
|
|
if(delta_toxins)
|
|
var/toxins_heat_capacity = SPECIFIC_HEAT_TOXIN*delta_toxins
|
|
heat_transferred -= toxins_heat_capacity*model.temperature
|
|
heat_capacity_transferred -= toxins_heat_capacity
|
|
|
|
old_self_heat_capacity = heat_capacity()*group_multiplier
|
|
|
|
if(border_multiplier)
|
|
oxygen -= delta_oxygen*border_multiplier/group_multiplier
|
|
carbon_dioxide -= delta_carbon_dioxide*border_multiplier/group_multiplier
|
|
nitrogen -= delta_nitrogen*border_multiplier/group_multiplier
|
|
toxins -= delta_toxins*border_multiplier/group_multiplier
|
|
else
|
|
oxygen -= delta_oxygen/group_multiplier
|
|
carbon_dioxide -= delta_carbon_dioxide/group_multiplier
|
|
nitrogen -= delta_nitrogen/group_multiplier
|
|
toxins -= delta_toxins/group_multiplier
|
|
|
|
var/moved_moles = (delta_oxygen + delta_carbon_dioxide + delta_nitrogen + delta_toxins)
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
var/delta = 0
|
|
|
|
delta = trace_gas.moles_archived/TRANSFER_FRACTION
|
|
|
|
if(border_multiplier)
|
|
trace_gas.moles -= delta*border_multiplier/group_multiplier
|
|
else
|
|
trace_gas.moles -= delta/group_multiplier
|
|
|
|
var/heat_cap_transferred = delta*trace_gas.specific_heat
|
|
heat_transferred += heat_cap_transferred*temperature_archived
|
|
heat_capacity_transferred += heat_cap_transferred
|
|
moved_moles += delta
|
|
update_values()
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/new_self_heat_capacity = old_self_heat_capacity - heat_capacity_transferred
|
|
if(new_self_heat_capacity > MINIMUM_HEAT_CAPACITY)
|
|
if(border_multiplier)
|
|
temperature = (old_self_heat_capacity*temperature - heat_capacity_transferred*border_multiplier*temperature_archived)/new_self_heat_capacity
|
|
else
|
|
temperature = (old_self_heat_capacity*temperature - heat_capacity_transferred*border_multiplier*temperature_archived)/new_self_heat_capacity
|
|
|
|
temperature_mimic(model, model.thermal_conductivity, border_multiplier)
|
|
|
|
if((delta_temperature > MINIMUM_TEMPERATURE_TO_MOVE) || abs(moved_moles) > MINIMUM_MOLES_DELTA_TO_MOVE)
|
|
var/delta_pressure = temperature_archived*(total_moles() + moved_moles) - model.temperature*(model.oxygen+model.carbon_dioxide+model.nitrogen+model.toxins)
|
|
return delta_pressure*R_IDEAL_GAS_EQUATION/volume
|
|
else
|
|
return 0
|
|
|
|
proc/check_both_then_temperature_share(datum/gas_mixture/sharer, conduction_coefficient)
|
|
var/delta_temperature = (temperature_archived - sharer.temperature_archived)
|
|
|
|
var/self_heat_capacity = heat_capacity_archived()
|
|
var/sharer_heat_capacity = sharer.heat_capacity_archived()
|
|
|
|
var/self_temperature_delta = 0
|
|
var/sharer_temperature_delta = 0
|
|
|
|
if((sharer_heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*sharer_heat_capacity/(self_heat_capacity+sharer_heat_capacity))
|
|
|
|
self_temperature_delta = -heat/(self_heat_capacity*group_multiplier)
|
|
sharer_temperature_delta = heat/(sharer_heat_capacity*sharer.group_multiplier)
|
|
else
|
|
return 1
|
|
|
|
if((abs(self_temperature_delta) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND) \
|
|
&& (abs(self_temperature_delta) > MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND*temperature_archived))
|
|
return 0
|
|
|
|
if((abs(sharer_temperature_delta) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND) \
|
|
&& (abs(sharer_temperature_delta) > MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND*sharer.temperature_archived))
|
|
return -1
|
|
|
|
temperature += self_temperature_delta
|
|
sharer.temperature += sharer_temperature_delta
|
|
|
|
return 1
|
|
//Logic integrated from: temperature_share(sharer, conduction_coefficient) for efficiency
|
|
|
|
proc/check_me_then_temperature_share(datum/gas_mixture/sharer, conduction_coefficient)
|
|
var/delta_temperature = (temperature_archived - sharer.temperature_archived)
|
|
|
|
var/self_heat_capacity = heat_capacity_archived()
|
|
var/sharer_heat_capacity = sharer.heat_capacity_archived()
|
|
|
|
var/self_temperature_delta = 0
|
|
var/sharer_temperature_delta = 0
|
|
|
|
if((sharer_heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*sharer_heat_capacity/(self_heat_capacity+sharer_heat_capacity))
|
|
|
|
self_temperature_delta = -heat/(self_heat_capacity*group_multiplier)
|
|
sharer_temperature_delta = heat/(sharer_heat_capacity*sharer.group_multiplier)
|
|
else
|
|
return 1
|
|
|
|
if((abs(self_temperature_delta) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND) \
|
|
&& (abs(self_temperature_delta) > MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND*temperature_archived))
|
|
return 0
|
|
|
|
temperature += self_temperature_delta
|
|
sharer.temperature += sharer_temperature_delta
|
|
|
|
return 1
|
|
//Logic integrated from: temperature_share(sharer, conduction_coefficient) for efficiency
|
|
|
|
proc/check_me_then_temperature_turf_share(turf/simulated/sharer, conduction_coefficient)
|
|
var/delta_temperature = (temperature_archived - sharer.temperature)
|
|
|
|
var/self_temperature_delta = 0
|
|
var/sharer_temperature_delta = 0
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/self_heat_capacity = heat_capacity_archived()
|
|
|
|
if((sharer.heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*sharer.heat_capacity/(self_heat_capacity+sharer.heat_capacity))
|
|
|
|
self_temperature_delta = -heat/(self_heat_capacity*group_multiplier)
|
|
sharer_temperature_delta = heat/sharer.heat_capacity
|
|
else
|
|
return 1
|
|
|
|
if((abs(self_temperature_delta) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND) \
|
|
&& (abs(self_temperature_delta) > MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND*temperature_archived))
|
|
return 0
|
|
|
|
temperature += self_temperature_delta
|
|
sharer.temperature += sharer_temperature_delta
|
|
|
|
return 1
|
|
//Logic integrated from: temperature_turf_share(sharer, conduction_coefficient) for efficiency
|
|
|
|
proc/check_me_then_temperature_mimic(turf/model, conduction_coefficient)
|
|
var/delta_temperature = (temperature_archived - model.temperature)
|
|
var/self_temperature_delta = 0
|
|
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/self_heat_capacity = heat_capacity_archived()
|
|
|
|
if((model.heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*model.heat_capacity/(self_heat_capacity+model.heat_capacity))
|
|
|
|
self_temperature_delta = -heat/(self_heat_capacity*group_multiplier)
|
|
|
|
if((abs(self_temperature_delta) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND) \
|
|
&& (abs(self_temperature_delta) > MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND*temperature_archived))
|
|
return 0
|
|
|
|
temperature += self_temperature_delta
|
|
|
|
return 1
|
|
//Logic integrated from: temperature_mimic(model, conduction_coefficient) for efficiency
|
|
|
|
proc/temperature_share(datum/gas_mixture/sharer, conduction_coefficient)
|
|
|
|
var/delta_temperature = (temperature_archived - sharer.temperature_archived)
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/self_heat_capacity = heat_capacity_archived()
|
|
var/sharer_heat_capacity = sharer.heat_capacity_archived()
|
|
if(!group_multiplier)
|
|
message_admins("Error! The gas mixture (ref \ref[src]) has no group multiplier!")
|
|
return
|
|
|
|
if((sharer_heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*sharer_heat_capacity/(self_heat_capacity+sharer_heat_capacity))
|
|
|
|
temperature -= heat/(self_heat_capacity*group_multiplier)
|
|
sharer.temperature += heat/(sharer_heat_capacity*sharer.group_multiplier)
|
|
|
|
proc/temperature_mimic(turf/model, conduction_coefficient, border_multiplier)
|
|
var/delta_temperature = (temperature - model.temperature)
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/self_heat_capacity = heat_capacity()//_archived()
|
|
if(!group_multiplier)
|
|
message_admins("Error! The gas mixture (ref \ref[src]) has no group multiplier!")
|
|
return
|
|
|
|
if((model.heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*model.heat_capacity/(self_heat_capacity+model.heat_capacity))
|
|
|
|
if(border_multiplier)
|
|
temperature -= heat*border_multiplier/(self_heat_capacity*group_multiplier)
|
|
else
|
|
temperature -= heat/(self_heat_capacity*group_multiplier)
|
|
|
|
proc/temperature_turf_share(turf/simulated/sharer, conduction_coefficient)
|
|
var/delta_temperature = (temperature_archived - sharer.temperature)
|
|
if(abs(delta_temperature) > MINIMUM_TEMPERATURE_DELTA_TO_CONSIDER)
|
|
var/self_heat_capacity = heat_capacity()
|
|
|
|
if((sharer.heat_capacity > MINIMUM_HEAT_CAPACITY) && (self_heat_capacity > MINIMUM_HEAT_CAPACITY))
|
|
var/heat = conduction_coefficient*delta_temperature* \
|
|
(self_heat_capacity*sharer.heat_capacity/(self_heat_capacity+sharer.heat_capacity))
|
|
|
|
temperature -= heat/(self_heat_capacity*group_multiplier)
|
|
sharer.temperature += heat/sharer.heat_capacity
|
|
|
|
proc/compare(datum/gas_mixture/sample)
|
|
//Purpose: Compares sample to self to see if within acceptable ranges that group processing may be enabled
|
|
//Called by: Airgroups trying to rebuild
|
|
//Inputs: Gas mix to compare
|
|
//Outputs: 1 if can rebuild, 0 if not.
|
|
if(!sample) return 0
|
|
|
|
if((abs(oxygen-sample.oxygen) > MINIMUM_AIR_TO_SUSPEND) && \
|
|
((oxygen < (1-MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.oxygen) || (oxygen > (1+MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.oxygen)))
|
|
return 0
|
|
if((abs(nitrogen-sample.nitrogen) > MINIMUM_AIR_TO_SUSPEND) && \
|
|
((nitrogen < (1-MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.nitrogen) || (nitrogen > (1+MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.nitrogen)))
|
|
return 0
|
|
if((abs(carbon_dioxide-sample.carbon_dioxide) > MINIMUM_AIR_TO_SUSPEND) && \
|
|
((carbon_dioxide < (1-MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.carbon_dioxide) || (oxygen > (1+MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.carbon_dioxide)))
|
|
return 0
|
|
if((abs(toxins-sample.toxins) > MINIMUM_AIR_TO_SUSPEND) && \
|
|
((toxins < (1-MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.toxins) || (toxins > (1+MINIMUM_AIR_RATIO_TO_SUSPEND)*sample.toxins)))
|
|
return 0
|
|
|
|
if(total_moles() > MINIMUM_AIR_TO_SUSPEND)
|
|
if((abs(temperature-sample.temperature) > MINIMUM_TEMPERATURE_DELTA_TO_SUSPEND) && \
|
|
((temperature < (1-MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND)*sample.temperature) || (temperature > (1+MINIMUM_TEMPERATURE_RATIO_TO_SUSPEND)*sample.temperature)))
|
|
//world << "temp fail [temperature] & [sample.temperature]"
|
|
return 0
|
|
|
|
if(sample.trace_gases.len)
|
|
for(var/datum/gas/trace_gas in sample.trace_gases)
|
|
if(trace_gas.moles_archived > MINIMUM_AIR_TO_SUSPEND)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in trace_gases
|
|
if(corresponding)
|
|
if((abs(trace_gas.moles - corresponding.moles) > MINIMUM_AIR_TO_SUSPEND) && \
|
|
((corresponding.moles < (1-MINIMUM_AIR_RATIO_TO_SUSPEND)*trace_gas.moles) || (corresponding.moles > (1+MINIMUM_AIR_RATIO_TO_SUSPEND)*trace_gas.moles)))
|
|
return 0
|
|
else
|
|
return 0
|
|
|
|
if(trace_gases.len)
|
|
for(var/datum/gas/trace_gas in trace_gases)
|
|
if(trace_gas.moles > MINIMUM_AIR_TO_SUSPEND)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in sample.trace_gases
|
|
if(corresponding)
|
|
if((abs(trace_gas.moles - corresponding.moles) > MINIMUM_AIR_TO_SUSPEND) && \
|
|
((trace_gas.moles < (1-MINIMUM_AIR_RATIO_TO_SUSPEND)*corresponding.moles) || (trace_gas.moles > (1+MINIMUM_AIR_RATIO_TO_SUSPEND)*corresponding.moles)))
|
|
return 0
|
|
else
|
|
return 0
|
|
return 1
|
|
|
|
|
|
proc/subtract(datum/gas_mixture/right_side)
|
|
//Purpose: Subtracts right_side from air_mixture. Used to help turfs mingle
|
|
//Called by: Pipelines ending in a break (or something)
|
|
//Inputs: Gas mix to remove
|
|
//Outputs: 1
|
|
|
|
oxygen -= right_side.oxygen
|
|
carbon_dioxide -= right_side.carbon_dioxide
|
|
nitrogen -= right_side.nitrogen
|
|
toxins -= right_side.toxins
|
|
|
|
if((trace_gases.len > 0)||(right_side.trace_gases.len > 0))
|
|
for(var/datum/gas/trace_gas in right_side.trace_gases)
|
|
var/datum/gas/corresponding = locate(trace_gas.type) in trace_gases
|
|
if(!corresponding)
|
|
corresponding = new trace_gas.type()
|
|
trace_gases += corresponding
|
|
|
|
corresponding.moles -= trace_gas.moles
|
|
update_values()
|
|
return 1 |