CHOMPStation2/code/ZAS/Processing.dm

#define QUANTIZE(variable)		(round(variable,0.0001))
var/explosion_halt = 0
zone
	proc/process()
		//Does rebuilding stuff. Not sure if used.
		if(rebuild)
			//Deletes zone if empty.
			if(!contents.len)
				del src
				return 0

			//Choose a random turf and regenerate the zone from it.
			var
				turf/sample = pick(contents)
				list/new_contents = FloodFill(sample)
				problem = 0

			//If something isn't carried over, there was a complication.
			for(var/turf/T in contents)
				if(!(T in new_contents))
					problem = 1

			if(problem)
				//Build some new zones for stuff that wasn't included.
				var/list/rebuild_turfs = list()
				for(var/turf/T in contents - new_contents)
					contents -= T
					rebuild_turfs += T
					T.zone = null
				for(var/turf/T in rebuild_turfs)
					if(!T.zone)
						var/zone/Z = new/zone(T)
						Z.air.copy_from(air)
			rebuild = 0

		//Sometimes explosions will cause the air to be deleted for some reason.
		if(!air)
			air = new()
			air.adjustGases(MOLES_O2STANDARD, 0, MOLES_N2STANDARD, 0, list())
			world.log << "Air object lost in zone. Regenerating."

		//Counting up space.
		var/total_space = 0

		if(space_tiles)
			for(var/T in space_tiles)
				if(!istype(T,/turf/space)) space_tiles -= T
			total_space = length(space_tiles)

		//Add checks to ensure that we're not sucking air out of an empty room.
		if(total_space && air.total_moles > 0.1 && air.temperature > TCMB+0.5)
			//If there is space, air should flow out of the zone.
			ShareSpace(air,total_space*(vsc.zone_share_percent/100))

		//React the air here.
		air.react(null,0)

		//Check the graphic.
		var/check = air.check_tile_graphic()

		//Only run through the individual turfs if there's reason to.
		if(check || air.temperature > FIRE_MINIMUM_TEMPERATURE_TO_EXIST)

			for(var/turf/simulated/S in contents)
				//Update overlays.
				if(check)
					if(S.HasDoor(1))
						S.update_visuals()
					else
						S.update_visuals(air)

				//Expose stuff to extreme heat.
				if(air.temperature > FIRE_MINIMUM_TEMPERATURE_TO_EXIST)
					for(var/atom/movable/item in S)
						item.temperature_expose(air, air.temperature, CELL_VOLUME)
					S.temperature_expose(air, air.temperature, CELL_VOLUME)

		//Archive graphic so we can know if it's different.
		air.graphic_archived = air.graphic

		//Ensure temperature does not reach absolute zero.
		air.temperature = max(TCMB,air.temperature)

		//Handle connections to other zones.
		if(length(connections))
			for(var/connection/C in connections)
				//Check if the connection is valid first.
				C.Cleanup()
				//Do merging if conditions are met. Specifically, if there's a non-door connection
				//to somewhere with space, the zones are merged regardless of equilibrium, to speed
				//up spacing in areas with double-plated windows.
				if(C && !C.indirect && C.A.zone && C.B.zone)
					if(C.A.zone.air.compare(C.B.zone.air) || total_space)
						ZMerge(C.A.zone,C.B.zone)

			//Share some
			for(var/zone/Z in connected_zones)
				//Ensure we're not doing pointless calculations on equilibrium zones.
				if(abs(air.total_moles - Z.air.total_moles) > 0.1 || abs(air.temperature - Z.air.temperature) > 0.1)
					ShareRatio(air,Z.air,connected_zones[Z]*(vsc.zone_share_percent/100))

proc/ShareRatio(datum/gas_mixture/A, datum/gas_mixture/B, ratio)
	//Shares a specific ratio of gas between mixtures using simple weighted averages.
	var
		size = max(1,A.group_multiplier)
		share_size = max(1,B.group_multiplier)

		full_oxy = A.oxygen * size
		full_nitro = A.nitrogen * size
		full_co2 = A.carbon_dioxide * size
		full_plasma = A.toxins * size

		full_thermal = A.temperature * A.heat_capacity() * size

		s_full_oxy = B.oxygen * share_size
		s_full_nitro = B.nitrogen * share_size
		s_full_co2 = B.carbon_dioxide * share_size
		s_full_plasma = B.toxins * share_size

		s_full_thermal = B.temperature * B.heat_capacity() * share_size

		oxy_avg = (full_oxy + s_full_oxy) / (size + share_size)
		nit_avg = (full_nitro + s_full_nitro) / (size + share_size)
		co2_avg = (full_co2 + s_full_co2) / (size + share_size)
		plasma_avg = (full_plasma + s_full_plasma) / (size + share_size)

		thermal_avg = (full_thermal + s_full_thermal) / (size+share_size)

	A.oxygen = (A.oxygen - oxy_avg) * (1-ratio) + oxy_avg
	A.nitrogen = (A.nitrogen - nit_avg) * (1-ratio) + nit_avg
	A.carbon_dioxide = (A.carbon_dioxide - co2_avg) * (1-ratio) + co2_avg
	A.toxins = (A.toxins - plasma_avg) * (1-ratio) + plasma_avg

	B.oxygen = (B.oxygen - oxy_avg) * (1-ratio) + oxy_avg
	B.nitrogen = (B.nitrogen - nit_avg) * (1-ratio) + nit_avg
	B.carbon_dioxide = (B.carbon_dioxide - co2_avg) * (1-ratio) + co2_avg
	B.toxins = (B.toxins - plasma_avg) * (1-ratio) + plasma_avg

	var
		thermal = (full_thermal/size - thermal_avg) * (1-ratio) + thermal_avg
		sharer_thermal = (s_full_thermal/share_size - thermal_avg) * (1-ratio) + thermal_avg

	A.temperature = thermal / (A.heat_capacity() == 0 ? MINIMUM_HEAT_CAPACITY : A.heat_capacity())

	B.temperature = sharer_thermal / (B.heat_capacity() == 0 ? MINIMUM_HEAT_CAPACITY : B.heat_capacity())

	for(var/datum/gas/G in A.trace_gases)
		var/datum/gas/H = locate(G.type) in B.trace_gases
		if(H)
			var/G_avg = (G.moles*size + H.moles*share_size) / (size+share_size)
			G.moles = (G.moles - G_avg) * (1-ratio) + G_avg
			H.moles = (H.moles - G_avg) * (1-ratio) + G_avg
		else
			H = new G.type
			B.trace_gases += H
			var/G_avg = (G.moles*size) / (size+share_size)
			G.moles = (G.moles - G_avg) * (1-ratio) + G_avg
			H.moles = (H.moles - G_avg) * (1-ratio) + G_avg

	A.update_values()
	B.update_values()

	if(A.compare(B)) return 1
	else return 0

proc/ShareSpace(datum/gas_mixture/A, ratio)
	//A modified version of ShareRatio for spacing gas at the same rate as if it were going into a huge airless room.
	var
		size = max(1,A.group_multiplier)
		share_size = 2000 //A huge value because space is huge.

		full_oxy = A.oxygen * size
		full_nitro = A.nitrogen * size
		full_co2 = A.carbon_dioxide * size
		full_plasma = A.toxins * size

		full_thermal = A.temperature * A.heat_capacity() * size

		oxy_avg = (full_oxy + 0) / (size + share_size)
		nit_avg = (full_nitro + 0.2) / (size + share_size)
		co2_avg = (full_co2 + 0) / (size + share_size)
		plasma_avg = (full_plasma + 0) / (size + share_size)

		thermal_avg = (full_thermal + MINIMUM_HEAT_CAPACITY) / (size+share_size)

	A.oxygen = (A.oxygen - oxy_avg) * (1-ratio) + oxy_avg
	A.nitrogen = (A.nitrogen - nit_avg) * (1-ratio) + nit_avg
	A.carbon_dioxide = (A.carbon_dioxide - co2_avg) * (1-ratio) + co2_avg
	A.toxins = (A.toxins - plasma_avg) * (1-ratio) + plasma_avg

	var/thermal = (full_thermal/size - thermal_avg) * (1-ratio) + thermal_avg

	A.temperature = thermal / (A.heat_capacity() == 0 ? MINIMUM_HEAT_CAPACITY : A.heat_capacity())

	for(var/datum/gas/G in A.trace_gases)
		var/G_avg = (G.moles*size + 0) / (size+share_size)
		G.moles = (G.moles - G_avg) * (1-ratio) + G_avg

	A.update_values()

	return 1


zone/proc
	connected_zones()
		//A legacy proc for getting connected zones.
		. = list()
		for(var/connection/C in connections)
			var/zone/Z
			if(C.A.zone == src)
				Z = C.B.zone
			else
				Z = C.A.zone

			if(Z in .)
				.[Z]++
			else
				. += Z
				.[Z] = 1