Uploading all files.

code/modules/power/antimatter/containment_jar.dm

@@ -0,0 +1,40 @@
+/obj/item/am_containment
+	name = "antimatter containment jar"
+	desc = "Holds antimatter."
+	icon = 'icons/obj/machines/antimatter.dmi'
+	icon_state = "jar"
+	density = FALSE
+	anchored = FALSE
+	force = 8
+	throwforce = 10
+	throw_speed = 1
+	throw_range = 2
+
+	var/fuel = 10000
+	var/fuel_max = 10000//Lets try this for now
+	var/stability = 100//TODO: add all the stability things to this so its not very safe if you keep hitting in on things
+
+
+/obj/item/am_containment/ex_act(severity, target)
+	switch(severity)
+		if(1)
+			explosion(get_turf(src), 1, 2, 3, 5)//Should likely be larger but this works fine for now I guess
+			if(src)
+				qdel(src)
+		if(2)
+			if(prob((fuel/10)-stability))
+				explosion(get_turf(src), 1, 2, 3, 5)
+				if(src)
+					qdel(src)
+				return
+			stability -= 40
+		if(3)
+			stability -= 20
+	//check_stability()
+	return
+
+/obj/item/am_containment/proc/usefuel(wanted)
+	if(fuel < wanted)
+		wanted = fuel
+	fuel -= wanted
+	return wanted

code/modules/power/antimatter/control.dm

@@ -0,0 +1,357 @@
+/obj/machinery/power/am_control_unit
+	name = "antimatter control unit"
+	desc = "This device injects antimatter into connected shielding units, the more antimatter injected the more power produced.  Wrench the device to set it up."
+	icon = 'icons/obj/machines/antimatter.dmi'
+	icon_state = "control"
+	anchored = FALSE
+	density = TRUE
+	use_power = IDLE_POWER_USE
+	idle_power_usage = 100
+	active_power_usage = 1000
+
+	interaction_flags_atom = INTERACT_ATOM_ATTACK_HAND | INTERACT_ATOM_UI_INTERACT | INTERACT_ATOM_REQUIRES_ANCHORED
+
+	var/list/obj/machinery/am_shielding/linked_shielding
+	var/list/obj/machinery/am_shielding/linked_cores
+	var/obj/item/am_containment/fueljar
+	var/update_shield_icons = 0
+	var/stability = 100
+	var/exploding = 0
+
+	var/active = 0//On or not
+	var/fuel_injection = 2//How much fuel to inject
+	var/shield_icon_delay = 0//delays resetting for a short time
+	var/reported_core_efficiency = 0
+
+	var/power_cycle = 0
+	var/power_cycle_delay = 4//How many ticks till produce_power is called
+	var/stored_core_stability = 0
+	var/stored_core_stability_delay = 0
+
+	var/stored_power = 0//Power to deploy per tick
+
+
+/obj/machinery/power/am_control_unit/Initialize()
+	. = ..()
+	linked_shielding = list()
+	linked_cores = list()
+
+
+/obj/machinery/power/am_control_unit/Destroy()//Perhaps damage and run stability checks rather than just del on the others
+	for(var/obj/machinery/am_shielding/AMS in linked_shielding)
+		AMS.control_unit = null
+		qdel(AMS)
+	QDEL_NULL(fueljar)
+	return ..()
+
+
+/obj/machinery/power/am_control_unit/process()
+	if(exploding)
+		explosion(get_turf(src),8,12,18,12)
+		if(src)
+			qdel(src)
+
+	if(update_shield_icons && !shield_icon_delay)
+		check_shield_icons()
+		update_shield_icons = 0
+
+	if(stat & (NOPOWER|BROKEN) || !active)//can update the icons even without power
+		return
+
+	if(!fueljar)//No fuel but we are on, shutdown
+		toggle_power()
+		playsound(src.loc, 'sound/machines/buzz-two.ogg', 50, 0)
+		return
+
+	add_avail(stored_power)
+
+	power_cycle++
+	if(power_cycle >= power_cycle_delay)
+		produce_power()
+		power_cycle = 0
+
+	return
+
+
+/obj/machinery/power/am_control_unit/proc/produce_power()
+	playsound(src.loc, 'sound/effects/bang.ogg', 25, 1)
+	var/core_power = reported_core_efficiency//Effectively how much fuel we can safely deal with
+	if(core_power <= 0)
+		return 0//Something is wrong
+	var/core_damage = 0
+	var/fuel = fueljar.usefuel(fuel_injection)
+
+	stored_power = (fuel/core_power)*fuel*200000
+	//Now check if the cores could deal with it safely, this is done after so you can overload for more power if needed, still a bad idea
+	if(fuel > (2*core_power))//More fuel has been put in than the current cores can deal with
+		if(prob(50))
+			core_damage = 1//Small chance of damage
+		if((fuel-core_power) > 5)
+			core_damage = 5//Now its really starting to overload the cores
+		if((fuel-core_power) > 10)
+			core_damage = 20//Welp now you did it, they wont stand much of this
+		if(core_damage == 0)
+			return
+		for(var/obj/machinery/am_shielding/AMS in linked_cores)
+			AMS.stability -= core_damage
+			AMS.check_stability(1)
+		playsound(src.loc, 'sound/effects/bang.ogg', 50, 1)
+	return
+
+
+/obj/machinery/power/am_control_unit/emp_act(severity)
+	. = ..()
+	if(. & EMP_PROTECT_SELF)
+		return
+	switch(severity)
+		if(1)
+			if(active)
+				toggle_power()
+			stability -= rand(15,30)
+		if(2)
+			if(active)
+				toggle_power()
+			stability -= rand(10,20)
+
+/obj/machinery/power/am_control_unit/blob_act()
+	stability -= 20
+	if(prob(100-stability))//Might infect the rest of the machine
+		for(var/obj/machinery/am_shielding/AMS in linked_shielding)
+			AMS.blob_act()
+		qdel(src)
+		return
+	check_stability()
+	return
+
+
+/obj/machinery/power/am_control_unit/ex_act(severity, target)
+	stability -= (80 - (severity * 20))
+	check_stability()
+	return
+
+
+/obj/machinery/power/am_control_unit/bullet_act(obj/item/projectile/Proj)
+	. = ..()
+	if(Proj.flag != "bullet")
+		stability -= Proj.force
+		check_stability()
+
+
+/obj/machinery/power/am_control_unit/power_change()
+	..()
+	if(stat & NOPOWER)
+		if(active)
+			toggle_power(1)
+		else
+			use_power = NO_POWER_USE
+
+	else if(!stat && anchored)
+		use_power = IDLE_POWER_USE
+
+	return
+
+
+/obj/machinery/power/am_control_unit/update_icon()
+	if(active)
+		icon_state = "control_on"
+	else icon_state = "control"
+	//No other icons for it atm
+
+
+/obj/machinery/power/am_control_unit/attackby(obj/item/W, mob/user, params)
+	if(istype(W, /obj/item/wrench))
+		if(!anchored)
+			W.play_tool_sound(src, 75)
+			user.visible_message("[user.name] secures the [src.name] to the floor.", \
+				"<span class='notice'>You secure the anchor bolts to the floor.</span>", \
+				"<span class='italics'>You hear a ratchet.</span>")
+			src.anchored = TRUE
+			connect_to_network()
+		else if(!linked_shielding.len > 0)
+			W.play_tool_sound(src, 75)
+			user.visible_message("[user.name] unsecures the [src.name].", \
+				"<span class='notice'>You remove the anchor bolts.</span>", \
+				"<span class='italics'>You hear a ratchet.</span>")
+			src.anchored = FALSE
+			disconnect_from_network()
+		else
+			to_chat(user, "<span class='warning'>Once bolted and linked to a shielding unit it the [src.name] is unable to be moved!</span>")
+
+	else if(istype(W, /obj/item/am_containment))
+		if(fueljar)
+			to_chat(user, "<span class='warning'>There is already a [fueljar] inside!</span>")
+			return
+
+		if(!user.transferItemToLoc(W, src))
+			return
+		fueljar = W
+		user.visible_message("[user.name] loads an [W.name] into the [src.name].", \
+				"<span class='notice'>You load an [W.name].</span>", \
+				"<span class='italics'>You hear a thunk.</span>")
+	else
+		return ..()
+
+
+/obj/machinery/power/am_control_unit/take_damage(damage, damage_type = BRUTE, sound_effect = 1)
+	switch(damage_type)
+		if(BRUTE)
+			if(sound_effect)
+				if(damage)
+					playsound(loc, 'sound/weapons/smash.ogg', 50, 1)
+				else
+					playsound(loc, 'sound/weapons/tap.ogg', 50, 1)
+		if(BURN)
+			if(sound_effect)
+				playsound(src.loc, 'sound/items/welder.ogg', 100, 1)
+		else
+			return
+	if(damage >= 20)
+		stability -= damage/2
+		check_stability()
+
+/obj/machinery/power/am_control_unit/proc/add_shielding(obj/machinery/am_shielding/AMS, AMS_linking = 0)
+	if(!istype(AMS))
+		return 0
+	if(!anchored)
+		return 0
+	if(!AMS_linking && !AMS.link_control(src))
+		return 0
+	linked_shielding.Add(AMS)
+	update_shield_icons = 1
+	return 1
+
+
+/obj/machinery/power/am_control_unit/proc/remove_shielding(obj/machinery/am_shielding/AMS)
+	if(!istype(AMS))
+		return 0
+	linked_shielding.Remove(AMS)
+	update_shield_icons = 2
+	if(active)
+		toggle_power()
+	return 1
+
+
+/obj/machinery/power/am_control_unit/proc/check_stability()//TODO: make it break when low also might want to add a way to fix it like a part or such that can be replaced
+	if(stability <= 0)
+		qdel(src)
+	return
+
+
+/obj/machinery/power/am_control_unit/proc/toggle_power(powerfail = 0)
+	active = !active
+	if(active)
+		use_power = ACTIVE_POWER_USE
+		visible_message("The [src.name] starts up.")
+	else
+		use_power = !powerfail
+		visible_message("The [src.name] shuts down.")
+	update_icon()
+	return
+
+
+/obj/machinery/power/am_control_unit/proc/check_shield_icons()//Forces icon_update for all shields
+	if(shield_icon_delay)
+		return
+	shield_icon_delay = 1
+	if(update_shield_icons == 2)//2 means to clear everything and rebuild
+		for(var/obj/machinery/am_shielding/AMS in linked_shielding)
+			if(AMS.processing)
+				AMS.shutdown_core()
+			AMS.control_unit = null
+			addtimer(CALLBACK(AMS, /obj/machinery/am_shielding.proc/controllerscan), 10)
+		linked_shielding = list()
+	else
+		for(var/obj/machinery/am_shielding/AMS in linked_shielding)
+			AMS.update_icon()
+	addtimer(CALLBACK(src, .proc/reset_shield_icon_delay), 20)
+
+/obj/machinery/power/am_control_unit/proc/reset_shield_icon_delay()
+	shield_icon_delay = 0
+
+/obj/machinery/power/am_control_unit/proc/check_core_stability()
+	if(stored_core_stability_delay || linked_cores.len <= 0)
+		return
+	stored_core_stability_delay = 1
+	stored_core_stability = 0
+	for(var/obj/machinery/am_shielding/AMS in linked_cores)
+		stored_core_stability += AMS.stability
+	stored_core_stability/=linked_cores.len
+	addtimer(CALLBACK(src, .proc/reset_stored_core_stability_delay), 40)
+
+/obj/machinery/power/am_control_unit/proc/reset_stored_core_stability_delay()
+	stored_core_stability_delay = 0
+
+/obj/machinery/power/am_control_unit/ui_interact(mob/user)
+	. = ..()
+	if((get_dist(src, user) > 1) || (stat & (BROKEN|NOPOWER)))
+		if(!isAI(user))
+			user.unset_machine()
+			user << browse(null, "window=AMcontrol")
+			return
+
+	var/dat = ""
+	dat += "AntiMatter Control Panel<BR>"
+	dat += "<A href='?src=[REF(src)];close=1'>Close</A><BR>"
+	dat += "<A href='?src=[REF(src)];refresh=1'>Refresh</A><BR>"
+	dat += "<A href='?src=[REF(src)];refreshicons=1'>Force Shielding Update</A><BR><BR>"
+	dat += "Status: [(active?"Injecting":"Standby")] <BR>"
+	dat += "<A href='?src=[REF(src)];togglestatus=1'>Toggle Status</A><BR>"
+
+	dat += "Stability: [stability]%<BR>"
+	dat += "Reactor parts: [linked_shielding.len]<BR>"//TODO: perhaps add some sort of stability check
+	dat += "Cores: [linked_cores.len]<BR><BR>"
+	dat += "-Current Efficiency: [reported_core_efficiency]<BR>"
+	dat += "-Average Stability: [stored_core_stability] <A href='?src=[REF(src)];refreshstability=1'>(update)</A><BR>"
+	dat += "Last Produced: [DisplayPower(stored_power)]<BR>"
+
+	dat += "Fuel: "
+	if(!fueljar)
+		dat += "<BR>No fuel receptacle detected."
+	else
+		dat += "<A href='?src=[REF(src)];ejectjar=1'>Eject</A><BR>"
+		dat += "- [fueljar.fuel]/[fueljar.fuel_max] Units<BR>"
+
+		dat += "- Injecting: [fuel_injection] units<BR>"
+		dat += "- <A href='?src=[REF(src)];strengthdown=1'>--</A>|<A href='?src=[REF(src)];strengthup=1'>++</A><BR><BR>"
+
+
+	user << browse(dat, "window=AMcontrol;size=420x500")
+	onclose(user, "AMcontrol")
+	return
+
+
+/obj/machinery/power/am_control_unit/Topic(href, href_list)
+	if(..())
+		return
+
+	if(href_list["close"])
+		usr << browse(null, "window=AMcontrol")
+		usr.unset_machine()
+		return
+
+	if(href_list["togglestatus"])
+		toggle_power()
+
+	if(href_list["refreshicons"])
+		update_shield_icons = 1
+
+	if(href_list["ejectjar"])
+		if(fueljar)
+			fueljar.forceMove(drop_location())
+			fueljar = null
+			//fueljar.control_unit = null currently it does not care where it is
+			//update_icon() when we have the icon for it
+
+	if(href_list["strengthup"])
+		fuel_injection++
+
+	if(href_list["strengthdown"])
+		fuel_injection--
+		if(fuel_injection < 0)
+			fuel_injection = 0
+
+	if(href_list["refreshstability"])
+		check_core_stability()
+
+	updateDialog()
+	return

code/modules/power/antimatter/shielding.dm

@@ -0,0 +1,253 @@
+//like orange but only checks north/south/east/west for one step
+/proc/cardinalrange(var/center)
+	var/list/things = list()
+	for(var/direction in GLOB.cardinals)
+		var/turf/T = get_step(center, direction)
+		if(!T)
+			continue
+		things += T.contents
+	return things
+
+/obj/machinery/am_shielding
+	name = "antimatter reactor section"
+	desc = "This device was built using a plasma life-form that seems to increase plasma's natural ability to react with neutrinos while reducing the combustibility."
+
+	icon = 'icons/obj/machines/antimatter.dmi'
+	icon_state = "shield"
+	density = TRUE
+	dir = NORTH
+	use_power = NO_POWER_USE//Living things generally dont use power
+	idle_power_usage = 0
+	active_power_usage = 0
+
+	var/obj/machinery/power/am_control_unit/control_unit = null
+	var/processing = FALSE//To track if we are in the update list or not, we need to be when we are damaged and if we ever
+	var/stability = 100//If this gets low bad things tend to happen
+	var/efficiency = 1//How many cores this core counts for when doing power processing, plasma in the air and stability could affect this
+	var/coredirs = 0
+	var/dirs = 0
+
+
+/obj/machinery/am_shielding/Initialize()
+	. = ..()
+	addtimer(CALLBACK(src, .proc/controllerscan), 10)
+
+/obj/machinery/am_shielding/proc/overheat()
+	visible_message("<span class='danger'>[src] melts!</span>")
+	new /obj/effect/hotspot(loc)
+	qdel(src)
+
+/obj/machinery/am_shielding/proc/collapse()
+	visible_message("<span class='notice'>[src] collapses back into a container!</span>")
+	new /obj/item/am_shielding_container(drop_location())
+	qdel(src)
+
+/obj/machinery/am_shielding/proc/controllerscan(priorscan = 0)
+	//Make sure we are the only one here
+	if(!isturf(loc))
+		collapse()
+	for(var/obj/machinery/am_shielding/AMS in loc.contents)
+		if(AMS == src)
+			continue
+		collapse()
+		return
+
+	//Search for shielding first
+	for(var/obj/machinery/am_shielding/AMS in cardinalrange(src))
+		if(AMS && AMS.control_unit && link_control(AMS.control_unit))
+			break
+
+	if(!control_unit)//No other guys nearby look for a control unit
+		for(var/direction in GLOB.cardinals)
+		for(var/obj/machinery/power/am_control_unit/AMC in cardinalrange(src))
+			if(AMC.add_shielding(src))
+				break
+
+	if(!control_unit)
+		if(!priorscan)
+			addtimer(CALLBACK(src, .proc/controllerscan, 1), 20)
+			return
+		collapse()
+
+
+/obj/machinery/am_shielding/Destroy()
+	if(control_unit)
+		control_unit.remove_shielding(src)
+	if(processing)
+		shutdown_core()
+	//Might want to have it leave a mess on the floor but no sprites for now
+	return ..()
+
+
+/obj/machinery/am_shielding/CanPass(atom/movable/mover, turf/target)
+	return 0
+
+
+/obj/machinery/am_shielding/process()
+	if(!processing)
+		. = PROCESS_KILL
+	//TODO: core functions and stability
+	//TODO: think about checking the airmix for plasma and increasing power output
+	return
+
+
+/obj/machinery/am_shielding/emp_act()//Immune due to not really much in the way of electronics.
+	return
+
+/obj/machinery/am_shielding/ex_act(severity, target)
+	stability -= (80 - (severity * 20))
+	check_stability()
+	return
+
+
+/obj/machinery/am_shielding/bullet_act(obj/item/projectile/Proj)
+	. = ..()
+	if(Proj.flag != "bullet")
+		stability -= Proj.force/2
+		check_stability()
+
+
+/obj/machinery/am_shielding/update_icon()
+	dirs = 0
+	coredirs = 0
+	cut_overlays()
+	for(var/direction in GLOB.alldirs)
+		var/turf/T = get_step(loc, direction)
+		for(var/obj/machinery/machine in T)
+			if(istype(machine, /obj/machinery/am_shielding))
+				var/obj/machinery/am_shielding/shield = machine
+				if(shield.control_unit == control_unit)
+					if(shield.processing)
+						coredirs |= direction
+					if(direction in GLOB.cardinals)
+						dirs |= direction
+
+			else
+				if(istype(machine, /obj/machinery/power/am_control_unit) && (direction in GLOB.cardinals))
+					var/obj/machinery/power/am_control_unit/control = machine
+					if(control == control_unit)
+						dirs |= direction
+
+
+	var/prefix = ""
+	var/icondirs=dirs
+
+	if(coredirs)
+		prefix="core"
+
+	icon_state = "[prefix]shield_[icondirs]"
+
+	if(core_check())
+		add_overlay("core[control_unit && control_unit.active]")
+		if(!processing)
+			setup_core()
+	else if(processing)
+		shutdown_core()
+
+
+/obj/machinery/am_shielding/take_damage(damage_amount, damage_type = BRUTE, damage_flag = 0, sound_effect = 1)
+	switch(damage_type)
+		if(BRUTE)
+			if(sound_effect)
+				if(damage_amount)
+					playsound(loc, 'sound/weapons/smash.ogg', 50, 1)
+				else
+					playsound(loc, 'sound/weapons/tap.ogg', 50, 1)
+		if(BURN)
+			if(sound_effect)
+				playsound(src.loc, 'sound/items/welder.ogg', 100, 1)
+		else
+			return
+	if(damage_amount >= 10)
+		stability -= damage_amount/2
+		check_stability()
+
+
+//Call this to link a detected shilding unit to the controller
+/obj/machinery/am_shielding/proc/link_control(obj/machinery/power/am_control_unit/AMC)
+	if(!istype(AMC))
+		return 0
+	if(control_unit && control_unit != AMC)
+		return 0//Already have one
+	control_unit = AMC
+	control_unit.add_shielding(src,1)
+	return 1
+
+
+//Scans cards for shields or the control unit and if all there it
+/obj/machinery/am_shielding/proc/core_check()
+	for(var/direction in GLOB.alldirs)
+		var/found_am_device=0
+		for(var/obj/machinery/machine in get_step(loc, direction))
+			if(!machine)
+				continue//Need all for a core
+			if(istype(machine, /obj/machinery/am_shielding) || istype(machine, /obj/machinery/power/am_control_unit))
+				found_am_device = 1
+				break
+		if(!found_am_device)
+			return 0
+	return 1
+
+
+/obj/machinery/am_shielding/proc/setup_core()
+	processing = TRUE
+	GLOB.machines |= src
+	START_PROCESSING(SSmachines, src)
+	if(!control_unit)
+		return
+	control_unit.linked_cores.Add(src)
+	control_unit.reported_core_efficiency += efficiency
+	return
+
+
+/obj/machinery/am_shielding/proc/shutdown_core()
+	processing = FALSE
+	if(!control_unit)
+		return
+	control_unit.linked_cores.Remove(src)
+	control_unit.reported_core_efficiency -= efficiency
+	return
+
+
+/obj/machinery/am_shielding/proc/check_stability(injecting_fuel = 0)
+	if(stability > 0)
+		return
+	if(injecting_fuel && control_unit)
+		control_unit.exploding = 1
+	if(src)
+		overheat()
+	return
+
+
+/obj/machinery/am_shielding/proc/recalc_efficiency(new_efficiency)//tbh still not 100% sure how I want to deal with efficiency so this is likely temp
+	if(!control_unit || !processing)
+		return
+	if(stability < 50)
+		new_efficiency /= 2
+	control_unit.reported_core_efficiency += (new_efficiency - efficiency)
+	efficiency = new_efficiency
+	return
+
+
+
+/obj/item/am_shielding_container
+	name = "packaged antimatter reactor section"
+	desc = "A small storage unit containing an antimatter reactor section.  To use place near an antimatter control unit or deployed antimatter reactor section and use a multitool to activate this package."
+	icon = 'icons/obj/machines/antimatter.dmi'
+	icon_state = "box"
+	item_state = "electronic"
+	lefthand_file = 'icons/mob/inhands/misc/devices_lefthand.dmi'
+	righthand_file = 'icons/mob/inhands/misc/devices_righthand.dmi'
+	w_class = WEIGHT_CLASS_BULKY
+	flags_1 = CONDUCT_1
+	throwforce = 5
+	throw_speed = 1
+	throw_range = 2
+	materials = list(MAT_METAL=100)
+
+/obj/item/am_shielding_container/attackby(obj/item/I, mob/user, params)
+	if(istype(I, /obj/item/multitool) && istype(src.loc, /turf))
+		new/obj/machinery/am_shielding(src.loc)
+		qdel(src)
+	else
+		return ..()

code/modules/power/cable.dm

@@ -0,0 +1,851 @@
+GLOBAL_LIST_INIT(cable_colors, list(
+	"yellow" = "#ffff00",
+	"green" = "#00aa00",
+	"blue" = "#1919c8",
+	"pink" = "#ff3cc8",
+	"orange" = "#ff8000",
+	"cyan" = "#00ffff",
+	"white" = "#ffffff",
+	"red" = "#ff0000"
+	))
+
+///////////////////////////////
+//CABLE STRUCTURE
+///////////////////////////////
+
+
+////////////////////////////////
+// Definitions
+////////////////////////////////
+
+/* Cable directions (d1 and d2)
+
+
+  9   1   5
+	\ | /
+  8 - 0 - 4
+	/ | \
+  10  2   6
+
+If d1 = 0 and d2 = 0, there's no cable
+If d1 = 0 and d2 = dir, it's a O-X cable, getting from the center of the tile to dir (knot cable)
+If d1 = dir1 and d2 = dir2, it's a full X-X cable, getting from dir1 to dir2
+By design, d1 is the smallest direction and d2 is the highest
+*/
+
+/obj/structure/cable
+	name = "power cable"
+	desc = "A flexible, superconducting insulated cable for heavy-duty power transfer."
+	icon = 'icons/obj/power_cond/cables.dmi'
+	icon_state = "0-1"
+	level = 1 //is underfloor
+	layer = WIRE_LAYER //Above hidden pipes, GAS_PIPE_HIDDEN_LAYER
+	anchored = TRUE
+	obj_flags = CAN_BE_HIT | ON_BLUEPRINTS
+	var/d1 = 0   // cable direction 1 (see above)
+	var/d2 = 1   // cable direction 2 (see above)
+	var/datum/powernet/powernet
+	var/obj/item/stack/cable_coil/stored
+
+	var/cable_color = "red"
+	color = "#ff0000"
+
+/obj/structure/cable/yellow
+	cable_color = "yellow"
+	color = "#ffff00"
+
+/obj/structure/cable/green
+	cable_color = "green"
+	color = "#00aa00"
+
+/obj/structure/cable/blue
+	cable_color = "blue"
+	color = "#1919c8"
+
+/obj/structure/cable/pink
+	cable_color = "pink"
+	color = "#ff3cc8"
+
+/obj/structure/cable/orange
+	cable_color = "orange"
+	color = "#ff8000"
+
+/obj/structure/cable/cyan
+	cable_color = "cyan"
+	color = "#00ffff"
+
+/obj/structure/cable/white
+	cable_color = "white"
+	color = "#ffffff"
+
+// the power cable object
+/obj/structure/cable/Initialize(mapload, param_color)
+	. = ..()
+
+	// ensure d1 & d2 reflect the icon_state for entering and exiting cable
+	var/dash = findtext(icon_state, "-")
+	d1 = text2num( copytext( icon_state, 1, dash ) )
+	d2 = text2num( copytext( icon_state, dash+1 ) )
+
+	var/turf/T = get_turf(src)			// hide if turf is not intact
+	if(level==1)
+		hide(T.intact)
+	GLOB.cable_list += src //add it to the global cable list
+
+	if(d1)
+		stored = new/obj/item/stack/cable_coil(null,2,cable_color)
+	else
+		stored = new/obj/item/stack/cable_coil(null,1,cable_color)
+
+	var/list/cable_colors = GLOB.cable_colors
+	cable_color = param_color || cable_color || pick(cable_colors)
+	if(cable_colors[cable_color])
+		cable_color = cable_colors[cable_color]
+	update_icon()
+
+/obj/structure/cable/Destroy()					// called when a cable is deleted
+	if(powernet)
+		cut_cable_from_powernet()				// update the powernets
+	GLOB.cable_list -= src							//remove it from global cable list
+	return ..()									// then go ahead and delete the cable
+
+/obj/structure/cable/deconstruct(disassembled = TRUE)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		var/turf/T = loc
+		stored.forceMove(T)
+	qdel(src)
+
+///////////////////////////////////
+// General procedures
+///////////////////////////////////
+
+//If underfloor, hide the cable
+/obj/structure/cable/hide(i)
+
+	if(level == 1 && isturf(loc))
+		invisibility = i ? INVISIBILITY_MAXIMUM : 0
+	update_icon()
+
+/obj/structure/cable/update_icon()
+	icon_state = "[d1]-[d2]"
+	color = null
+	add_atom_colour(cable_color, FIXED_COLOUR_PRIORITY)
+
+/obj/structure/cable/proc/handlecable(obj/item/W, mob/user, params)
+	var/turf/T = get_turf(src)
+	if(T.intact)
+		return
+	if(istype(W, /obj/item/wirecutters))
+		if (shock(user, 50))
+			return
+		user.visible_message("[user] cuts the cable.", "<span class='notice'>You cut the cable.</span>")
+		stored.add_fingerprint(user)
+		investigate_log("was cut by [key_name(usr)] in [AREACOORD(src)]", INVESTIGATE_WIRES)
+		deconstruct()
+		return
+
+	else if(istype(W, /obj/item/stack/cable_coil))
+		var/obj/item/stack/cable_coil/coil = W
+		if (coil.get_amount() < 1)
+			to_chat(user, "<span class='warning'>Not enough cable!</span>")
+			return
+		coil.cable_join(src, user)
+
+	else if(istype(W, /obj/item/twohanded/rcl))
+		var/obj/item/twohanded/rcl/R = W
+		if(R.loaded)
+			R.loaded.cable_join(src, user)
+			R.is_empty(user)
+
+	else if(istype(W, /obj/item/multitool))
+		if(powernet && (powernet.avail > 0))		// is it powered?
+			to_chat(user, "<span class='danger'>[DisplayPower(powernet.avail)] in power network.</span>")
+		else
+			to_chat(user, "<span class='danger'>The cable is not powered.</span>")
+		shock(user, 5, 0.2)
+
+	src.add_fingerprint(user)
+
+// Items usable on a cable :
+//   - Wirecutters : cut it duh !
+//   - Cable coil : merge cables
+//   - Multitool : get the power currently passing through the cable
+//
+/obj/structure/cable/attackby(obj/item/W, mob/user, params)
+	handlecable(W, user, params)
+
+
+// shock the user with probability prb
+/obj/structure/cable/proc/shock(mob/user, prb, siemens_coeff = 1)
+	if(!prob(prb))
+		return 0
+	if (electrocute_mob(user, powernet, src, siemens_coeff))
+		do_sparks(5, TRUE, src)
+		return 1
+	else
+		return 0
+
+/obj/structure/cable/singularity_pull(S, current_size)
+	..()
+	if(current_size >= STAGE_FIVE)
+		deconstruct()
+
+/obj/structure/cable/proc/update_stored(length = 1, colorC = "red")
+	stored.amount = length
+	stored.item_color = colorC
+	stored.update_icon()
+
+////////////////////////////////////////////
+// Power related
+///////////////////////////////////////////
+
+// All power generation handled in add_avail()
+// Machines should use add_load(), surplus(), avail()
+// Non-machines should use add_delayedload(), delayed_surplus(), newavail()
+
+/obj/structure/cable/proc/add_avail(amount)
+	if(powernet)
+		powernet.newavail += amount
+
+/obj/structure/cable/proc/add_load(amount)
+	if(powernet)
+		powernet.load += amount
+
+/obj/structure/cable/proc/surplus()
+	if(powernet)
+		return CLAMP(powernet.avail-powernet.load, 0, powernet.avail)
+	else
+		return 0
+
+/obj/structure/cable/proc/avail()
+	if(powernet)
+		return powernet.avail
+	else
+		return 0
+
+/obj/structure/cable/proc/add_delayedload(amount)
+	if(powernet)
+		powernet.delayedload += amount
+
+/obj/structure/cable/proc/delayed_surplus()
+	if(powernet)
+		return CLAMP(powernet.newavail - powernet.delayedload, 0, powernet.newavail)
+	else
+		return 0
+
+/obj/structure/cable/proc/newavail()
+	if(powernet)
+		return powernet.newavail
+	else
+		return 0
+
+/////////////////////////////////////////////////
+// Cable laying helpers
+////////////////////////////////////////////////
+
+//handles merging diagonally matching cables
+//for info : direction^3 is flipping horizontally, direction^12 is flipping vertically
+/obj/structure/cable/proc/mergeDiagonalsNetworks(direction)
+
+	//search for and merge diagonally matching cables from the first direction component (north/south)
+	var/turf/T  = get_step(src, direction&3)//go north/south
+
+	for(var/obj/structure/cable/C in T)
+
+		if(!C)
+			continue
+
+		if(src == C)
+			continue
+
+		if(C.d1 == (direction^3) || C.d2 == (direction^3)) //we've got a diagonally matching cable
+			if(!C.powernet) //if the matching cable somehow got no powernet, make him one (should not happen for cables)
+				var/datum/powernet/newPN = new()
+				newPN.add_cable(C)
+
+			if(powernet) //if we already have a powernet, then merge the two powernets
+				merge_powernets(powernet,C.powernet)
+			else
+				C.powernet.add_cable(src) //else, we simply connect to the matching cable powernet
+
+	//the same from the second direction component (east/west)
+	T  = get_step(src, direction&12)//go east/west
+
+	for(var/obj/structure/cable/C in T)
+
+		if(!C)
+			continue
+
+		if(src == C)
+			continue
+		if(C.d1 == (direction^12) || C.d2 == (direction^12)) //we've got a diagonally matching cable
+			if(!C.powernet) //if the matching cable somehow got no powernet, make him one (should not happen for cables)
+				var/datum/powernet/newPN = new()
+				newPN.add_cable(C)
+
+			if(powernet) //if we already have a powernet, then merge the two powernets
+				merge_powernets(powernet,C.powernet)
+			else
+				C.powernet.add_cable(src) //else, we simply connect to the matching cable powernet
+
+// merge with the powernets of power objects in the given direction
+/obj/structure/cable/proc/mergeConnectedNetworks(direction)
+
+	var/fdir = (!direction)? 0 : turn(direction, 180) //flip the direction, to match with the source position on its turf
+
+	if(!(d1 == direction || d2 == direction)) //if the cable is not pointed in this direction, do nothing
+		return
+
+	var/turf/TB  = get_step(src, direction)
+
+	for(var/obj/structure/cable/C in TB)
+
+		if(!C)
+			continue
+
+		if(src == C)
+			continue
+
+		if(C.d1 == fdir || C.d2 == fdir) //we've got a matching cable in the neighbor turf
+			if(!C.powernet) //if the matching cable somehow got no powernet, make him one (should not happen for cables)
+				var/datum/powernet/newPN = new()
+				newPN.add_cable(C)
+
+			if(powernet) //if we already have a powernet, then merge the two powernets
+				merge_powernets(powernet,C.powernet)
+			else
+				C.powernet.add_cable(src) //else, we simply connect to the matching cable powernet
+
+// merge with the powernets of power objects in the source turf
+/obj/structure/cable/proc/mergeConnectedNetworksOnTurf()
+	var/list/to_connect = list()
+
+	if(!powernet) //if we somehow have no powernet, make one (should not happen for cables)
+		var/datum/powernet/newPN = new()
+		newPN.add_cable(src)
+
+	//first let's add turf cables to our powernet
+	//then we'll connect machines on turf with a node cable is present
+	for(var/AM in loc)
+		if(istype(AM, /obj/structure/cable))
+			var/obj/structure/cable/C = AM
+			if(C.d1 == d1 || C.d2 == d1 || C.d1 == d2 || C.d2 == d2) //only connected if they have a common direction
+				if(C.powernet == powernet)
+					continue
+				if(C.powernet)
+					merge_powernets(powernet, C.powernet)
+				else
+					powernet.add_cable(C) //the cable was powernetless, let's just add it to our powernet
+
+		else if(istype(AM, /obj/machinery/power/apc))
+			var/obj/machinery/power/apc/N = AM
+			if(!N.terminal)
+				continue // APC are connected through their terminal
+
+			if(N.terminal.powernet == powernet)
+				continue
+
+			to_connect += N.terminal //we'll connect the machines after all cables are merged
+
+		else if(istype(AM, /obj/machinery/power)) //other power machines
+			var/obj/machinery/power/M = AM
+
+			if(M.powernet == powernet)
+				continue
+
+			to_connect += M //we'll connect the machines after all cables are merged
+
+	//now that cables are done, let's connect found machines
+	for(var/obj/machinery/power/PM in to_connect)
+		if(!PM.connect_to_network())
+			PM.disconnect_from_network() //if we somehow can't connect the machine to the new powernet, remove it from the old nonetheless
+
+//////////////////////////////////////////////
+// Powernets handling helpers
+//////////////////////////////////////////////
+
+//if powernetless_only = 1, will only get connections without powernet
+/obj/structure/cable/proc/get_connections(powernetless_only = 0)
+	. = list()	// this will be a list of all connected power objects
+	var/turf/T
+
+	//get matching cables from the first direction
+	if(d1) //if not a node cable
+		T = get_step(src, d1)
+		if(T)
+			. += power_list(T, src, turn(d1, 180), powernetless_only) //get adjacents matching cables
+
+	if(d1&(d1-1)) //diagonal direction, must check the 4 possibles adjacents tiles
+		T = get_step(src,d1&3) // go north/south
+		if(T)
+			. += power_list(T, src, d1 ^ 3, powernetless_only) //get diagonally matching cables
+		T = get_step(src,d1&12) // go east/west
+		if(T)
+			. += power_list(T, src, d1 ^ 12, powernetless_only) //get diagonally matching cables
+
+	. += power_list(loc, src, d1, powernetless_only) //get on turf matching cables
+
+	//do the same on the second direction (which can't be 0)
+	T = get_step(src, d2)
+	if(T)
+		. += power_list(T, src, turn(d2, 180), powernetless_only) //get adjacents matching cables
+
+	if(d2&(d2-1)) //diagonal direction, must check the 4 possibles adjacents tiles
+		T = get_step(src,d2&3) // go north/south
+		if(T)
+			. += power_list(T, src, d2 ^ 3, powernetless_only) //get diagonally matching cables
+		T = get_step(src,d2&12) // go east/west
+		if(T)
+			. += power_list(T, src, d2 ^ 12, powernetless_only) //get diagonally matching cables
+	. += power_list(loc, src, d2, powernetless_only) //get on turf matching cables
+
+	return .
+
+//should be called after placing a cable which extends another cable, creating a "smooth" cable that no longer terminates in the centre of a turf.
+//needed as this can, unlike other placements, disconnect cables
+/obj/structure/cable/proc/denode()
+	var/turf/T1 = loc
+	if(!T1)
+		return
+
+	var/list/powerlist = power_list(T1,src,0,0) //find the other cables that ended in the centre of the turf, with or without a powernet
+	if(powerlist.len>0)
+		var/datum/powernet/PN = new()
+		propagate_network(powerlist[1],PN) //propagates the new powernet beginning at the source cable
+
+		if(PN.is_empty()) //can happen with machines made nodeless when smoothing cables
+			qdel(PN)
+
+/obj/structure/cable/proc/auto_propogate_cut_cable(obj/O)
+	if(O && !QDELETED(O))
+		var/datum/powernet/newPN = new()// creates a new powernet...
+		propagate_network(O, newPN)//... and propagates it to the other side of the cable
+
+// cut the cable's powernet at this cable and updates the powergrid
+/obj/structure/cable/proc/cut_cable_from_powernet(remove=TRUE)
+	var/turf/T1 = loc
+	var/list/P_list
+	if(!T1)
+		return
+	if(d1)
+		T1 = get_step(T1, d1)
+		P_list = power_list(T1, src, turn(d1,180),0,cable_only = 1)	// what adjacently joins on to cut cable...
+
+	P_list += power_list(loc, src, d1, 0, cable_only = 1)//... and on turf
+
+
+	if(P_list.len == 0)//if nothing in both list, then the cable was a lone cable, just delete it and its powernet
+		powernet.remove_cable(src)
+
+		for(var/obj/machinery/power/P in T1)//check if it was powering a machine
+			if(!P.connect_to_network()) //can't find a node cable on a the turf to connect to
+				P.disconnect_from_network() //remove from current network (and delete powernet)
+		return
+
+	var/obj/O = P_list[1]
+	// remove the cut cable from its turf and powernet, so that it doesn't get count in propagate_network worklist
+	if(remove)
+		moveToNullspace()
+	powernet.remove_cable(src) //remove the cut cable from its powernet
+
+	addtimer(CALLBACK(O, .proc/auto_propogate_cut_cable, O), 0) //so we don't rebuild the network X times when singulo/explosion destroys a line of X cables
+
+	// Disconnect machines connected to nodes
+	if(d1 == 0) // if we cut a node (O-X) cable
+		for(var/obj/machinery/power/P in T1)
+			if(!P.connect_to_network()) //can't find a node cable on a the turf to connect to
+				P.disconnect_from_network() //remove from current network
+
+
+///////////////////////////////////////////////
+// The cable coil object, used for laying cable
+///////////////////////////////////////////////
+
+////////////////////////////////
+// Definitions
+////////////////////////////////
+
+GLOBAL_LIST_INIT(cable_coil_recipes, list (new/datum/stack_recipe("cable restraints", /obj/item/restraints/handcuffs/cable, 15)))
+
+/obj/item/stack/cable_coil
+	name = "cable coil"
+	gender = NEUTER //That's a cable coil sounds better than that's some cable coils
+	icon = 'icons/obj/power.dmi'
+	icon_state = "coil"
+	item_state = "coil"
+	lefthand_file = 'icons/mob/inhands/equipment/tools_lefthand.dmi'
+	righthand_file = 'icons/mob/inhands/equipment/tools_righthand.dmi'
+	max_amount = MAXCOIL
+	amount = MAXCOIL
+	merge_type = /obj/item/stack/cable_coil // This is here to let its children merge between themselves
+	item_color = "red"
+	desc = "A coil of insulated power cable."
+	throwforce = 0
+	w_class = WEIGHT_CLASS_SMALL
+	throw_speed = 3
+	throw_range = 5
+	materials = list(MAT_METAL=10, MAT_GLASS=5)
+	flags_1 = CONDUCT_1
+	slot_flags = ITEM_SLOT_BELT
+	attack_verb = list("whipped", "lashed", "disciplined", "flogged")
+	singular_name = "cable piece"
+	full_w_class = WEIGHT_CLASS_SMALL
+	grind_results = list("copper" = 2) //2 copper per cable in the coil
+	usesound = 'sound/items/deconstruct.ogg'
+
+/obj/item/stack/cable_coil/cyborg
+	is_cyborg = 1
+	materials = list()
+	cost = 1
+
+/obj/item/stack/cable_coil/cyborg/attack_self(mob/user)
+	var/cable_color = input(user,"Pick a cable color.","Cable Color") in list("red","yellow","green","blue","pink","orange","cyan","white")
+	item_color = cable_color
+	update_icon()
+
+/obj/item/stack/cable_coil/suicide_act(mob/user)
+	if(locate(/obj/structure/chair/stool) in get_turf(user))
+		user.visible_message("<span class='suicide'>[user] is making a noose with [src]! It looks like [user.p_theyre()] trying to commit suicide!</span>")
+	else
+		user.visible_message("<span class='suicide'>[user] is strangling [user.p_them()]self with [src]! It looks like [user.p_theyre()] trying to commit suicide!</span>")
+	return(OXYLOSS)
+
+/obj/item/stack/cable_coil/Initialize(mapload, new_amount = null, param_color = null)
+	. = ..()
+
+	var/list/cable_colors = GLOB.cable_colors
+	item_color = param_color || item_color || pick(cable_colors)
+	if(cable_colors[item_color])
+		item_color = cable_colors[item_color]
+
+	pixel_x = rand(-2,2)
+	pixel_y = rand(-2,2)
+	update_icon()
+	recipes = GLOB.cable_coil_recipes
+
+///////////////////////////////////
+// General procedures
+///////////////////////////////////
+
+
+//you can use wires to heal robotics
+/obj/item/stack/cable_coil/attack(mob/living/carbon/human/H, mob/user)
+	if(!istype(H))
+		return ..()
+
+	var/obj/item/bodypart/affecting = H.get_bodypart(check_zone(user.zone_selected))
+	if(affecting && affecting.status == BODYPART_ROBOTIC)
+		if(user == H)
+			user.visible_message("<span class='notice'>[user] starts to fix some of the wires in [H]'s [affecting.name].</span>", "<span class='notice'>You start fixing some of the wires in [H]'s [affecting.name].</span>")
+			if(!do_mob(user, H, 50))
+				return
+		if(item_heal_robotic(H, user, 0, 15))
+			use(1)
+		return
+	else
+		return ..()
+
+
+/obj/item/stack/cable_coil/update_icon()
+	icon_state = "[initial(item_state)][amount < 3 ? amount : ""]"
+	name = "cable [amount < 3 ? "piece" : "coil"]"
+	color = null
+	add_atom_colour(item_color, FIXED_COLOUR_PRIORITY)
+
+/obj/item/stack/cable_coil/attack_hand(mob/user)
+	. = ..()
+	if(.)
+		return
+	var/obj/item/stack/cable_coil/new_cable = ..()
+	if(istype(new_cable))
+		new_cable.item_color = item_color
+		new_cable.update_icon()
+
+//add cables to the stack
+/obj/item/stack/cable_coil/proc/give(extra)
+	if(amount + extra > max_amount)
+		amount = max_amount
+	else
+		amount += extra
+	update_icon()
+
+
+
+///////////////////////////////////////////////
+// Cable laying procedures
+//////////////////////////////////////////////
+
+/obj/item/stack/cable_coil/proc/get_new_cable(location)
+	var/path = /obj/structure/cable
+	return new path(location, item_color)
+
+// called when cable_coil is clicked on a turf
+/obj/item/stack/cable_coil/proc/place_turf(turf/T, mob/user, dirnew)
+	if(!isturf(user.loc))
+		return
+
+	if(!isturf(T) || T.intact || !T.can_have_cabling())
+		to_chat(user, "<span class='warning'>You can only lay cables on catwalks and plating!</span>")
+		return
+
+	if(get_amount() < 1) // Out of cable
+		to_chat(user, "<span class='warning'>There is no cable left!</span>")
+		return
+
+	if(get_dist(T,user) > 1) // Too far
+		to_chat(user, "<span class='warning'>You can't lay cable at a place that far away!</span>")
+		return
+
+	var/dirn
+	if(!dirnew) //If we weren't given a direction, come up with one! (Called as null from catwalk.dm and floor.dm)
+		if(user.loc == T)
+			dirn = user.dir //If laying on the tile we're on, lay in the direction we're facing
+		else
+			dirn = get_dir(T, user)
+	else
+		dirn = dirnew
+
+	for(var/obj/structure/cable/LC in T)
+		if(LC.d2 == dirn && LC.d1 == 0)
+			to_chat(user, "<span class='warning'>There's already a cable at that position!</span>")
+			return
+
+	var/obj/structure/cable/C = get_new_cable(T)
+
+	//set up the new cable
+	C.d1 = 0 //it's a O-X node cable
+	C.d2 = dirn
+	C.add_fingerprint(user)
+	C.update_icon()
+
+	//create a new powernet with the cable, if needed it will be merged later
+	var/datum/powernet/PN = new()
+	PN.add_cable(C)
+
+	C.mergeConnectedNetworks(C.d2) //merge the powernet with adjacents powernets
+	C.mergeConnectedNetworksOnTurf() //merge the powernet with on turf powernets
+
+	if(C.d2 & (C.d2 - 1))// if the cable is layed diagonally, check the others 2 possible directions
+		C.mergeDiagonalsNetworks(C.d2)
+
+	use(1)
+
+	if(C.shock(user, 50))
+		if(prob(50)) //fail
+			new /obj/item/stack/cable_coil(get_turf(C), 1, C.color)
+			C.deconstruct()
+
+	return C
+
+// called when cable_coil is click on an installed obj/cable
+// or click on a turf that already contains a "node" cable
+/obj/item/stack/cable_coil/proc/cable_join(obj/structure/cable/C, mob/user, showerror = TRUE, forceddir)
+	var/turf/U = user.loc
+	if(!isturf(U))
+		return
+
+	var/turf/T = C.loc
+
+	if(!isturf(T) || T.intact)		// sanity checks, also stop use interacting with T-scanner revealed cable
+		return
+
+	if(get_dist(C, user) > 1)		// make sure it's close enough
+		to_chat(user, "<span class='warning'>You can't lay cable at a place that far away!</span>")
+		return
+
+
+	if(U == T && !forceddir) //if clicked on the turf we're standing on and a direction wasn't supplied, try to put a cable in the direction we're facing
+		place_turf(T,user)
+		return
+
+	var/dirn = get_dir(C, user)
+
+	// one end of the clicked cable is pointing towards us and no direction was supplied
+	if((C.d1 == dirn || C.d2 == dirn) && !forceddir)
+		if(!U.can_have_cabling())						//checking if it's a plating or catwalk
+			if (showerror)
+				to_chat(user, "<span class='warning'>You can only lay cables on catwalks and plating!</span>")
+			return
+		if(U.intact)						//can't place a cable if it's a plating with a tile on it
+			to_chat(user, "<span class='warning'>You can't lay cable there unless the floor tiles are removed!</span>")
+			return
+		else
+			// cable is pointing at us, we're standing on an open tile
+			// so create a stub pointing at the clicked cable on our tile
+
+			var/fdirn = turn(dirn, 180)		// the opposite direction
+
+			for(var/obj/structure/cable/LC in U)		// check to make sure there's not a cable there already
+				if(LC.d1 == fdirn || LC.d2 == fdirn)
+					if (showerror)
+						to_chat(user, "<span class='warning'>There's already a cable at that position!</span>")
+					return
+
+			var/obj/structure/cable/NC = get_new_cable (U)
+
+			NC.d1 = 0
+			NC.d2 = fdirn
+			NC.add_fingerprint(user)
+			NC.update_icon()
+
+			//create a new powernet with the cable, if needed it will be merged later
+			var/datum/powernet/newPN = new()
+			newPN.add_cable(NC)
+
+			NC.mergeConnectedNetworks(NC.d2) //merge the powernet with adjacents powernets
+			NC.mergeConnectedNetworksOnTurf() //merge the powernet with on turf powernets
+
+			if(NC.d2 & (NC.d2 - 1))// if the cable is layed diagonally, check the others 2 possible directions
+				NC.mergeDiagonalsNetworks(NC.d2)
+
+			use(1)
+
+			if (NC.shock(user, 50))
+				if (prob(50)) //fail
+					NC.deconstruct()
+
+			return
+
+	// exisiting cable doesn't point at our position or we have a supplied direction, so see if it's a stub
+	else if(C.d1 == 0)
+							// if so, make it a full cable pointing from it's old direction to our dirn
+		var/nd1 = C.d2	// these will be the new directions
+		var/nd2 = dirn
+
+
+		if(nd1 > nd2)		// swap directions to match icons/states
+			nd1 = dirn
+			nd2 = C.d2
+
+
+		for(var/obj/structure/cable/LC in T)		// check to make sure there's no matching cable
+			if(LC == C)			// skip the cable we're interacting with
+				continue
+			if((LC.d1 == nd1 && LC.d2 == nd2) || (LC.d1 == nd2 && LC.d2 == nd1) )	// make sure no cable matches either direction
+				if (showerror)
+					to_chat(user, "<span class='warning'>There's already a cable at that position!</span>")
+
+				return
+
+
+		C.update_icon()
+
+		C.d1 = nd1
+		C.d2 = nd2
+
+		//updates the stored cable coil
+		C.update_stored(2, item_color)
+
+		C.add_fingerprint(user)
+		C.update_icon()
+
+
+		C.mergeConnectedNetworks(C.d1) //merge the powernets...
+		C.mergeConnectedNetworks(C.d2) //...in the two new cable directions
+		C.mergeConnectedNetworksOnTurf()
+
+		if(C.d1 & (C.d1 - 1))// if the cable is layed diagonally, check the others 2 possible directions
+			C.mergeDiagonalsNetworks(C.d1)
+
+		if(C.d2 & (C.d2 - 1))// if the cable is layed diagonally, check the others 2 possible directions
+			C.mergeDiagonalsNetworks(C.d2)
+
+		use(1)
+
+		if (C.shock(user, 50))
+			if (prob(50)) //fail
+				C.deconstruct()
+				return
+
+		C.denode()// this call may have disconnected some cables that terminated on the centre of the turf, if so split the powernets.
+		return
+
+//////////////////////////////
+// Misc.
+/////////////////////////////
+
+/obj/item/stack/cable_coil/red
+	item_color = "red"
+	color = "#ff0000"
+
+/obj/item/stack/cable_coil/yellow
+	item_color = "yellow"
+	color = "#ffff00"
+
+/obj/item/stack/cable_coil/blue
+	item_color = "blue"
+	color = "#1919c8"
+
+/obj/item/stack/cable_coil/green
+	item_color = "green"
+	color = "#00aa00"
+
+/obj/item/stack/cable_coil/pink
+	item_color = "pink"
+	color = "#ff3ccd"
+
+/obj/item/stack/cable_coil/orange
+	item_color = "orange"
+	color = "#ff8000"
+
+/obj/item/stack/cable_coil/cyan
+	item_color = "cyan"
+	color = "#00ffff"
+
+/obj/item/stack/cable_coil/white
+	item_color = "white"
+
+/obj/item/stack/cable_coil/random
+	item_color = null
+	color = "#ffffff"
+
+
+/obj/item/stack/cable_coil/random/five
+	amount = 5
+
+/obj/item/stack/cable_coil/cut
+	amount = null
+	icon_state = "coil2"
+
+/obj/item/stack/cable_coil/cut/Initialize(mapload)
+	. = ..()
+	if(!amount)
+		amount = rand(1,2)
+	pixel_x = rand(-2,2)
+	pixel_y = rand(-2,2)
+	update_icon()
+
+/obj/item/stack/cable_coil/cut/red
+	item_color = "red"
+	color = "#ff0000"
+
+/obj/item/stack/cable_coil/cut/yellow
+	item_color = "yellow"
+	color = "#ffff00"
+
+/obj/item/stack/cable_coil/cut/blue
+	item_color = "blue"
+	color = "#1919c8"
+
+/obj/item/stack/cable_coil/cut/green
+	item_color = "green"
+	color = "#00aa00"
+
+/obj/item/stack/cable_coil/cut/pink
+	item_color = "pink"
+	color = "#ff3ccd"
+
+/obj/item/stack/cable_coil/cut/orange
+	item_color = "orange"
+	color = "#ff8000"
+
+/obj/item/stack/cable_coil/cut/cyan
+	item_color = "cyan"
+	color = "#00ffff"
+
+/obj/item/stack/cable_coil/cut/white
+	item_color = "white"
+
+/obj/item/stack/cable_coil/cut/random
+	item_color = null
+	color = "#ffffff"

code/modules/power/cell.dm

@@ -0,0 +1,361 @@
+/obj/item/stock_parts/cell
+	name = "power cell"
+	desc = "A rechargeable electrochemical power cell."
+	icon = 'icons/obj/power.dmi'
+	icon_state = "cell"
+	item_state = "cell"
+	lefthand_file = 'icons/mob/inhands/misc/devices_lefthand.dmi'
+	righthand_file = 'icons/mob/inhands/misc/devices_righthand.dmi'
+	force = 5
+	throwforce = 5
+	throw_speed = 2
+	throw_range = 5
+	w_class = WEIGHT_CLASS_SMALL
+	var/charge = 0	// note %age conveted to actual charge in New
+	var/maxcharge = 1000
+	materials = list(MAT_METAL=700, MAT_GLASS=50)
+	grind_results = list("lithium" = 15, "iron" = 5, "silicon" = 5)
+	var/rigged = FALSE	// true if rigged to explode
+	var/chargerate = 100 //how much power is given every tick in a recharger
+	var/self_recharge = 0 //does it self recharge, over time, or not?
+	var/ratingdesc = TRUE
+	var/grown_battery = FALSE // If it's a grown that acts as a battery, add a wire overlay to it.
+
+/obj/item/stock_parts/cell/get_cell()
+	return src
+
+/obj/item/stock_parts/cell/Initialize(mapload, override_maxcharge)
+	. = ..()
+	if(self_recharge)
+		START_PROCESSING(SSobj, src)
+	create_reagents(5, INJECTABLE | DRAINABLE)
+	if (override_maxcharge)
+		maxcharge = override_maxcharge
+	charge = maxcharge
+	if(ratingdesc)
+		desc += " This one has a rating of [DisplayEnergy(maxcharge)], and you should not swallow it."
+	update_icon()
+
+/obj/item/stock_parts/cell/Destroy()
+	STOP_PROCESSING(SSobj, src)
+	return ..()
+
+/obj/item/stock_parts/cell/vv_edit_var(var_name, var_value)
+	switch(var_name)
+		if("self_recharge")
+			if(var_value)
+				START_PROCESSING(SSobj, src)
+			else
+				STOP_PROCESSING(SSobj, src)
+	. = ..()
+
+/obj/item/stock_parts/cell/process()
+	if(self_recharge)
+		give(chargerate * 0.25)
+	else
+		return PROCESS_KILL
+
+/obj/item/stock_parts/cell/update_icon()
+	cut_overlays()
+	if(grown_battery)
+		add_overlay(image('icons/obj/power.dmi',"grown_wires"))
+	if(charge < 0.01)
+		return
+	else if(charge/maxcharge >=0.995)
+		add_overlay("cell-o2")
+	else
+		add_overlay("cell-o1")
+
+/obj/item/stock_parts/cell/proc/percent()		// return % charge of cell
+	return 100*charge/maxcharge
+
+// use power from a cell
+/obj/item/stock_parts/cell/use(amount, can_explode = TRUE)
+	if(rigged && amount > 0 && can_explode)
+		explode()
+		return 0
+	if(charge < amount)
+		return 0
+	charge = (charge - amount)
+	if(!istype(loc, /obj/machinery/power/apc))
+		SSblackbox.record_feedback("tally", "cell_used", 1, type)
+	return 1
+
+// recharge the cell
+/obj/item/stock_parts/cell/proc/give(amount)
+	if(rigged && amount > 0)
+		explode()
+		return 0
+	if(maxcharge < amount)
+		amount = maxcharge
+	var/power_used = min(maxcharge-charge,amount)
+	charge += power_used
+	return power_used
+
+/obj/item/stock_parts/cell/examine(mob/user)
+	..()
+	if(rigged)
+		to_chat(user, "<span class='danger'>This power cell seems to be faulty!</span>")
+	else
+		to_chat(user, "The charge meter reads [round(src.percent() )]%.")
+
+/obj/item/stock_parts/cell/suicide_act(mob/user)
+	user.visible_message("<span class='suicide'>[user] is licking the electrodes of [src]! It looks like [user.p_theyre()] trying to commit suicide!</span>")
+	return (FIRELOSS)
+
+/obj/item/stock_parts/cell/on_reagent_change(changetype)
+	..()
+	rigged = reagents?.has_reagent("plasma", 5) ? TRUE : FALSE //has_reagent returns the reagent datum
+
+/obj/item/stock_parts/cell/proc/explode()
+	var/turf/T = get_turf(src.loc)
+	if (charge==0)
+		return
+	var/devastation_range = -1 //round(charge/11000)
+	var/heavy_impact_range = round(sqrt(charge)/60)
+	var/light_impact_range = round(sqrt(charge)/30)
+	var/flash_range = light_impact_range
+	if (light_impact_range==0)
+		rigged = FALSE
+		corrupt()
+		return
+	//explosion(T, 0, 1, 2, 2)
+	explosion(T, devastation_range, heavy_impact_range, light_impact_range, flash_range)
+	qdel(src)
+
+/obj/item/stock_parts/cell/proc/corrupt()
+	charge /= 2
+	maxcharge = max(maxcharge/2, chargerate)
+	if (prob(10))
+		rigged = TRUE //broken batterys are dangerous
+
+/obj/item/stock_parts/cell/emp_act(severity)
+	. = ..()
+	if(. & EMP_PROTECT_SELF)
+		return
+	charge -= 1000 / severity
+	if (charge < 0)
+		charge = 0
+
+/obj/item/stock_parts/cell/ex_act(severity, target)
+	..()
+	if(!QDELETED(src))
+		switch(severity)
+			if(2)
+				if(prob(50))
+					corrupt()
+			if(3)
+				if(prob(25))
+					corrupt()
+
+
+/obj/item/stock_parts/cell/blob_act(obj/structure/blob/B)
+	ex_act(EXPLODE_DEVASTATE)
+
+/obj/item/stock_parts/cell/proc/get_electrocute_damage()
+	if(charge >= 1000)
+		return CLAMP(round(charge/10000), 10, 90) + rand(-5,5)
+	else
+		return 0
+
+/obj/item/stock_parts/cell/get_part_rating()
+	return rating * maxcharge
+
+/* Cell variants*/
+/obj/item/stock_parts/cell/empty/Initialize()
+	. = ..()
+	charge = 0
+
+/obj/item/stock_parts/cell/crap
+	name = "\improper Nanotrasen brand rechargeable AA battery"
+	desc = "You can't top the plasma top." //TOTALLY TRADEMARK INFRINGEMENT
+	maxcharge = 500
+	materials = list(MAT_GLASS=40)
+
+/obj/item/stock_parts/cell/crap/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/upgraded
+	name = "upgraded power cell"
+	desc = "A power cell with a slightly higher capacity than normal!"
+	maxcharge = 2500
+	materials = list(MAT_GLASS=50)
+	chargerate = 1000
+
+/obj/item/stock_parts/cell/upgraded/plus
+	name = "upgraded power cell+"
+	desc = "A power cell with an even higher capacity than the base model!"
+	maxcharge = 5000
+
+/obj/item/stock_parts/cell/secborg
+	name = "security borg rechargeable D battery"
+	maxcharge = 1750	//35/17/8 disabler/laser/taser shots.
+	materials = list(MAT_GLASS=40)
+
+/obj/item/stock_parts/cell/secborg/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/lascarbine
+	name = "laser carbine power supply"
+	maxcharge = 2500
+
+/obj/item/stock_parts/cell/pulse //200 pulse shots
+	name = "pulse rifle power cell"
+	maxcharge = 40000
+	chargerate = 1500
+
+/obj/item/stock_parts/cell/pulse/carbine //25 pulse shots
+	name = "pulse carbine power cell"
+	maxcharge = 5000
+
+/obj/item/stock_parts/cell/pulse/pistol //10 pulse shots
+	name = "pulse pistol power cell"
+	maxcharge = 2000
+
+/obj/item/stock_parts/cell/high
+	name = "high-capacity power cell"
+	icon_state = "hcell"
+	maxcharge = 10000
+	materials = list(MAT_GLASS=60)
+	chargerate = 1500
+
+/obj/item/stock_parts/cell/high/plus
+	name = "high-capacity power cell+"
+	desc = "Where did these come from?"
+	icon_state = "h+cell"
+	maxcharge = 15000
+	chargerate = 2250
+
+/obj/item/stock_parts/cell/high/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/super
+	name = "super-capacity power cell"
+	icon_state = "scell"
+	maxcharge = 20000
+	materials = list(MAT_GLASS=300)
+	chargerate = 2000
+
+/obj/item/stock_parts/cell/super/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/hyper
+	name = "hyper-capacity power cell"
+	icon_state = "hpcell"
+	maxcharge = 30000
+	materials = list(MAT_GLASS=400)
+	chargerate = 3000
+
+/obj/item/stock_parts/cell/hyper/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/bluespace
+	name = "bluespace power cell"
+	desc = "A rechargeable transdimensional power cell."
+	icon_state = "bscell"
+	maxcharge = 40000
+	materials = list(MAT_GLASS=600)
+	chargerate = 4000
+
+/obj/item/stock_parts/cell/bluespace/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/infinite
+	name = "infinite-capacity power cell!"
+	icon_state = "icell"
+	maxcharge = 30000
+	materials = list(MAT_GLASS=1000)
+	rating = 100
+	chargerate = 30000
+
+/obj/item/stock_parts/cell/infinite/use()
+	return 1
+
+/obj/item/stock_parts/cell/infinite/abductor
+	name = "void core"
+	desc = "An alien power cell that produces energy seemingly out of nowhere."
+	icon = 'icons/obj/abductor.dmi'
+	icon_state = "cell"
+	maxcharge = 50000
+	ratingdesc = FALSE
+
+/obj/item/stock_parts/cell/infinite/abductor/update_icon()
+	return
+
+
+/obj/item/stock_parts/cell/potato
+	name = "potato battery"
+	desc = "A rechargeable starch based power cell."
+	icon = 'icons/obj/hydroponics/harvest.dmi'
+	icon_state = "potato"
+	charge = 100
+	maxcharge = 300
+	materials = list()
+	grown_battery = TRUE //it has the overlays for wires
+
+/obj/item/stock_parts/cell/high/slime
+	name = "charged slime core"
+	desc = "A yellow slime core infused with plasma, it crackles with power."
+	icon = 'icons/mob/slimes.dmi'
+	icon_state = "yellow slime extract"
+	materials = list()
+	rating = 5 //self-recharge makes these desirable
+	self_recharge = 1 // Infused slime cores self-recharge, over time
+
+/obj/item/stock_parts/cell/emproof
+	name = "\improper EMP-proof cell"
+	desc = "An EMP-proof cell."
+	maxcharge = 500
+	rating = 3
+
+/obj/item/stock_parts/cell/emproof/empty/Initialize()
+	. = ..()
+	charge = 0
+	update_icon()
+
+/obj/item/stock_parts/cell/emproof/empty/ComponentInitialize()
+	. = ..()
+	AddComponent(/datum/component/empprotection, EMP_PROTECT_SELF)
+
+/obj/item/stock_parts/cell/emproof/corrupt()
+	return
+
+/obj/item/stock_parts/cell/beam_rifle
+	name = "beam rifle capacitor"
+	desc = "A high powered capacitor that can provide huge amounts of energy in an instant."
+	maxcharge = 50000
+	chargerate = 5000	//Extremely energy intensive
+
+/obj/item/stock_parts/cell/beam_rifle/corrupt()
+	return
+
+/obj/item/stock_parts/cell/beam_rifle/emp_act(severity)
+	. = ..()
+	if(. & EMP_PROTECT_SELF)
+		return
+	charge = CLAMP((charge-(10000/severity)),0,maxcharge)
+
+/obj/item/stock_parts/cell/emergency_light
+	name = "miniature power cell"
+	desc = "A tiny power cell with a very low power capacity. Used in light fixtures to power them in the event of an outage."
+	maxcharge = 120 //Emergency lights use 0.2 W per tick, meaning ~10 minutes of emergency power from a cell
+	materials = list(MAT_GLASS = 20)
+	w_class = WEIGHT_CLASS_TINY
+
+/obj/item/stock_parts/cell/emergency_light/Initialize()
+	. = ..()
+	var/area/A = get_area(src)
+	if(!A.lightswitch || !A.light_power)
+		charge = 0 //For naturally depowered areas, we start with no power

code/modules/power/floodlight.dm

@@ -0,0 +1,117 @@
+
+/obj/structure/floodlight_frame
+	name = "floodlight frame"
+	desc = "A bare metal frame looking vaguely like a floodlight. Requires wrenching down."
+	max_integrity = 100
+	icon = 'icons/obj/lighting.dmi'
+	icon_state = "floodlight_c1"
+	density = TRUE
+	var/state = FLOODLIGHT_NEEDS_WRENCHING
+
+/obj/structure/floodlight_frame/attackby(obj/item/O, mob/user, params)
+	if(istype(O, /obj/item/wrench) && (state == FLOODLIGHT_NEEDS_WRENCHING))
+		to_chat(user, "<span class='notice'>You secure [src].</span>")
+		anchored = TRUE
+		state = FLOODLIGHT_NEEDS_WIRES
+		desc = "A bare metal frame looking vaguely like a floodlight. Requires wiring."
+	else if(istype(O, /obj/item/stack/cable_coil) && (state == FLOODLIGHT_NEEDS_WIRES))
+		var/obj/item/stack/S = O
+		if(S.use(5))
+			to_chat(user, "<span class='notice'>You wire [src].</span>")
+			name = "wired [name]"
+			desc = "A bare metal frame looking vaguely like a floodlight. Requires securing with a screwdriver."
+			icon_state = "floodlight_c2"
+			state = FLOODLIGHT_NEEDS_SECURING
+	else if(istype(O, /obj/item/light/tube) && (state == FLOODLIGHT_NEEDS_LIGHTS))
+		if(user.transferItemToLoc(O))
+			to_chat(user, "<span class='notice'>You put lights in [src].</span>")
+			new /obj/machinery/power/floodlight(src.loc)
+			qdel(src)
+	else if(istype(O, /obj/item/screwdriver) && (state == FLOODLIGHT_NEEDS_SECURING))
+		to_chat(user, "<span class='notice'>You fasten the wiring and electronics in [src].</span>")
+		name = "secured [name]"
+		desc = "A bare metal frame that looks like a floodlight. Requires light tubes."
+		icon_state = "floodlight_c3"
+		state = FLOODLIGHT_NEEDS_LIGHTS
+	else
+		..()
+
+/obj/machinery/power/floodlight
+	name = "floodlight"
+	desc = "A pole with powerful mounted lights on it. Due to its high power draw, it must be powered by a direct connection to a wire node."
+	icon = 'icons/obj/lighting.dmi'
+	icon_state = "floodlight"
+	density = TRUE
+	max_integrity = 100
+	integrity_failure = 80
+	idle_power_usage = 100
+	active_power_usage = 1000
+	var/list/light_setting_list = list(0, 5, 10, 15)
+	var/light_power_coefficient = 300
+	var/setting = 1
+	light_power = 1.75
+
+/obj/machinery/power/floodlight/process()
+	if(avail(active_power_usage))
+		add_load(active_power_usage)
+	else
+		change_setting(1)
+
+/obj/machinery/power/floodlight/proc/change_setting(val, mob/user)
+	if((val < 1) || (val > light_setting_list.len))
+		return
+	active_power_usage = light_setting_list[val]
+	if(!avail(active_power_usage))
+		return change_setting(val - 1)
+	setting = val
+	set_light(light_setting_list[val])
+	var/setting_text = ""
+	if(val > 1)
+		icon_state = "[initial(icon_state)]_on"
+	else
+		icon_state = initial(icon_state)
+	switch(val)
+		if(1)
+			setting_text = "OFF"
+		if(2)
+			setting_text = "low power"
+		if(3)
+			setting_text = "standard lighting"
+		if(4)
+			setting_text = "high power"
+	if(user)
+		to_chat(user, "You set [src] to [setting_text].")
+
+/obj/machinery/power/floodlight/attackby(obj/item/O, mob/user, params)
+	if(istype(O, /obj/item/wrench))
+		default_unfasten_wrench(user, O, time = 20)
+		change_setting(1)
+		if(anchored)
+			connect_to_network()
+		else
+			disconnect_from_network()
+	else
+		. = ..()
+
+/obj/machinery/power/floodlight/attack_hand(mob/user)
+	. = ..()
+	if(.)
+		return
+	var/current = setting
+	if(current == 1)
+		current = light_setting_list.len
+	else
+		current--
+	change_setting(current, user)
+	..()
+
+/obj/machinery/power/floodlight/obj_break(damage_flag)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		playsound(loc, 'sound/effects/glassbr3.ogg', 100, 1)
+		var/obj/structure/floodlight_frame/F = new(loc)
+		F.state = FLOODLIGHT_NEEDS_LIGHTS
+		new /obj/item/light/tube/broken(loc)
+		qdel(src)
+
+/obj/machinery/power/floodlight/play_attack_sound(damage_amount, damage_type = BRUTE, damage_flag = 0)
+	playsound(src, 'sound/effects/glasshit.ogg', 75, 1)

code/modules/power/generator.dm

@@ -0,0 +1,234 @@
+/obj/machinery/power/generator
+	name = "thermoelectric generator"
+	desc = "It's a high efficiency thermoelectric generator."
+	icon_state = "teg"
+	density = TRUE
+	use_power = NO_POWER_USE
+
+	var/obj/machinery/atmospherics/components/binary/circulator/cold_circ
+	var/obj/machinery/atmospherics/components/binary/circulator/hot_circ
+
+	var/lastgen = 0
+	var/lastgenlev = -1
+	var/lastcirc = "00"
+
+
+/obj/machinery/power/generator/Initialize(mapload)
+	. = ..()
+	find_circs()
+	connect_to_network()
+	SSair.atmos_machinery += src
+	update_icon()
+	component_parts = list(new /obj/item/circuitboard/machine/generator)
+
+/obj/machinery/power/generator/ComponentInitialize()
+	. = ..()
+	AddComponent(/datum/component/simple_rotation,ROTATION_ALTCLICK | ROTATION_CLOCKWISE | ROTATION_COUNTERCLOCKWISE | ROTATION_VERBS )
+
+/obj/machinery/power/generator/Destroy()
+	kill_circs()
+	SSair.atmos_machinery -= src
+	return ..()
+
+/obj/machinery/power/generator/update_icon()
+
+	if(stat & (NOPOWER|BROKEN))
+		cut_overlays()
+	else
+		cut_overlays()
+
+		var/L = min(round(lastgenlev/100000),11)
+		if(L != 0)
+			add_overlay(image('icons/obj/power.dmi', "teg-op[L]"))
+
+		if(hot_circ && cold_circ)
+			add_overlay("teg-oc[lastcirc]")
+
+
+#define GENRATE 800		// generator output coefficient from Q
+
+/obj/machinery/power/generator/process_atmos()
+
+	if(!cold_circ || !hot_circ)
+		return
+
+	if(powernet)
+		var/datum/gas_mixture/cold_air = cold_circ.return_transfer_air()
+		var/datum/gas_mixture/hot_air = hot_circ.return_transfer_air()
+
+		if(cold_air && hot_air)
+
+			var/cold_air_heat_capacity = cold_air.heat_capacity()
+			var/hot_air_heat_capacity = hot_air.heat_capacity()
+
+			var/delta_temperature = hot_air.temperature - cold_air.temperature
+
+
+			if(delta_temperature > 0 && cold_air_heat_capacity > 0 && hot_air_heat_capacity > 0)
+				var/efficiency = 0.00025 + (hot_air.reaction_results["fire"]*0.01)
+
+				var/energy_transfer = delta_temperature*hot_air_heat_capacity*cold_air_heat_capacity/(hot_air_heat_capacity+cold_air_heat_capacity)
+
+				var/heat = energy_transfer*(1-efficiency)
+				lastgen += energy_transfer*efficiency
+
+				hot_air.temperature = hot_air.temperature - energy_transfer/hot_air_heat_capacity
+				cold_air.temperature = cold_air.temperature + heat/cold_air_heat_capacity
+
+				//add_avail(lastgen) This is done in process now
+		// update icon overlays only if displayed level has changed
+
+		if(hot_air)
+			var/datum/gas_mixture/hot_circ_air1 = hot_circ.airs[1]
+			hot_circ_air1.merge(hot_air)
+
+		if(cold_air)
+			var/datum/gas_mixture/cold_circ_air1 = cold_circ.airs[1]
+			cold_circ_air1.merge(cold_air)
+
+		update_icon()
+
+	var/circ = "[cold_circ && cold_circ.last_pressure_delta > 0 ? "1" : "0"][hot_circ && hot_circ.last_pressure_delta > 0 ? "1" : "0"]"
+	if(circ != lastcirc)
+		lastcirc = circ
+		update_icon()
+
+	src.updateDialog()
+
+/obj/machinery/power/generator/process()
+	//Setting this number higher just makes the change in power output slower, it doesnt actualy reduce power output cause **math**
+	var/power_output = round(lastgen / 10)
+	add_avail(power_output)
+	lastgenlev = power_output
+	lastgen -= power_output
+	..()
+
+/obj/machinery/power/generator/proc/get_menu(include_link = TRUE)
+	var/t = ""
+	if(!powernet)
+		t += "<span class='bad'>Unable to connect to the power network!</span>"
+	else if(cold_circ && hot_circ)
+		var/datum/gas_mixture/cold_circ_air1 = cold_circ.airs[1]
+		var/datum/gas_mixture/cold_circ_air2 = cold_circ.airs[2]
+		var/datum/gas_mixture/hot_circ_air1 = hot_circ.airs[1]
+		var/datum/gas_mixture/hot_circ_air2 = hot_circ.airs[2]
+
+		t += "<div class='statusDisplay'>"
+
+		t += "Output: [DisplayPower(lastgenlev)]"
+
+		t += "<BR>"
+
+		t += "<B><font color='blue'>Cold loop</font></B><BR>"
+		t += "Temperature Inlet: [round(cold_circ_air2.temperature, 0.1)] K / Outlet: [round(cold_circ_air1.temperature, 0.1)] K<BR>"
+		t += "Pressure Inlet: [round(cold_circ_air2.return_pressure(), 0.1)] kPa /  Outlet: [round(cold_circ_air1.return_pressure(), 0.1)] kPa<BR>"
+
+		t += "<B><font color='red'>Hot loop</font></B><BR>"
+		t += "Temperature Inlet: [round(hot_circ_air2.temperature, 0.1)] K / Outlet: [round(hot_circ_air1.temperature, 0.1)] K<BR>"
+		t += "Pressure Inlet: [round(hot_circ_air2.return_pressure(), 0.1)] kPa / Outlet: [round(hot_circ_air1.return_pressure(), 0.1)] kPa<BR>"
+
+		t += "</div>"
+	else if(!hot_circ && cold_circ)
+		t += "<span class='bad'>Unable to locate hot circulator!</span>"
+	else if(hot_circ && !cold_circ)
+		t += "<span class='bad'>Unable to locate cold circulator!</span>"
+	else
+		t += "<span class='bad'>Unable to locate any parts!</span>"
+	if(include_link)
+		t += "<BR><A href='?src=[REF(src)];close=1'>Close</A>"
+
+	return t
+
+/obj/machinery/power/generator/ui_interact(mob/user)
+	. = ..()
+	var/datum/browser/popup = new(user, "teg", "Thermo-Electric Generator", 460, 300)
+	popup.set_content(get_menu())
+	popup.set_title_image(user.browse_rsc_icon(src.icon, src.icon_state))
+	popup.open()
+
+/obj/machinery/power/generator/Topic(href, href_list)
+	if(..())
+		return
+	if( href_list["close"] )
+		usr << browse(null, "window=teg")
+		usr.unset_machine()
+		return FALSE
+	return TRUE
+
+
+/obj/machinery/power/generator/power_change()
+	..()
+	update_icon()
+
+/obj/machinery/power/generator/proc/find_circs()
+	kill_circs()
+	var/list/circs = list()
+	var/obj/machinery/atmospherics/components/binary/circulator/C
+	var/circpath = /obj/machinery/atmospherics/components/binary/circulator
+	if(dir == NORTH || dir == SOUTH)
+		C = locate(circpath) in get_step(src, EAST)
+		if(C && C.dir == WEST)
+			circs += C
+
+		C = locate(circpath) in get_step(src, WEST)
+		if(C && C.dir == EAST)
+			circs += C
+
+	else
+		C = locate(circpath) in get_step(src, NORTH)
+		if(C && C.dir == SOUTH)
+			circs += C
+
+		C = locate(circpath) in get_step(src, SOUTH)
+		if(C && C.dir == NORTH)
+			circs += C
+
+	if(circs.len)
+		for(C in circs)
+			if(C.mode == CIRCULATOR_COLD && !cold_circ)
+				cold_circ = C
+				C.generator = src
+			else if(C.mode == CIRCULATOR_HOT && !hot_circ)
+				hot_circ = C
+				C.generator = src
+
+/obj/machinery/power/generator/wrench_act(mob/living/user, obj/item/I)
+	if(!panel_open)
+		return
+	anchored = !anchored
+	I.play_tool_sound(src)
+	if(!anchored)
+		kill_circs()
+	connect_to_network()
+	to_chat(user, "<span class='notice'>You [anchored?"secure":"unsecure"] [src].</span>")
+	return TRUE
+
+/obj/machinery/power/generator/multitool_act(mob/living/user, obj/item/I)
+	if(!anchored)
+		return
+	find_circs()
+	to_chat(user, "<span class='notice'>You update [src]'s circulator links.</span>")
+	return TRUE
+
+/obj/machinery/power/generator/screwdriver_act(mob/user, obj/item/I)
+	if(..())
+		return TRUE
+	panel_open = !panel_open
+	I.play_tool_sound(src)
+	to_chat(user, "<span class='notice'>You [panel_open?"open":"close"] the panel on [src].</span>")
+	return TRUE
+
+/obj/machinery/power/generator/crowbar_act(mob/user, obj/item/I)
+	default_deconstruction_crowbar(I)
+	return TRUE
+
+/obj/machinery/power/generator/on_deconstruction()
+	kill_circs()
+
+/obj/machinery/power/generator/proc/kill_circs()
+	if(hot_circ)
+		hot_circ.generator = null
+		hot_circ = null
+	if(cold_circ)
+		cold_circ.generator = null
+		cold_circ = null

code/modules/power/gravitygenerator.dm

@@ -0,0 +1,409 @@
+
+//
+// Gravity Generator
+//
+
+GLOBAL_LIST_EMPTY(gravity_generators) // We will keep track of this by adding new gravity generators to the list, and keying it with the z level.
+
+#define POWER_IDLE 0
+#define POWER_UP 1
+#define POWER_DOWN 2
+
+#define GRAV_NEEDS_SCREWDRIVER 0
+#define GRAV_NEEDS_WELDING 1
+#define GRAV_NEEDS_PLASTEEL 2
+#define GRAV_NEEDS_WRENCH 3
+
+//
+// Abstract Generator
+//
+
+/obj/machinery/gravity_generator
+	name = "gravitational generator"
+	desc = "A device which produces a graviton field when set up."
+	icon = 'icons/obj/machines/gravity_generator.dmi'
+	density = TRUE
+	use_power = NO_POWER_USE
+	resistance_flags = INDESTRUCTIBLE | LAVA_PROOF | FIRE_PROOF | UNACIDABLE | ACID_PROOF
+	var/sprite_number = 0
+
+/obj/machinery/gravity_generator/safe_throw_at()
+	return FALSE
+
+/obj/machinery/gravity_generator/ex_act(severity, target)
+	if(severity == 1) // Very sturdy.
+		set_broken()
+
+/obj/machinery/gravity_generator/blob_act(obj/structure/blob/B)
+	if(prob(20))
+		set_broken()
+
+/obj/machinery/gravity_generator/tesla_act(power, tesla_flags)
+	..()
+	if(tesla_flags & TESLA_MACHINE_EXPLOSIVE)
+		qdel(src)//like the singulo, tesla deletes it. stops it from exploding over and over
+
+/obj/machinery/gravity_generator/update_icon()
+	..()
+	icon_state = "[get_status()]_[sprite_number]"
+
+/obj/machinery/gravity_generator/proc/get_status()
+	return "off"
+
+// You aren't allowed to move.
+/obj/machinery/gravity_generator/Move()
+	. = ..()
+	qdel(src)
+
+/obj/machinery/gravity_generator/proc/set_broken()
+	stat |= BROKEN
+
+/obj/machinery/gravity_generator/proc/set_fix()
+	stat &= ~BROKEN
+
+/obj/machinery/gravity_generator/part/Destroy()
+	if(main_part)
+		qdel(main_part)
+	set_broken()
+	return ..()
+
+//
+// Part generator which is mostly there for looks
+//
+
+/obj/machinery/gravity_generator/part
+	var/obj/machinery/gravity_generator/main/main_part = null
+
+/obj/machinery/gravity_generator/part/attackby(obj/item/I, mob/user, params)
+	return main_part.attackby(I, user)
+
+/obj/machinery/gravity_generator/part/get_status()
+	return main_part.get_status()
+
+/obj/machinery/gravity_generator/part/attack_hand(mob/user)
+	return main_part.attack_hand(user)
+
+/obj/machinery/gravity_generator/part/set_broken()
+	..()
+	if(main_part && !(main_part.stat & BROKEN))
+		main_part.set_broken()
+
+//
+// Generator which spawns with the station.
+//
+
+/obj/machinery/gravity_generator/main/station/Initialize()
+	. = ..()
+	setup_parts()
+	middle.add_overlay("activated")
+	update_list()
+
+//
+// Generator an admin can spawn
+//
+/obj/machinery/gravity_generator/main/station/admin
+	use_power = NO_POWER_USE
+
+//
+// Main Generator with the main code
+//
+
+/obj/machinery/gravity_generator/main
+	icon_state = "on_8"
+	idle_power_usage = 0
+	active_power_usage = 3000
+	power_channel = ENVIRON
+	sprite_number = 8
+	use_power = IDLE_POWER_USE
+	interaction_flags_machine = INTERACT_MACHINE_ALLOW_SILICON | INTERACT_MACHINE_OFFLINE
+	var/on = TRUE
+	var/breaker = 1
+	var/list/parts = list()
+	var/obj/middle = null
+	var/charging_state = POWER_IDLE
+	var/charge_count = 100
+	var/current_overlay = null
+	var/broken_state = 0
+	var/setting = 1	//Gravity value when on
+
+/obj/machinery/gravity_generator/main/Destroy() // If we somehow get deleted, remove all of our other parts.
+	investigate_log("was destroyed!", INVESTIGATE_GRAVITY)
+	on = FALSE
+	update_list()
+	for(var/obj/machinery/gravity_generator/part/O in parts)
+		O.main_part = null
+		if(!QDESTROYING(O))
+			qdel(O)
+	return ..()
+
+/obj/machinery/gravity_generator/main/proc/setup_parts()
+	var/turf/our_turf = get_turf(src)
+	// 9x9 block obtained from the bottom middle of the block
+	var/list/spawn_turfs = block(locate(our_turf.x - 1, our_turf.y + 2, our_turf.z), locate(our_turf.x + 1, our_turf.y, our_turf.z))
+	var/count = 10
+	for(var/turf/T in spawn_turfs)
+		count--
+		if(T == our_turf) // Skip our turf.
+			continue
+		var/obj/machinery/gravity_generator/part/part = new(T)
+		if(count == 5) // Middle
+			middle = part
+		if(count <= 3) // Their sprite is the top part of the generator
+			part.density = FALSE
+			part.layer = WALL_OBJ_LAYER
+		part.sprite_number = count
+		part.main_part = src
+		parts += part
+		part.update_icon()
+
+/obj/machinery/gravity_generator/main/proc/connected_parts()
+	return parts.len == 8
+
+/obj/machinery/gravity_generator/main/set_broken()
+	..()
+	for(var/obj/machinery/gravity_generator/M in parts)
+		if(!(M.stat & BROKEN))
+			M.set_broken()
+	middle.cut_overlays()
+	charge_count = 0
+	breaker = 0
+	set_power()
+	set_state(0)
+	investigate_log("has broken down.", INVESTIGATE_GRAVITY)
+
+/obj/machinery/gravity_generator/main/set_fix()
+	..()
+	for(var/obj/machinery/gravity_generator/M in parts)
+		if(M.stat & BROKEN)
+			M.set_fix()
+	broken_state = 0
+	update_icon()
+	set_power()
+
+// Interaction
+
+// Fixing the gravity generator.
+/obj/machinery/gravity_generator/main/attackby(obj/item/I, mob/user, params)
+	switch(broken_state)
+		if(GRAV_NEEDS_SCREWDRIVER)
+			if(istype(I, /obj/item/screwdriver))
+				to_chat(user, "<span class='notice'>You secure the screws of the framework.</span>")
+				I.play_tool_sound(src)
+				broken_state++
+				update_icon()
+				return
+		if(GRAV_NEEDS_WELDING)
+			if(istype(I, /obj/item/weldingtool))
+				if(I.use_tool(src, user, 0, volume=50, amount=1))
+					to_chat(user, "<span class='notice'>You mend the damaged framework.</span>")
+					broken_state++
+					update_icon()
+				return
+		if(GRAV_NEEDS_PLASTEEL)
+			if(istype(I, /obj/item/stack/sheet/plasteel))
+				var/obj/item/stack/sheet/plasteel/PS = I
+				if(PS.get_amount() >= 10)
+					PS.use(10)
+					to_chat(user, "<span class='notice'>You add the plating to the framework.</span>")
+					playsound(src.loc, 'sound/machines/click.ogg', 75, 1)
+					broken_state++
+					update_icon()
+				else
+					to_chat(user, "<span class='warning'>You need 10 sheets of plasteel!</span>")
+				return
+		if(GRAV_NEEDS_WRENCH)
+			if(istype(I, /obj/item/wrench))
+				to_chat(user, "<span class='notice'>You secure the plating to the framework.</span>")
+				I.play_tool_sound(src)
+				set_fix()
+				return
+	return ..()
+
+/obj/machinery/gravity_generator/main/ui_interact(mob/user)
+	if(stat & BROKEN)
+		return
+	var/dat = "Gravity Generator Breaker: "
+	if(breaker)
+		dat += "<span class='linkOn'>ON</span> <A href='?src=[REF(src)];gentoggle=1'>OFF</A>"
+	else
+		dat += "<A href='?src=[REF(src)];gentoggle=1'>ON</A> <span class='linkOn'>OFF</span> "
+
+	dat += "<br>Generator Status:<br><div class='statusDisplay'>"
+	if(charging_state != POWER_IDLE)
+		dat += "<font class='bad'>WARNING</font> Radiation Detected. <br>[charging_state == POWER_UP ? "Charging..." : "Discharging..."]"
+	else if(on)
+		dat += "Powered."
+	else
+		dat += "Unpowered."
+
+	dat += "<br>Gravity Charge: [charge_count]%</div>"
+
+	var/datum/browser/popup = new(user, "gravgen", name)
+	popup.set_content(dat)
+	popup.open()
+
+
+/obj/machinery/gravity_generator/main/Topic(href, href_list)
+
+	if(..())
+		return
+
+	if(href_list["gentoggle"])
+		breaker = !breaker
+		investigate_log("was toggled [breaker ? "<font color='green'>ON</font>" : "<font color='red'>OFF</font>"] by [key_name(usr)].", INVESTIGATE_GRAVITY)
+		set_power()
+		src.updateUsrDialog()
+
+// Power and Icon States
+
+/obj/machinery/gravity_generator/main/power_change()
+	..()
+	investigate_log("has [stat & NOPOWER ? "lost" : "regained"] power.", INVESTIGATE_GRAVITY)
+	set_power()
+
+/obj/machinery/gravity_generator/main/get_status()
+	if(stat & BROKEN)
+		return "fix[min(broken_state, 3)]"
+	return on || charging_state != POWER_IDLE ? "on" : "off"
+
+/obj/machinery/gravity_generator/main/update_icon()
+	..()
+	for(var/obj/O in parts)
+		O.update_icon()
+
+// Set the charging state based on power/breaker.
+/obj/machinery/gravity_generator/main/proc/set_power()
+	var/new_state = 0
+	if(stat & (NOPOWER|BROKEN) || !breaker)
+		new_state = 0
+	else if(breaker)
+		new_state = 1
+
+	charging_state = new_state ? POWER_UP : POWER_DOWN // Startup sequence animation.
+	investigate_log("is now [charging_state == POWER_UP ? "charging" : "discharging"].", INVESTIGATE_GRAVITY)
+	update_icon()
+
+// Set the state of the gravity.
+/obj/machinery/gravity_generator/main/proc/set_state(new_state)
+	charging_state = POWER_IDLE
+	on = new_state
+	use_power = on ? ACTIVE_POWER_USE : IDLE_POWER_USE
+	// Sound the alert if gravity was just enabled or disabled.
+	var/alert = FALSE
+	if(SSticker.IsRoundInProgress())
+		if(on) // If we turned on and the game is live.
+			if(gravity_in_level() == 0)
+				alert = 1
+				investigate_log("was brought online and is now producing gravity for this level.", INVESTIGATE_GRAVITY)
+				message_admins("The gravity generator was brought online [ADMIN_VERBOSEJMP(src)]")
+		else
+			if(gravity_in_level() == 1)
+				alert = 1
+				investigate_log("was brought offline and there is now no gravity for this level.", INVESTIGATE_GRAVITY)
+				message_admins("The gravity generator was brought offline with no backup generator. [ADMIN_VERBOSEJMP(src)]")
+
+	update_icon()
+	update_list()
+	src.updateUsrDialog()
+	if(alert)
+		shake_everyone()
+
+// Charge/Discharge and turn on/off gravity when you reach 0/100 percent.
+// Also emit radiation and handle the overlays.
+/obj/machinery/gravity_generator/main/process()
+	if(stat & BROKEN)
+		return
+	if(charging_state != POWER_IDLE)
+		if(charging_state == POWER_UP && charge_count >= 100)
+			set_state(1)
+		else if(charging_state == POWER_DOWN && charge_count <= 0)
+			set_state(0)
+		else
+			if(charging_state == POWER_UP)
+				charge_count += 2
+			else if(charging_state == POWER_DOWN)
+				charge_count -= 2
+
+			if(charge_count % 4 == 0 && prob(75)) // Let them know it is charging/discharging.
+				playsound(src.loc, 'sound/effects/empulse.ogg', 100, 1)
+
+			updateDialog()
+			if(prob(25)) // To help stop "Your clothes feel warm." spam.
+				pulse_radiation()
+
+			var/overlay_state = null
+			switch(charge_count)
+				if(0 to 20)
+					overlay_state = null
+				if(21 to 40)
+					overlay_state = "startup"
+				if(41 to 60)
+					overlay_state = "idle"
+				if(61 to 80)
+					overlay_state = "activating"
+				if(81 to 100)
+					overlay_state = "activated"
+
+			if(overlay_state != current_overlay)
+				if(middle)
+					middle.cut_overlays()
+					if(overlay_state)
+						middle.add_overlay(overlay_state)
+					current_overlay = overlay_state
+
+
+/obj/machinery/gravity_generator/main/proc/pulse_radiation()
+	radiation_pulse(src, 200)
+
+// Shake everyone on the z level to let them know that gravity was enagaged/disenagaged.
+/obj/machinery/gravity_generator/main/proc/shake_everyone()
+	var/turf/T = get_turf(src)
+	var/sound/alert_sound = sound('sound/effects/alert.ogg')
+	for(var/i in GLOB.mob_list)
+		var/mob/M = i
+		if(M.z != z)
+			continue
+		M.update_gravity(M.mob_has_gravity())
+		if(M.client)
+			shake_camera(M, 15, 1)
+			M.playsound_local(T, null, 100, 1, 0.5, S = alert_sound)
+
+/obj/machinery/gravity_generator/main/proc/gravity_in_level()
+	var/turf/T = get_turf(src)
+	if(!T)
+		return 0
+	if(GLOB.gravity_generators["[T.z]"])
+		return length(GLOB.gravity_generators["[T.z]"])
+	return 0
+
+/obj/machinery/gravity_generator/main/proc/update_list()
+	var/turf/T = get_turf(src.loc)
+	if(T)
+		if(!GLOB.gravity_generators["[T.z]"])
+			GLOB.gravity_generators["[T.z]"] = list()
+		if(on)
+			GLOB.gravity_generators["[T.z]"] |= src
+		else
+			GLOB.gravity_generators["[T.z]"] -= src
+
+/obj/machinery/gravity_generator/main/proc/change_setting(value)
+	if(value != setting)
+		setting = value
+		shake_everyone()
+
+// Misc
+
+/obj/item/paper/guides/jobs/engi/gravity_gen
+	name = "paper- 'Generate your own gravity!'"
+	info = {"<h1>Gravity Generator Instructions For Dummies</h1>
+	<p>Surprisingly, gravity isn't that hard to make! All you have to do is inject deadly radioactive minerals into a ball of
+	energy and you have yourself gravity! You can turn the machine on or off when required but you must remember that the generator
+	will EMIT RADIATION when charging or discharging, you can tell it is charging or discharging by the noise it makes, so please WEAR PROTECTIVE CLOTHING.</p>
+	<br>
+	<h3>It blew up!</h3>
+	<p>Don't panic! The gravity generator was designed to be easily repaired. If, somehow, the sturdy framework did not survive then
+	please proceed to panic; otherwise follow these steps.</p><ol>
+	<li>Secure the screws of the framework with a screwdriver.</li>
+	<li>Mend the damaged framework with a welding tool.</li>
+	<li>Add additional plasteel plating.</li>
+	<li>Secure the additional plating with a wrench.</li></ol>"}

code/modules/power/lighting.dm

@@ -0,0 +1,823 @@
+// The lighting system
+//
+// consists of light fixtures (/obj/machinery/light) and light tube/bulb items (/obj/item/light)
+
+#define LIGHT_EMERGENCY_POWER_USE 0.2 //How much power emergency lights will consume per tick
+// status values shared between lighting fixtures and items
+#define LIGHT_OK 0
+#define LIGHT_EMPTY 1
+#define LIGHT_BROKEN 2
+#define LIGHT_BURNED 3
+
+
+
+/obj/item/wallframe/light_fixture
+	name = "light fixture frame"
+	desc = "Used for building lights."
+	icon = 'icons/obj/lighting.dmi'
+	icon_state = "tube-construct-item"
+	result_path = /obj/structure/light_construct
+	inverse = TRUE
+
+/obj/item/wallframe/light_fixture/small
+	name = "small light fixture frame"
+	icon_state = "bulb-construct-item"
+	result_path = /obj/structure/light_construct/small
+	materials = list(MAT_METAL=MINERAL_MATERIAL_AMOUNT)
+
+/obj/item/wallframe/light_fixture/try_build(turf/on_wall, user)
+	if(!..())
+		return
+	var/area/A = get_area(user)
+	if(!IS_DYNAMIC_LIGHTING(A))
+		to_chat(user, "<span class='warning'>You cannot place [src] in this area!</span>")
+		return
+	return TRUE
+
+
+/obj/structure/light_construct
+	name = "light fixture frame"
+	desc = "A light fixture under construction."
+	icon = 'icons/obj/lighting.dmi'
+	icon_state = "tube-construct-stage1"
+	anchored = TRUE
+	layer = WALL_OBJ_LAYER
+	max_integrity = 200
+	armor = list("melee" = 50, "bullet" = 10, "laser" = 10, "energy" = 0, "bomb" = 0, "bio" = 0, "rad" = 0, "fire" = 80, "acid" = 50)
+
+	var/stage = 1
+	var/fixture_type = "tube"
+	var/sheets_refunded = 2
+	var/obj/machinery/light/newlight = null
+	var/obj/item/stock_parts/cell/cell
+
+	var/cell_connectors = TRUE
+
+/obj/structure/light_construct/Initialize(mapload, ndir, building)
+	. = ..()
+	if(building)
+		setDir(ndir)
+
+/obj/structure/light_construct/Destroy()
+	QDEL_NULL(cell)
+	return ..()
+
+/obj/structure/light_construct/get_cell()
+	return cell
+
+/obj/structure/light_construct/examine(mob/user)
+	..()
+	switch(src.stage)
+		if(1)
+			to_chat(user, "It's an empty frame.")
+		if(2)
+			to_chat(user, "It's wired.")
+		if(3)
+			to_chat(user, "The casing is closed.")
+	if(cell_connectors)
+		if(cell)
+			to_chat(user, "You see [cell] inside the casing.")
+		else
+			to_chat(user, "The casing has no power cell for backup power.")
+	else
+		to_chat(user, "<span class='danger'>This casing doesn't support power cells for backup power.</span>")
+		return
+
+/obj/structure/light_construct/attackby(obj/item/W, mob/user, params)
+	add_fingerprint(user)
+	if(istype(W, /obj/item/stock_parts/cell))
+		if(!cell_connectors)
+			to_chat(user, "<span class='warning'>This [name] can't support a power cell!</span>")
+			return
+		if(HAS_TRAIT(W, TRAIT_NODROP))
+			to_chat(user, "<span class='warning'>[W] is stuck to your hand!</span>")
+			return
+		user.dropItemToGround(W)
+		if(cell)
+			user.visible_message("<span class='notice'>[user] swaps [W] out for [src]'s cell.</span>", \
+			"<span class='notice'>You swap [src]'s power cells.</span>")
+			cell.forceMove(drop_location())
+			user.put_in_hands(cell)
+		else
+			user.visible_message("<span class='notice'>[user] hooks up [W] to [src].</span>", \
+			"<span class='notice'>You add [W] to [src].</span>")
+		playsound(src, 'sound/machines/click.ogg', 50, TRUE)
+		W.forceMove(src)
+		cell = W
+		add_fingerprint(user)
+		return
+	switch(stage)
+		if(1)
+			if(istype(W, /obj/item/wrench))
+				to_chat(usr, "<span class='notice'>You begin deconstructing [src]...</span>")
+				if (W.use_tool(src, user, 30, volume=50))
+					new /obj/item/stack/sheet/metal(drop_location(), sheets_refunded)
+					user.visible_message("[user.name] deconstructs [src].", \
+						"<span class='notice'>You deconstruct [src].</span>", "<span class='italics'>You hear a ratchet.</span>")
+					playsound(src.loc, 'sound/items/deconstruct.ogg', 75, 1)
+					qdel(src)
+				return
+
+			if(istype(W, /obj/item/stack/cable_coil))
+				var/obj/item/stack/cable_coil/coil = W
+				if(coil.use(1))
+					icon_state = "[fixture_type]-construct-stage2"
+					stage = 2
+					user.visible_message("[user.name] adds wires to [src].", \
+						"<span class='notice'>You add wires to [src].</span>")
+				else
+					to_chat(user, "<span class='warning'>You need one length of cable to wire [src]!</span>")
+				return
+		if(2)
+			if(istype(W, /obj/item/wrench))
+				to_chat(usr, "<span class='warning'>You have to remove the wires first!</span>")
+				return
+
+			if(istype(W, /obj/item/wirecutters))
+				stage = 1
+				icon_state = "[fixture_type]-construct-stage1"
+				new /obj/item/stack/cable_coil(drop_location(), 1, "red")
+				user.visible_message("[user.name] removes the wiring from [src].", \
+					"<span class='notice'>You remove the wiring from [src].</span>", "<span class='italics'>You hear clicking.</span>")
+				W.play_tool_sound(src, 100)
+				return
+
+			if(istype(W, /obj/item/screwdriver))
+				user.visible_message("[user.name] closes [src]'s casing.", \
+					"<span class='notice'>You close [src]'s casing.</span>", "<span class='italics'>You hear screwing.</span>")
+				W.play_tool_sound(src, 75)
+				switch(fixture_type)
+					if("tube")
+						newlight = new /obj/machinery/light/built(loc)
+					if("bulb")
+						newlight = new /obj/machinery/light/small/built(loc)
+				newlight.setDir(dir)
+				transfer_fingerprints_to(newlight)
+				if(cell)
+					newlight.cell = cell
+					cell.forceMove(newlight)
+					cell = null
+				qdel(src)
+				return
+	return ..()
+
+/obj/structure/light_construct/blob_act(obj/structure/blob/B)
+	if(B && B.loc == loc)
+		qdel(src)
+
+
+/obj/structure/light_construct/deconstruct(disassembled = TRUE)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		new /obj/item/stack/sheet/metal(loc, sheets_refunded)
+	qdel(src)
+
+/obj/structure/light_construct/small
+	name = "small light fixture frame"
+	icon_state = "bulb-construct-stage1"
+	fixture_type = "bulb"
+	sheets_refunded = 1
+
+
+
+// the standard tube light fixture
+/obj/machinery/light
+	name = "light fixture"
+	icon = 'icons/obj/lighting.dmi'
+	var/overlayicon = 'icons/obj/lighting_overlay.dmi'
+	var/base_state = "tube"		// base description and icon_state
+	icon_state = "tube"
+	desc = "A lighting fixture."
+	layer = WALL_OBJ_LAYER
+	max_integrity = 100
+	use_power = ACTIVE_POWER_USE
+	idle_power_usage = 2
+	active_power_usage = 20
+	power_channel = LIGHT //Lights are calc'd via area so they dont need to be in the machine list
+	var/on = FALSE					// 1 if on, 0 if off
+	var/on_gs = FALSE
+	var/static_power_used = 0
+	var/brightness = 8			// luminosity when on, also used in power calculation
+	var/bulb_power = 1			// basically the alpha of the emitted light source
+	var/bulb_colour = "#FFFFFF"	// befault colour of the light.
+	var/status = LIGHT_OK		// LIGHT_OK, _EMPTY, _BURNED or _BROKEN
+	var/flickering = FALSE
+	var/light_type = /obj/item/light/tube		// the type of light item
+	var/fitting = "tube"
+	var/switchcount = 0			// count of number of times switched on/off
+								// this is used to calc the probability the light burns out
+
+	var/rigged = FALSE			// true if rigged to explode
+
+	var/obj/item/stock_parts/cell/cell
+	var/start_with_cell = TRUE	// if true, this fixture generates a very weak cell at roundstart
+
+	var/nightshift_enabled = FALSE	//Currently in night shift mode?
+	var/nightshift_allowed = TRUE	//Set to FALSE to never let this light get switched to night mode.
+	var/nightshift_brightness = 8
+	var/nightshift_light_power = 0.45
+	var/nightshift_light_color = "#FFDDCC"
+
+	var/emergency_mode = FALSE	// if true, the light is in emergency mode
+	var/no_emergency = FALSE	// if true, this light cannot ever have an emergency mode
+	var/bulb_emergency_brightness_mul = 0.25	// multiplier for this light's base brightness in emergency power mode
+	var/bulb_emergency_colour = "#FF3232"	// determines the colour of the light while it's in emergency mode
+	var/bulb_emergency_pow_mul = 0.75	// the multiplier for determining the light's power in emergency mode
+	var/bulb_emergency_pow_min = 0.5	// the minimum value for the light's power in emergency mode
+
+/obj/machinery/light/broken
+	status = LIGHT_BROKEN
+	icon_state = "tube-broken"
+
+// the smaller bulb light fixture
+
+/obj/machinery/light/small
+	icon_state = "bulb"
+	base_state = "bulb"
+	fitting = "bulb"
+	brightness = 4
+	desc = "A small lighting fixture."
+	light_type = /obj/item/light/bulb
+
+/obj/machinery/light/small/broken
+	status = LIGHT_BROKEN
+	icon_state = "bulb-broken"
+
+/obj/machinery/light/Move()
+	if(status != LIGHT_BROKEN)
+		break_light_tube(1)
+	return ..()
+
+/obj/machinery/light/built
+	icon_state = "tube-empty"
+	start_with_cell = FALSE
+
+/obj/machinery/light/built/Initialize()
+	. = ..()
+	status = LIGHT_EMPTY
+	update(0)
+
+/obj/machinery/light/small/built
+	icon_state = "bulb-empty"
+
+/obj/machinery/light/small/built/Initialize()
+	. = ..()
+	status = LIGHT_EMPTY
+	update(0)
+
+
+
+// create a new lighting fixture
+/obj/machinery/light/Initialize()
+	. = ..()
+	if(start_with_cell && !no_emergency)
+		cell = new/obj/item/stock_parts/cell/emergency_light(src)
+	spawn(2)
+		switch(fitting)
+			if("tube")
+				brightness = 8
+				if(prob(2))
+					break_light_tube(1)
+			if("bulb")
+				brightness = 4
+				if(prob(5))
+					break_light_tube(1)
+		spawn(1)
+			update(0)
+
+/obj/machinery/light/Destroy()
+	var/area/A = get_area(src)
+	if(A)
+		on = FALSE
+//		A.update_lights()
+	QDEL_NULL(cell)
+	return ..()
+
+/obj/machinery/light/update_icon()
+	cut_overlays()
+	switch(status)		// set icon_states
+		if(LIGHT_OK)
+			var/area/A = get_area(src)
+			if(emergency_mode || (A && A.fire))
+				icon_state = "[base_state]_emergency"
+			else
+				icon_state = "[base_state]"
+				if(on)
+					var/mutable_appearance/glowybit = mutable_appearance(overlayicon, base_state, ABOVE_LIGHTING_LAYER, ABOVE_LIGHTING_PLANE)
+					glowybit.alpha = CLAMP(light_power*250, 30, 200)
+					add_overlay(glowybit)
+		if(LIGHT_EMPTY)
+			icon_state = "[base_state]-empty"
+		if(LIGHT_BURNED)
+			icon_state = "[base_state]-burned"
+		if(LIGHT_BROKEN)
+			icon_state = "[base_state]-broken"
+	return
+
+// update the icon_state and luminosity of the light depending on its state
+/obj/machinery/light/proc/update(trigger = TRUE)
+	switch(status)
+		if(LIGHT_BROKEN,LIGHT_BURNED,LIGHT_EMPTY)
+			on = FALSE
+	emergency_mode = FALSE
+	if(on)
+		var/BR = brightness
+		var/PO = bulb_power
+		var/CO = bulb_colour
+		var/area/A = get_area(src)
+		if (A && A.fire)
+			CO = bulb_emergency_colour
+		else if (nightshift_enabled)
+			BR = nightshift_brightness
+			PO = nightshift_light_power
+			CO = nightshift_light_color
+		var/matching = light && BR == light.light_range && PO == light.light_power && CO == light.light_color
+		if(!matching)
+			switchcount++
+			if(rigged)
+				if(status == LIGHT_OK && trigger)
+					explode()
+			else if( prob( min(60, (switchcount^2)*0.01) ) )
+				if(trigger)
+					burn_out()
+			else
+				use_power = ACTIVE_POWER_USE
+				set_light(BR, PO, CO)
+	else if(has_emergency_power(LIGHT_EMERGENCY_POWER_USE) && !turned_off())
+		use_power = IDLE_POWER_USE
+		emergency_mode = TRUE
+		START_PROCESSING(SSmachines, src)
+	else
+		use_power = IDLE_POWER_USE
+		set_light(0)
+	update_icon()
+
+	active_power_usage = (brightness * 10)
+	if(on != on_gs)
+		on_gs = on
+		if(on)
+			static_power_used = brightness * 20 //20W per unit luminosity
+			addStaticPower(static_power_used, STATIC_LIGHT)
+		else
+			removeStaticPower(static_power_used, STATIC_LIGHT)
+
+
+/obj/machinery/light/process()
+	if (!cell)
+		return PROCESS_KILL
+	if(has_power())
+		if (cell.charge == cell.maxcharge)
+			return PROCESS_KILL
+		cell.charge = min(cell.maxcharge, cell.charge + LIGHT_EMERGENCY_POWER_USE) //Recharge emergency power automatically while not using it
+	if(emergency_mode && !use_emergency_power(LIGHT_EMERGENCY_POWER_USE))
+		update(FALSE) //Disables emergency mode and sets the color to normal
+
+/obj/machinery/light/proc/burn_out()
+	if(status == LIGHT_OK)
+		status = LIGHT_BURNED
+		icon_state = "[base_state]-burned"
+		on = FALSE
+		set_light(0)
+
+// attempt to set the light's on/off status
+// will not switch on if broken/burned/empty
+/obj/machinery/light/proc/seton(s)
+	on = (s && status == LIGHT_OK)
+	update()
+
+/obj/machinery/light/get_cell()
+	return cell
+
+// examine verb
+/obj/machinery/light/examine(mob/user)
+	..()
+	switch(status)
+		if(LIGHT_OK)
+			to_chat(user, "It is turned [on? "on" : "off"].")
+		if(LIGHT_EMPTY)
+			to_chat(user, "The [fitting] has been removed.")
+		if(LIGHT_BURNED)
+			to_chat(user, "The [fitting] is burnt out.")
+		if(LIGHT_BROKEN)
+			to_chat(user, "The [fitting] has been smashed.")
+	if(cell)
+		to_chat(user, "Its backup power charge meter reads [round((cell.charge / cell.maxcharge) * 100, 0.1)]%.")
+
+
+
+// attack with item - insert light (if right type), otherwise try to break the light
+
+/obj/machinery/light/attackby(obj/item/W, mob/living/user, params)
+
+	//Light replacer code
+	if(istype(W, /obj/item/lightreplacer))
+		var/obj/item/lightreplacer/LR = W
+		LR.ReplaceLight(src, user)
+
+	// attempt to insert light
+	else if(istype(W, /obj/item/light))
+		if(status == LIGHT_OK)
+			to_chat(user, "<span class='warning'>There is a [fitting] already inserted!</span>")
+		else
+			src.add_fingerprint(user)
+			var/obj/item/light/L = W
+			if(istype(L, light_type))
+				if(!user.temporarilyRemoveItemFromInventory(L))
+					return
+
+				src.add_fingerprint(user)
+				if(status != LIGHT_EMPTY)
+					drop_light_tube(user)
+					to_chat(user, "<span class='notice'>You replace [L].</span>")
+				else
+					to_chat(user, "<span class='notice'>You insert [L].</span>")
+				status = L.status
+				switchcount = L.switchcount
+				rigged = L.rigged
+				brightness = L.brightness
+				on = has_power()
+				update()
+
+				qdel(L)
+
+				if(on && rigged)
+					explode()
+			else
+				to_chat(user, "<span class='warning'>This type of light requires a [fitting]!</span>")
+
+	// attempt to stick weapon into light socket
+	else if(status == LIGHT_EMPTY)
+		if(istype(W, /obj/item/screwdriver)) //If it's a screwdriver open it.
+			W.play_tool_sound(src, 75)
+			user.visible_message("[user.name] opens [src]'s casing.", \
+				"<span class='notice'>You open [src]'s casing.</span>", "<span class='italics'>You hear a noise.</span>")
+			deconstruct()
+		else
+			to_chat(user, "<span class='userdanger'>You stick \the [W] into the light socket!</span>")
+			if(has_power() && (W.flags_1 & CONDUCT_1))
+				do_sparks(3, TRUE, src)
+				if (prob(75))
+					electrocute_mob(user, get_area(src), src, rand(0.7,1.0), TRUE)
+	else
+		return ..()
+
+/obj/machinery/light/deconstruct(disassembled = TRUE)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		var/obj/structure/light_construct/newlight = null
+		var/cur_stage = 2
+		if(!disassembled)
+			cur_stage = 1
+		switch(fitting)
+			if("tube")
+				newlight = new /obj/structure/light_construct(src.loc)
+				newlight.icon_state = "tube-construct-stage[cur_stage]"
+
+			if("bulb")
+				newlight = new /obj/structure/light_construct/small(src.loc)
+				newlight.icon_state = "bulb-construct-stage[cur_stage]"
+		newlight.setDir(src.dir)
+		newlight.stage = cur_stage
+		if(!disassembled)
+			newlight.obj_integrity = newlight.max_integrity * 0.5
+			if(status != LIGHT_BROKEN)
+				break_light_tube()
+			if(status != LIGHT_EMPTY)
+				drop_light_tube()
+			new /obj/item/stack/cable_coil(loc, 1, "red")
+		transfer_fingerprints_to(newlight)
+		if(cell)
+			newlight.cell = cell
+			cell.forceMove(newlight)
+			cell = null
+	qdel(src)
+
+/obj/machinery/light/attacked_by(obj/item/I, mob/living/user)
+	..()
+	if(status == LIGHT_BROKEN || status == LIGHT_EMPTY)
+		if(on && (I.flags_1 & CONDUCT_1))
+			if(prob(12))
+				electrocute_mob(user, get_area(src), src, 0.3, TRUE)
+
+/obj/machinery/light/take_damage(damage_amount, damage_type = BRUTE, damage_flag = 0, sound_effect = 1)
+	. = ..()
+	if(. && !QDELETED(src))
+		if(prob(damage_amount * 5))
+			break_light_tube()
+
+
+
+
+/obj/machinery/light/play_attack_sound(damage_amount, damage_type = BRUTE, damage_flag = 0)
+	switch(damage_type)
+		if(BRUTE)
+			switch(status)
+				if(LIGHT_EMPTY)
+					playsound(loc, 'sound/weapons/smash.ogg', 50, 1)
+				if(LIGHT_BROKEN)
+					playsound(loc, 'sound/effects/hit_on_shattered_glass.ogg', 90, 1)
+				else
+					playsound(loc, 'sound/effects/glasshit.ogg', 90, 1)
+		if(BURN)
+			playsound(src.loc, 'sound/items/welder.ogg', 100, 1)
+
+// returns if the light has power /but/ is manually turned off
+// if a light is turned off, it won't activate emergency power
+/obj/machinery/light/proc/turned_off()
+	var/area/A = get_area(src)
+	return !A.lightswitch && A.power_light || flickering
+
+// returns whether this light has power
+// true if area has power and lightswitch is on
+/obj/machinery/light/proc/has_power()
+	var/area/A = get_area(src)
+	return A.lightswitch && A.power_light
+
+// returns whether this light has emergency power
+// can also return if it has access to a certain amount of that power
+/obj/machinery/light/proc/has_emergency_power(pwr)
+	if(no_emergency || !cell)
+		return FALSE
+	if(pwr ? cell.charge >= pwr : cell.charge)
+		return status == LIGHT_OK
+
+// attempts to use power from the installed emergency cell, returns true if it does and false if it doesn't
+/obj/machinery/light/proc/use_emergency_power(pwr = LIGHT_EMERGENCY_POWER_USE)
+	if(!has_emergency_power(pwr))
+		return FALSE
+	if(cell.charge > 300) //it's meant to handle 120 W, ya doofus
+		visible_message("<span class='warning'>[src] short-circuits from too powerful of a power cell!</span>")
+		burn_out()
+		return FALSE
+	cell.use(pwr)
+	set_light(brightness * bulb_emergency_brightness_mul, max(bulb_emergency_pow_min, bulb_emergency_pow_mul * (cell.charge / cell.maxcharge)), bulb_emergency_colour)
+	return TRUE
+
+
+/obj/machinery/light/proc/flicker(var/amount = rand(10, 20))
+	set waitfor = 0
+	if(flickering)
+		return
+	flickering = 1
+	if(on && status == LIGHT_OK)
+		for(var/i = 0; i < amount; i++)
+			if(status != LIGHT_OK)
+				break
+			on = !on
+			update(0)
+			sleep(rand(5, 15))
+		on = (status == LIGHT_OK)
+		update(0)
+	flickering = 0
+
+// ai attack - make lights flicker, because why not
+
+/obj/machinery/light/attack_ai(mob/user)
+	no_emergency = !no_emergency
+	to_chat(user, "<span class='notice'>Emergency lights for this fixture have been [no_emergency ? "disabled" : "enabled"].</span>")
+	update(FALSE)
+	return
+
+// attack with hand - remove tube/bulb
+// if hands aren't protected and the light is on, burn the player
+
+/obj/machinery/light/attack_hand(mob/living/carbon/human/user)
+	. = ..()
+	if(.)
+		return
+	user.changeNext_move(CLICK_CD_MELEE)
+	add_fingerprint(user)
+
+	if(status == LIGHT_EMPTY)
+		to_chat(user, "There is no [fitting] in this light.")
+		return
+
+	// make it burn hands if not wearing fire-insulated gloves
+	if(on)
+		var/prot = 0
+		var/mob/living/carbon/human/H = user
+
+		if(istype(H))
+
+			if(H.gloves)
+				var/obj/item/clothing/gloves/G = H.gloves
+				if(G.max_heat_protection_temperature)
+					prot = (G.max_heat_protection_temperature > 360)
+		else
+			prot = 1
+
+		if(prot > 0 || HAS_TRAIT(user, TRAIT_RESISTHEAT) || HAS_TRAIT(user, TRAIT_RESISTHEATHANDS))
+			to_chat(user, "<span class='notice'>You remove the light [fitting].</span>")
+		else if(istype(user) && user.dna.check_mutation(TK))
+			to_chat(user, "<span class='notice'>You telekinetically remove the light [fitting].</span>")
+		else
+			to_chat(user, "<span class='warning'>You try to remove the light [fitting], but you burn your hand on it!</span>")
+
+			var/obj/item/bodypart/affecting = H.get_bodypart("[(user.active_hand_index % 2 == 0) ? "r" : "l" ]_arm")
+			if(affecting && affecting.receive_damage( 0, 5 ))		// 5 burn damage
+				H.update_damage_overlays()
+			return				// if burned, don't remove the light
+	else
+		to_chat(user, "<span class='notice'>You remove the light [fitting].</span>")
+	// create a light tube/bulb item and put it in the user's hand
+	drop_light_tube(user)
+
+/obj/machinery/light/proc/drop_light_tube(mob/user)
+	var/obj/item/light/L = new light_type()
+	L.status = status
+	L.rigged = rigged
+	L.brightness = brightness
+
+	// light item inherits the switchcount, then zero it
+	L.switchcount = switchcount
+	switchcount = 0
+
+	L.update()
+	L.forceMove(loc)
+
+	if(user) //puts it in our active hand
+		L.add_fingerprint(user)
+		user.put_in_active_hand(L)
+
+	status = LIGHT_EMPTY
+	update()
+	return L
+
+/obj/machinery/light/attack_tk(mob/user)
+	if(status == LIGHT_EMPTY)
+		to_chat(user, "There is no [fitting] in this light.")
+		return
+
+	to_chat(user, "<span class='notice'>You telekinetically remove the light [fitting].</span>")
+	// create a light tube/bulb item and put it in the user's hand
+	var/obj/item/light/L = drop_light_tube()
+	L.attack_tk(user)
+
+
+// break the light and make sparks if was on
+
+/obj/machinery/light/proc/break_light_tube(skip_sound_and_sparks = 0)
+	if(status == LIGHT_EMPTY || status == LIGHT_BROKEN)
+		return
+
+	if(!skip_sound_and_sparks)
+		if(status == LIGHT_OK || status == LIGHT_BURNED)
+			playsound(src.loc, 'sound/effects/glasshit.ogg', 75, 1)
+		if(on)
+			do_sparks(3, TRUE, src)
+	status = LIGHT_BROKEN
+	update()
+
+/obj/machinery/light/proc/fix()
+	if(status == LIGHT_OK)
+		return
+	status = LIGHT_OK
+	brightness = initial(brightness)
+	on = TRUE
+	update()
+
+/obj/machinery/light/tesla_act(power, tesla_flags)
+	if(tesla_flags & TESLA_MACHINE_EXPLOSIVE)
+		explosion(src,0,0,0,flame_range = 5, adminlog = 0)
+		qdel(src)
+	else
+		return ..()
+
+// called when area power state changes
+/obj/machinery/light/power_change()
+	var/area/A = get_area(src)
+	seton(A.lightswitch && A.power_light)
+
+// called when on fire
+
+/obj/machinery/light/temperature_expose(datum/gas_mixture/air, exposed_temperature, exposed_volume)
+	if(prob(max(0, exposed_temperature - 673)))   //0% at <400C, 100% at >500C
+		break_light_tube()
+
+// explode the light
+
+/obj/machinery/light/proc/explode()
+	set waitfor = 0
+	var/turf/T = get_turf(src.loc)
+	break_light_tube()	// break it first to give a warning
+	sleep(2)
+	explosion(T, 0, 0, 2, 2)
+	sleep(1)
+	qdel(src)
+
+// the light item
+// can be tube or bulb subtypes
+// will fit into empty /obj/machinery/light of the corresponding type
+
+/obj/item/light
+	icon = 'icons/obj/lighting.dmi'
+	force = 2
+	throwforce = 5
+	w_class = WEIGHT_CLASS_TINY
+	var/status = LIGHT_OK		// LIGHT_OK, LIGHT_BURNED or LIGHT_BROKEN
+	var/base_state
+	var/switchcount = 0	// number of times switched
+	materials = list(MAT_GLASS=100)
+	grind_results = list("silicon" = 5, "nitrogen" = 10) //Nitrogen is used as a cheaper alternative to argon in incandescent lighbulbs
+	var/rigged = 0		// true if rigged to explode
+	var/brightness = 2 //how much light it gives off
+
+/obj/item/light/suicide_act(mob/living/carbon/user)
+	if (status == LIGHT_BROKEN)
+		user.visible_message("<span class='suicide'>[user] begins to stab [user.p_them()]self with \the [src]! It looks like [user.p_theyre()] trying to commit suicide!</span>")
+		return BRUTELOSS
+	else
+		user.visible_message("<span class='suicide'>[user] begins to eat \the [src]! It looks like [user.p_theyre()] not very bright!</span>")
+		shatter()
+		return BRUTELOSS
+
+/obj/item/light/tube
+	name = "light tube"
+	desc = "A replacement light tube."
+	icon_state = "ltube"
+	base_state = "ltube"
+	item_state = "c_tube"
+	brightness = 8
+
+/obj/item/light/tube/broken
+	status = LIGHT_BROKEN
+
+/obj/item/light/bulb
+	name = "light bulb"
+	desc = "A replacement light bulb."
+	icon_state = "lbulb"
+	base_state = "lbulb"
+	item_state = "contvapour"
+	lefthand_file = 'icons/mob/inhands/equipment/medical_lefthand.dmi'
+	righthand_file = 'icons/mob/inhands/equipment/medical_righthand.dmi'
+	brightness = 4
+
+/obj/item/light/bulb/broken
+	status = LIGHT_BROKEN
+
+/obj/item/light/throw_impact(atom/hit_atom)
+	if(!..()) //not caught by a mob
+		shatter()
+
+// update the icon state and description of the light
+
+/obj/item/light/proc/update()
+	switch(status)
+		if(LIGHT_OK)
+			icon_state = base_state
+			desc = "A replacement [name]."
+		if(LIGHT_BURNED)
+			icon_state = "[base_state]-burned"
+			desc = "A burnt-out [name]."
+		if(LIGHT_BROKEN)
+			icon_state = "[base_state]-broken"
+			desc = "A broken [name]."
+
+
+/obj/item/light/Initialize()
+	. = ..()
+	update()
+
+
+// attack bulb/tube with object
+// if a syringe, can inject plasma to make it explode
+/obj/item/light/attackby(obj/item/I, mob/user, params)
+	..()
+	if(istype(I, /obj/item/reagent_containers/syringe))
+		var/obj/item/reagent_containers/syringe/S = I
+
+		to_chat(user, "<span class='notice'>You inject the solution into \the [src].</span>")
+
+		if(S.reagents.has_reagent("plasma", 5))
+
+			rigged = 1
+
+		S.reagents.clear_reagents()
+	else
+		..()
+	return
+
+/obj/item/light/attack(mob/living/M, mob/living/user, def_zone)
+	..()
+	shatter()
+
+/obj/item/light/attack_obj(obj/O, mob/living/user)
+	..()
+	shatter()
+
+/obj/item/light/proc/shatter()
+	if(status == LIGHT_OK || status == LIGHT_BURNED)
+		visible_message("<span class='danger'>[src] shatters.</span>","<span class='italics'>You hear a small glass object shatter.</span>")
+		status = LIGHT_BROKEN
+		force = 5
+		playsound(src.loc, 'sound/effects/glasshit.ogg', 75, 1)
+		update()
+
+
+/obj/machinery/light/floor
+	name = "floor light"
+	icon = 'icons/obj/lighting.dmi'
+	base_state = "floor"		// base description and icon_state
+	icon_state = "floor"
+	brightness = 4
+	layer = 2.5
+	light_type = /obj/item/light/bulb
+	fitting = "bulb"

code/modules/power/monitor.dm

@@ -0,0 +1,121 @@
+//modular computer program version is located in code\modules\modular_computers\file_system\programs\powermonitor.dm, /datum/computer_file/program/power_monitor
+
+/obj/machinery/computer/monitor
+	name = "power monitoring console"
+	desc = "It monitors power levels across the station."
+	icon_screen = "power"
+	icon_keyboard = "power_key"
+	light_color = LIGHT_COLOR_YELLOW
+	use_power = ACTIVE_POWER_USE
+	idle_power_usage = 20
+	active_power_usage = 100
+	circuit = /obj/item/circuitboard/computer/powermonitor
+
+	var/obj/structure/cable/attached_wire
+	var/obj/machinery/power/apc/local_apc
+
+	var/list/history = list()
+	var/record_size = 60
+	var/record_interval = 50
+	var/next_record = 0
+	var/is_secret_monitor = FALSE
+
+/obj/machinery/computer/monitor/secret //Hides the power monitor (such as ones on ruins & CentCom) from PDA's to prevent metagaming.
+	name = "outdated power monitoring console"
+	desc = "It monitors power levels across the local powernet."
+	circuit = /obj/item/circuitboard/computer/powermonitor/secret
+	is_secret_monitor = TRUE
+
+/obj/machinery/computer/monitor/secret/examine(mob/user)
+	..()
+	to_chat(user, "<span class='notice'>It's operating system seems quite outdated... It doesn't seem like it'd be compatible with the latest remote NTOS monitoring systems.</span>")
+
+/obj/machinery/computer/monitor/Initialize()
+	. = ..()
+	search()
+	history["supply"] = list()
+	history["demand"] = list()
+
+/obj/machinery/computer/monitor/process()
+	if(!get_powernet())
+		use_power = IDLE_POWER_USE
+		search()
+	else
+		use_power = ACTIVE_POWER_USE
+		record()
+
+/obj/machinery/computer/monitor/proc/search() //keep in sync with /datum/computer_file/program/power_monitor's version
+	var/turf/T = get_turf(src)
+	attached_wire = locate(/obj/structure/cable) in T
+	if(attached_wire)
+		return
+	var/area/A = get_area(src) //if the computer isn't directly connected to a wire, attempt to find the APC powering it to pull it's powernet instead
+	if(!A)
+		return
+	local_apc = A.get_apc()
+	if(!local_apc)
+		return
+	if(!local_apc.terminal) //this really shouldn't happen without badminnery.
+		local_apc = null
+
+/obj/machinery/computer/monitor/proc/get_powernet() //keep in sync with /datum/computer_file/program/power_monitor's version
+	if(attached_wire || (local_apc && local_apc.terminal))
+		return attached_wire ? attached_wire.powernet : local_apc.terminal.powernet
+	return FALSE
+
+/obj/machinery/computer/monitor/proc/record() //keep in sync with /datum/computer_file/program/power_monitor's version
+	if(world.time >= next_record)
+		next_record = world.time + record_interval
+
+		var/datum/powernet/connected_powernet = get_powernet()
+
+		var/list/supply = history["supply"]
+		if(connected_powernet)
+			supply += connected_powernet.viewavail
+		if(supply.len > record_size)
+			supply.Cut(1, 2)
+
+		var/list/demand = history["demand"]
+		if(connected_powernet)
+			demand += connected_powernet.viewload
+		if(demand.len > record_size)
+			demand.Cut(1, 2)
+
+/obj/machinery/computer/monitor/ui_interact(mob/user, ui_key = "main", datum/tgui/ui = null, force_open = FALSE, \
+											datum/tgui/master_ui = null, datum/ui_state/state = GLOB.default_state)
+	ui = SStgui.try_update_ui(user, src, ui_key, ui, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "power_monitor", name, 1200, 1000, master_ui, state)
+		ui.open()
+
+/obj/machinery/computer/monitor/ui_data()
+	var/datum/powernet/connected_powernet = get_powernet()
+	var/list/data = list()
+	data["stored"] = record_size
+	data["interval"] = record_interval / 10
+	data["attached"] = connected_powernet ? TRUE : FALSE
+	data["history"] = history
+	data["areas"] = list()
+
+	if(connected_powernet)
+		data["supply"] = DisplayPower(connected_powernet.viewavail)
+		data["demand"] = DisplayPower(connected_powernet.viewload)
+		for(var/obj/machinery/power/terminal/term in connected_powernet.nodes)
+			var/obj/machinery/power/apc/A = term.master
+			if(istype(A))
+				var/cell_charge
+				if(!A.cell)
+					cell_charge = 0
+				else
+					cell_charge = A.cell.percent()
+				data["areas"] += list(list(
+					"name" = A.area.name,
+					"charge" = cell_charge,
+					"load" = DisplayPower(A.lastused_total),
+					"charging" = A.charging,
+					"eqp" = A.equipment,
+					"lgt" = A.lighting,
+					"env" = A.environ
+				))
+
+	return data

code/modules/power/port_gen.dm

@@ -0,0 +1,285 @@
+
+//Baseline portable generator. Has all the default handling. Not intended to be used on it's own (since it generates unlimited power).
+/obj/machinery/power/port_gen
+	name = "portable generator"
+	desc = "A portable generator for emergency backup power."
+	icon = 'icons/obj/power.dmi'
+	icon_state = "portgen0_0"
+	density = TRUE
+	anchored = FALSE
+	use_power = NO_POWER_USE
+
+	var/active = 0
+	var/power_gen = 5000
+	var/recent_fault = 0
+	var/power_output = 1
+	var/consumption = 0
+	var/base_icon = "portgen0"
+	var/datum/looping_sound/generator/soundloop
+
+	interaction_flags_atom = INTERACT_ATOM_ATTACK_HAND | INTERACT_ATOM_UI_INTERACT | INTERACT_ATOM_REQUIRES_ANCHORED
+
+/obj/machinery/power/port_gen/Initialize()
+	. = ..()
+	soundloop = new(list(src), active)
+
+/obj/machinery/power/port_gen/Destroy()
+	QDEL_NULL(soundloop)
+	return ..()
+
+/obj/machinery/power/port_gen/proc/HasFuel() //Placeholder for fuel check.
+	return 1
+
+/obj/machinery/power/port_gen/proc/UseFuel() //Placeholder for fuel use.
+	return
+
+/obj/machinery/power/port_gen/proc/DropFuel()
+	return
+
+/obj/machinery/power/port_gen/proc/handleInactive()
+	return
+
+/obj/machinery/power/port_gen/update_icon()
+	icon_state = "[base_icon]_[active]"
+
+/obj/machinery/power/port_gen/process()
+	if(active && HasFuel() && !crit_fail && anchored && powernet)
+		add_avail(power_gen * power_output)
+		UseFuel()
+		src.updateDialog()
+		soundloop.start()
+
+	else
+		active = 0
+		handleInactive()
+		update_icon()
+		soundloop.stop()
+
+/obj/machinery/power/port_gen/examine(mob/user)
+	..()
+	to_chat(user, "It is[!active?"n't":""] running.")
+
+/obj/machinery/power/port_gen/pacman
+	name = "\improper P.A.C.M.A.N.-type portable generator"
+	circuit = /obj/item/circuitboard/machine/pacman
+	var/sheets = 0
+	var/max_sheets = 100
+	var/sheet_name = ""
+	var/sheet_path = /obj/item/stack/sheet/mineral/plasma
+	var/sheet_left = 0 // How much is left of the sheet
+	var/time_per_sheet = 260
+	var/current_heat = 0
+
+/obj/machinery/power/port_gen/pacman/Initialize()
+	. = ..()
+	if(anchored)
+		connect_to_network()
+
+/obj/machinery/power/port_gen/pacman/Initialize()
+	. = ..()
+
+	var/obj/sheet = new sheet_path(null)
+	sheet_name = sheet.name
+
+/obj/machinery/power/port_gen/pacman/Destroy()
+	DropFuel()
+	return ..()
+
+/obj/machinery/power/port_gen/pacman/RefreshParts()
+	var/temp_rating = 0
+	var/consumption_coeff = 0
+	for(var/obj/item/stock_parts/SP in component_parts)
+		if(istype(SP, /obj/item/stock_parts/matter_bin))
+			max_sheets = SP.rating * SP.rating * 50
+		else if(istype(SP, /obj/item/stock_parts/capacitor))
+			temp_rating += SP.rating
+		else
+			consumption_coeff += SP.rating
+	power_gen = round(initial(power_gen) * temp_rating * 2)
+	consumption = consumption_coeff
+
+/obj/machinery/power/port_gen/pacman/examine(mob/user)
+	..()
+	to_chat(user, "<span class='notice'>The generator has [sheets] units of [sheet_name] fuel left, producing [power_gen] per cycle.</span>")
+	if(crit_fail)
+		to_chat(user, "<span class='danger'>The generator seems to have broken down.</span>")
+
+/obj/machinery/power/port_gen/pacman/HasFuel()
+	if(sheets >= 1 / (time_per_sheet / power_output) - sheet_left)
+		return 1
+	return 0
+
+/obj/machinery/power/port_gen/pacman/DropFuel()
+	if(sheets)
+		new sheet_path(drop_location(), sheets)
+		sheets = 0
+
+/obj/machinery/power/port_gen/pacman/UseFuel()
+	var/needed_sheets = 1 / (time_per_sheet * consumption / power_output)
+	var/temp = min(needed_sheets, sheet_left)
+	needed_sheets -= temp
+	sheet_left -= temp
+	sheets -= round(needed_sheets)
+	needed_sheets -= round(needed_sheets)
+	if (sheet_left <= 0 && sheets > 0)
+		sheet_left = 1 - needed_sheets
+		sheets--
+
+	var/lower_limit = 56 + power_output * 10
+	var/upper_limit = 76 + power_output * 10
+	var/bias = 0
+	if (power_output > 4)
+		upper_limit = 400
+		bias = power_output - consumption * (4 - consumption)
+	if (current_heat < lower_limit)
+		current_heat += 4 - consumption
+	else
+		current_heat += rand(-7 + bias, 7 + bias)
+		if (current_heat < lower_limit)
+			current_heat = lower_limit
+		if (current_heat > upper_limit)
+			current_heat = upper_limit
+
+	if (current_heat > 300)
+		overheat()
+		qdel(src)
+	return
+
+/obj/machinery/power/port_gen/pacman/handleInactive()
+
+	if (current_heat > 0)
+		current_heat = max(current_heat - 2, 0)
+		src.updateDialog()
+
+/obj/machinery/power/port_gen/pacman/proc/overheat()
+	explosion(src.loc, 2, 5, 2, -1)
+
+/obj/machinery/power/port_gen/pacman/attackby(obj/item/O, mob/user, params)
+	if(istype(O, sheet_path))
+		var/obj/item/stack/addstack = O
+		var/amount = min((max_sheets - sheets), addstack.amount)
+		if(amount < 1)
+			to_chat(user, "<span class='notice'>The [src.name] is full!</span>")
+			return
+		to_chat(user, "<span class='notice'>You add [amount] sheets to the [src.name].</span>")
+		sheets += amount
+		addstack.use(amount)
+		updateUsrDialog()
+		return
+	else if(!active)
+
+		if(istype(O, /obj/item/wrench))
+
+			if(!anchored && !isinspace())
+				connect_to_network()
+				to_chat(user, "<span class='notice'>You secure the generator to the floor.</span>")
+				anchored = TRUE
+			else if(anchored)
+				disconnect_from_network()
+				to_chat(user, "<span class='notice'>You unsecure the generator from the floor.</span>")
+				anchored = FALSE
+
+			playsound(src.loc, 'sound/items/deconstruct.ogg', 50, 1)
+			return
+		else if(istype(O, /obj/item/screwdriver))
+			panel_open = !panel_open
+			O.play_tool_sound(src)
+			if(panel_open)
+				to_chat(user, "<span class='notice'>You open the access panel.</span>")
+			else
+				to_chat(user, "<span class='notice'>You close the access panel.</span>")
+			return
+		else if(default_deconstruction_crowbar(O))
+			return
+	return ..()
+
+/obj/machinery/power/port_gen/pacman/emag_act(mob/user)
+	if(obj_flags & EMAGGED)
+		return
+	obj_flags |= EMAGGED
+	emp_act(EMP_HEAVY)
+
+/obj/machinery/power/port_gen/pacman/attack_ai(mob/user)
+	interact(user)
+
+/obj/machinery/power/port_gen/pacman/attack_paw(mob/user)
+	interact(user)
+
+/obj/machinery/power/port_gen/pacman/ui_interact(mob/user)
+	. = ..()
+	if (get_dist(src, user) > 1 )
+		if(!isAI(user))
+			user.unset_machine()
+			user << browse(null, "window=port_gen")
+			return
+
+	var/dat = text("<b>[name]</b><br>")
+	if (active)
+		dat += text("Generator: <A href='?src=[REF(src)];action=disable'>On</A><br>")
+	else
+		dat += text("Generator: <A href='?src=[REF(src)];action=enable'>Off</A><br>")
+	dat += text("[capitalize(sheet_name)]: [sheets] - <A href='?src=[REF(src)];action=eject'>Eject</A><br>")
+	var/stack_percent = round(sheet_left * 100, 1)
+	dat += text("Current stack: [stack_percent]% <br>")
+	dat += text("Power output: <A href='?src=[REF(src)];action=lower_power'>-</A> [power_gen * power_output] <A href='?src=[REF(src)];action=higher_power'>+</A><br>")
+	dat += text("Power current: [(powernet == null ? "Unconnected" : "[DisplayPower(avail())]")]<br>")
+	dat += text("Heat: [current_heat]<br>")
+	dat += "<br><A href='?src=[REF(src)];action=close'>Close</A>"
+	user << browse(dat, "window=port_gen")
+	onclose(user, "port_gen")
+
+/obj/machinery/power/port_gen/pacman/Topic(href, href_list)
+	if(..())
+		return
+
+	src.add_fingerprint(usr)
+	if(href_list["action"])
+		if(href_list["action"] == "enable")
+			if(!active && HasFuel() && !crit_fail)
+				active = 1
+				src.updateUsrDialog()
+				update_icon()
+		if(href_list["action"] == "disable")
+			if (active)
+				active = 0
+				src.updateUsrDialog()
+				update_icon()
+		if(href_list["action"] == "eject")
+			if(!active)
+				DropFuel()
+				src.updateUsrDialog()
+		if(href_list["action"] == "lower_power")
+			if (power_output > 1)
+				power_output--
+				src.updateUsrDialog()
+		if (href_list["action"] == "higher_power")
+			if (power_output < 4 || (obj_flags & EMAGGED))
+				power_output++
+				src.updateUsrDialog()
+		if (href_list["action"] == "close")
+			usr << browse(null, "window=port_gen")
+			usr.unset_machine()
+
+/obj/machinery/power/port_gen/pacman/super
+	name = "\improper S.U.P.E.R.P.A.C.M.A.N.-type portable generator"
+	icon_state = "portgen1_0"
+	base_icon = "portgen1"
+	circuit = /obj/item/circuitboard/machine/pacman/super
+	sheet_path = /obj/item/stack/sheet/mineral/uranium
+	power_gen = 15000
+	time_per_sheet = 85
+
+/obj/machinery/power/port_gen/pacman/super/overheat()
+	explosion(src.loc, 3, 3, 3, -1)
+
+/obj/machinery/power/port_gen/pacman/mrs
+	name = "\improper M.R.S.P.A.C.M.A.N.-type portable generator"
+	base_icon = "portgen2"
+	icon_state = "portgen2_0"
+	circuit = /obj/item/circuitboard/machine/pacman/mrs
+	sheet_path = /obj/item/stack/sheet/mineral/diamond
+	power_gen = 40000
+	time_per_sheet = 80
+
+/obj/machinery/power/port_gen/pacman/mrs/overheat()
+	explosion(src.loc, 4, 4, 4, -1)

code/modules/power/power.dm

@@ -0,0 +1,387 @@
+//////////////////////////////
+// POWER MACHINERY BASE CLASS
+//////////////////////////////
+
+/////////////////////////////
+// Definitions
+/////////////////////////////
+
+/obj/machinery/power
+	name = null
+	icon = 'icons/obj/power.dmi'
+	anchored = TRUE
+	obj_flags = CAN_BE_HIT | ON_BLUEPRINTS
+	var/datum/powernet/powernet = null
+	use_power = NO_POWER_USE
+	idle_power_usage = 0
+	active_power_usage = 0
+
+/obj/machinery/power/Destroy()
+	disconnect_from_network()
+	return ..()
+
+///////////////////////////////
+// General procedures
+//////////////////////////////
+
+// common helper procs for all power machines
+// All power generation handled in add_avail()
+// Machines should use add_load(), surplus(), avail()
+// Non-machines should use add_delayedload(), delayed_surplus(), newavail()
+
+/obj/machinery/power/proc/add_avail(amount)
+	if(powernet)
+		powernet.newavail += amount
+		return TRUE
+	else
+		return FALSE
+
+/obj/machinery/power/proc/add_load(amount)
+	if(powernet)
+		powernet.load += amount
+
+/obj/machinery/power/proc/surplus()
+	if(powernet)
+		return CLAMP(powernet.avail-powernet.load, 0, powernet.avail)
+	else
+		return 0
+
+/obj/machinery/power/proc/avail()
+	if(powernet)
+		return powernet.avail
+	else
+		return 0
+
+/obj/machinery/power/proc/add_delayedload(amount)
+	if(powernet)
+		powernet.delayedload += amount
+
+/obj/machinery/power/proc/delayed_surplus()
+	if(powernet)
+		return CLAMP(powernet.newavail - powernet.delayedload, 0, powernet.newavail)
+	else
+		return 0
+
+/obj/machinery/power/proc/newavail()
+	if(powernet)
+		return powernet.newavail
+	else
+		return 0
+
+/obj/machinery/power/proc/disconnect_terminal() // machines without a terminal will just return, no harm no fowl.
+	return
+
+// returns true if the area has power on given channel (or doesn't require power).
+// defaults to power_channel
+/obj/machinery/proc/powered(var/chan = -1) // defaults to power_channel
+	if(!loc)
+		return FALSE
+	if(!use_power)
+		return TRUE
+
+	var/area/A = get_area(src)		// make sure it's in an area
+	if(!A)
+		return FALSE					// if not, then not powered
+	if(chan == -1)
+		chan = power_channel
+	return A.powered(chan)	// return power status of the area
+
+// increment the power usage stats for an area
+/obj/machinery/proc/use_power(amount, chan = -1) // defaults to power_channel
+	var/area/A = get_area(src)		// make sure it's in an area
+	if(!A)
+		return
+	if(chan == -1)
+		chan = power_channel
+	A.use_power(amount, chan)
+
+/obj/machinery/proc/addStaticPower(value, powerchannel)
+	var/area/A = get_area(src)
+	if(!A)
+		return
+	A.addStaticPower(value, powerchannel)
+
+/obj/machinery/proc/removeStaticPower(value, powerchannel)
+	addStaticPower(-value, powerchannel)
+
+/obj/machinery/proc/power_change()		// called whenever the power settings of the containing area change
+										// by default, check equipment channel & set flag
+										// can override if needed
+	if(powered(power_channel))
+		stat &= ~NOPOWER
+	else
+
+		stat |= NOPOWER
+	return
+
+// connect the machine to a powernet if a node cable is present on the turf
+/obj/machinery/power/proc/connect_to_network()
+	var/turf/T = src.loc
+	if(!T || !istype(T))
+		return FALSE
+
+	var/obj/structure/cable/C = T.get_cable_node() //check if we have a node cable on the machine turf, the first found is picked
+	if(!C || !C.powernet)
+		return FALSE
+
+	C.powernet.add_machine(src)
+	return TRUE
+
+// remove and disconnect the machine from its current powernet
+/obj/machinery/power/proc/disconnect_from_network()
+	if(!powernet)
+		return FALSE
+	powernet.remove_machine(src)
+	return TRUE
+
+// attach a wire to a power machine - leads from the turf you are standing on
+//almost never called, overwritten by all power machines but terminal and generator
+/obj/machinery/power/attackby(obj/item/W, mob/user, params)
+	if(istype(W, /obj/item/stack/cable_coil))
+		var/obj/item/stack/cable_coil/coil = W
+		var/turf/T = user.loc
+		if(T.intact || !isfloorturf(T))
+			return
+		if(get_dist(src, user) > 1)
+			return
+		coil.place_turf(T, user)
+	else
+		return ..()
+
+
+///////////////////////////////////////////
+// Powernet handling helpers
+//////////////////////////////////////////
+
+//returns all the cables WITHOUT a powernet in neighbors turfs,
+//pointing towards the turf the machine is located at
+/obj/machinery/power/proc/get_connections()
+
+	. = list()
+
+	var/cdir
+	var/turf/T
+
+	for(var/card in GLOB.cardinals)
+		T = get_step(loc,card)
+		cdir = get_dir(T,loc)
+
+		for(var/obj/structure/cable/C in T)
+			if(C.powernet)
+				continue
+			if(C.d1 == cdir || C.d2 == cdir)
+				. += C
+	return .
+
+//returns all the cables in neighbors turfs,
+//pointing towards the turf the machine is located at
+/obj/machinery/power/proc/get_marked_connections()
+
+	. = list()
+
+	var/cdir
+	var/turf/T
+
+	for(var/card in GLOB.cardinals)
+		T = get_step(loc,card)
+		cdir = get_dir(T,loc)
+
+		for(var/obj/structure/cable/C in T)
+			if(C.d1 == cdir || C.d2 == cdir)
+				. += C
+	return .
+
+//returns all the NODES (O-X) cables WITHOUT a powernet in the turf the machine is located at
+/obj/machinery/power/proc/get_indirect_connections()
+	. = list()
+	for(var/obj/structure/cable/C in loc)
+		if(C.powernet)
+			continue
+		if(C.d1 == 0) // the cable is a node cable
+			. += C
+	return .
+
+///////////////////////////////////////////
+// GLOBAL PROCS for powernets handling
+//////////////////////////////////////////
+
+
+// returns a list of all power-related objects (nodes, cable, junctions) in turf,
+// excluding source, that match the direction d
+// if unmarked==1, only return those with no powernet
+/proc/power_list(turf/T, source, d, unmarked=0, cable_only = 0)
+	. = list()
+
+	for(var/AM in T)
+		if(AM == source)
+			continue			//we don't want to return source
+
+		if(!cable_only && istype(AM, /obj/machinery/power))
+			var/obj/machinery/power/P = AM
+			if(P.powernet == 0)
+				continue		// exclude APCs which have powernet=0
+
+			if(!unmarked || !P.powernet)		//if unmarked=1 we only return things with no powernet
+				if(d == 0)
+					. += P
+
+		else if(istype(AM, /obj/structure/cable))
+			var/obj/structure/cable/C = AM
+
+			if(!unmarked || !C.powernet)
+				if(C.d1 == d || C.d2 == d)
+					. += C
+	return .
+
+
+
+
+//remove the old powernet and replace it with a new one throughout the network.
+/proc/propagate_network(obj/O, datum/powernet/PN)
+	var/list/worklist = list()
+	var/list/found_machines = list()
+	var/index = 1
+	var/obj/P = null
+
+	worklist+=O //start propagating from the passed object
+
+	while(index<=worklist.len) //until we've exhausted all power objects
+		P = worklist[index] //get the next power object found
+		index++
+
+		if( istype(P, /obj/structure/cable))
+			var/obj/structure/cable/C = P
+			if(C.powernet != PN) //add it to the powernet, if it isn't already there
+				PN.add_cable(C)
+			worklist |= C.get_connections() //get adjacents power objects, with or without a powernet
+
+		else if(P.anchored && istype(P, /obj/machinery/power))
+			var/obj/machinery/power/M = P
+			found_machines |= M //we wait until the powernet is fully propagates to connect the machines
+
+		else
+			continue
+
+	//now that the powernet is set, connect found machines to it
+	for(var/obj/machinery/power/PM in found_machines)
+		if(!PM.connect_to_network()) //couldn't find a node on its turf...
+			PM.disconnect_from_network() //... so disconnect if already on a powernet
+
+
+//Merge two powernets, the bigger (in cable length term) absorbing the other
+/proc/merge_powernets(datum/powernet/net1, datum/powernet/net2)
+	if(!net1 || !net2) //if one of the powernet doesn't exist, return
+		return
+
+	if(net1 == net2) //don't merge same powernets
+		return
+
+	//We assume net1 is larger. If net2 is in fact larger we are just going to make them switch places to reduce on code.
+	if(net1.cables.len < net2.cables.len)	//net2 is larger than net1. Let's switch them around
+		var/temp = net1
+		net1 = net2
+		net2 = temp
+
+	//merge net2 into net1
+	for(var/obj/structure/cable/Cable in net2.cables) //merge cables
+		net1.add_cable(Cable)
+
+	for(var/obj/machinery/power/Node in net2.nodes) //merge power machines
+		if(!Node.connect_to_network())
+			Node.disconnect_from_network() //if somehow we can't connect the machine to the new powernet, disconnect it from the old nonetheless
+
+	return net1
+
+//Determines how strong could be shock, deals damage to mob, uses power.
+//M is a mob who touched wire/whatever
+//power_source is a source of electricity, can be powercell, area, apc, cable, powernet or null
+//source is an object caused electrocuting (airlock, grille, etc)
+//siemens_coeff - layman's terms, conductivity
+//dist_check - set to only shock mobs within 1 of source (vendors, airlocks, etc.)
+//No animations will be performed by this proc.
+/proc/electrocute_mob(mob/living/carbon/M, power_source, obj/source, siemens_coeff = 1, dist_check = FALSE)
+	if(!M || ismecha(M.loc))
+		return 0	//feckin mechs are dumb
+	if(dist_check)
+		if(!in_range(source,M))
+			return 0
+	if(ishuman(M))
+		var/mob/living/carbon/human/H = M
+		if(H.gloves)
+			var/obj/item/clothing/gloves/G = H.gloves
+			if(G.siemens_coefficient == 0)
+				return 0		//to avoid spamming with insulated glvoes on
+
+	var/area/source_area
+	if(istype(power_source, /area))
+		source_area = power_source
+		power_source = source_area.get_apc()
+	if(istype(power_source, /obj/structure/cable))
+		var/obj/structure/cable/Cable = power_source
+		power_source = Cable.powernet
+
+	var/datum/powernet/PN
+	var/obj/item/stock_parts/cell/cell
+
+	if(istype(power_source, /datum/powernet))
+		PN = power_source
+	else if(istype(power_source, /obj/item/stock_parts/cell))
+		cell = power_source
+	else if(istype(power_source, /obj/machinery/power/apc))
+		var/obj/machinery/power/apc/apc = power_source
+		cell = apc.cell
+		if (apc.terminal)
+			PN = apc.terminal.powernet
+	else if (!power_source)
+		return 0
+	else
+		log_admin("ERROR: /proc/electrocute_mob([M], [power_source], [source]): wrong power_source")
+		return 0
+	if (!cell && !PN)
+		return 0
+	var/PN_damage = 0
+	var/cell_damage = 0
+	if (PN)
+		PN_damage = PN.get_electrocute_damage()
+	if (cell)
+		cell_damage = cell.get_electrocute_damage()
+	var/shock_damage = 0
+	if (PN_damage>=cell_damage)
+		power_source = PN
+		shock_damage = PN_damage
+	else
+		power_source = cell
+		shock_damage = cell_damage
+	var/drained_hp = M.electrocute_act(shock_damage, source, siemens_coeff) //zzzzzzap!
+	log_combat(source, M, "electrocuted")
+
+	var/drained_energy = drained_hp*20
+
+	if (source_area)
+		source_area.use_power(drained_energy/GLOB.CELLRATE)
+	else if (istype(power_source, /datum/powernet))
+		var/drained_power = drained_energy/GLOB.CELLRATE //convert from "joules" to "watts"
+		PN.delayedload += (min(drained_power, max(PN.newavail - PN.delayedload, 0)))
+	else if (istype(power_source, /obj/item/stock_parts/cell))
+		cell.use(drained_energy)
+	return drained_energy
+
+////////////////////////////////////////////////
+// Misc.
+///////////////////////////////////////////////
+
+
+// return a knot cable (O-X) if one is present in the turf
+// null if there's none
+/turf/proc/get_cable_node()
+	if(!can_have_cabling())
+		return null
+	for(var/obj/structure/cable/C in src)
+		if(C.d1 == 0)
+			return C
+	return null
+
+/area/proc/get_apc()
+	for(var/obj/machinery/power/apc/APC in GLOB.apcs_list)
+		if(APC.area == src)
+			return APC

code/modules/power/powernet.dm

@@ -0,0 +1,101 @@
+////////////////////////////////////////////
+// POWERNET DATUM
+// each contiguous network of cables & nodes
+/////////////////////////////////////
+/datum/powernet
+	var/number					// unique id
+	var/list/cables = list()	// all cables & junctions
+	var/list/nodes = list()		// all connected machines
+
+	var/load = 0				// the current load on the powernet, increased by each machine at processing
+	var/newavail = 0			// what available power was gathered last tick, then becomes...
+	var/avail = 0				//...the current available power in the powernet
+	var/viewavail = 0			// the available power as it appears on the power console (gradually updated)
+	var/viewload = 0			// the load as it appears on the power console (gradually updated)
+	var/netexcess = 0			// excess power on the powernet (typically avail-load)///////
+	var/delayedload = 0			// load applied to powernet between power ticks.
+
+/datum/powernet/New()
+	SSmachines.powernets += src
+
+/datum/powernet/Destroy()
+	//Go away references, you suck!
+	for(var/obj/structure/cable/C in cables)
+		cables -= C
+		C.powernet = null
+	for(var/obj/machinery/power/M in nodes)
+		nodes -= M
+		M.powernet = null
+
+	SSmachines.powernets -= src
+	return ..()
+
+/datum/powernet/proc/is_empty()
+	return !cables.len && !nodes.len
+
+//remove a cable from the current powernet
+//if the powernet is then empty, delete it
+//Warning : this proc DON'T check if the cable exists
+/datum/powernet/proc/remove_cable(obj/structure/cable/C)
+	cables -= C
+	C.powernet = null
+	if(is_empty())//the powernet is now empty...
+		qdel(src)///... delete it
+
+//add a cable to the current powernet
+//Warning : this proc DON'T check if the cable exists
+/datum/powernet/proc/add_cable(obj/structure/cable/C)
+	if(C.powernet)// if C already has a powernet...
+		if(C.powernet == src)
+			return
+		else
+			C.powernet.remove_cable(C) //..remove it
+	C.powernet = src
+	cables +=C
+
+//remove a power machine from the current powernet
+//if the powernet is then empty, delete it
+//Warning : this proc DON'T check if the machine exists
+/datum/powernet/proc/remove_machine(obj/machinery/power/M)
+	nodes -=M
+	M.powernet = null
+	if(is_empty())//the powernet is now empty...
+		qdel(src)///... delete it
+
+
+//add a power machine to the current powernet
+//Warning : this proc DON'T check if the machine exists
+/datum/powernet/proc/add_machine(obj/machinery/power/M)
+	if(M.powernet)// if M already has a powernet...
+		if(M.powernet == src)
+			return
+		else
+			M.disconnect_from_network()//..remove it
+	M.powernet = src
+	nodes[M] = M
+
+//handles the power changes in the powernet
+//called every ticks by the powernet controller
+/datum/powernet/proc/reset()
+	//see if there's a surplus of power remaining in the powernet and stores unused power in the SMES
+	netexcess = avail - load
+
+	if(netexcess > 100 && nodes && nodes.len)		// if there was excess power last cycle
+		for(var/obj/machinery/power/smes/S in nodes)	// find the SMESes in the network
+			S.restore()				// and restore some of the power that was used
+
+	// update power consoles
+	viewavail = round(0.8 * viewavail + 0.2 * avail)
+	viewload = round(0.8 * viewload + 0.2 * load)
+
+	// reset the powernet
+	load = delayedload
+	delayedload = 0
+	avail = newavail
+	newavail = 0
+
+/datum/powernet/proc/get_electrocute_damage()
+	if(avail >= 1000)
+		return CLAMP(round(avail/10000), 10, 90) + rand(-5,5)
+	else
+		return 0

code/modules/power/rtg.dm

@@ -0,0 +1,97 @@
+// Radioisotope Thermoelectric Generator (RTG)
+// Simple power generator that would replace "magic SMES" on various derelicts.
+
+/obj/machinery/power/rtg
+	name = "radioisotope thermoelectric generator"
+	desc = "A simple nuclear power generator, used in small outposts to reliably provide power for decades."
+	icon = 'icons/obj/power.dmi'
+	icon_state = "rtg"
+	density = TRUE
+	use_power = NO_POWER_USE
+	circuit = /obj/item/circuitboard/machine/rtg
+
+	// You can buckle someone to RTG, then open its panel. Fun stuff.
+	can_buckle = TRUE
+	buckle_lying = FALSE
+	buckle_requires_restraints = TRUE
+
+	var/power_gen = 1000 // Enough to power a single APC. 4000 output with T4 capacitor.
+
+	var/irradiate = TRUE // RTGs irradiate surroundings, but only when panel is open.
+
+/obj/machinery/power/rtg/Initialize()
+	. = ..()
+	connect_to_network()
+
+/obj/machinery/power/rtg/process()
+	..()
+	add_avail(power_gen)
+	if(panel_open && irradiate)
+		radiation_pulse(src, 60)
+
+/obj/machinery/power/rtg/RefreshParts()
+	var/part_level = 0
+	for(var/obj/item/stock_parts/SP in component_parts)
+		part_level += SP.rating
+
+	power_gen = initial(power_gen) * part_level
+
+/obj/machinery/power/rtg/attackby(obj/item/I, mob/user, params)
+	if(default_deconstruction_screwdriver(user, "[initial(icon_state)]-open", initial(icon_state), I))
+		return
+	else if(default_deconstruction_crowbar(I))
+		return
+	return ..()
+
+/obj/machinery/power/rtg/advanced
+	desc = "An advanced RTG capable of moderating isotope decay, increasing power output but reducing lifetime. It uses plasma-fueled radiation collectors to increase output even further."
+	power_gen = 1250 // 2500 on T1, 10000 on T4.
+	circuit = /obj/item/circuitboard/machine/rtg/advanced
+
+// Void Core, power source for Abductor ships and bases.
+// Provides a lot of power, but tends to explode when mistreated.
+
+/obj/machinery/power/rtg/abductor
+	name = "Void Core"
+	icon = 'icons/obj/abductor.dmi'
+	icon_state = "core"
+	desc = "An alien power source that produces energy seemingly out of nowhere."
+	circuit = /obj/item/circuitboard/machine/abductor/core
+	power_gen = 20000 // 280 000 at T1, 400 000 at T4. Starts at T4.
+	irradiate = FALSE // Green energy!
+	can_buckle = FALSE
+	pixel_y = 7
+	var/going_kaboom = FALSE // Is it about to explode?
+
+/obj/machinery/power/rtg/abductor/proc/overload()
+	if(going_kaboom)
+		return
+	going_kaboom = TRUE
+	visible_message("<span class='danger'>\The [src] lets out an shower of sparks as it starts to lose stability!</span>",\
+		"<span class='italics'>You hear a loud electrical crack!</span>")
+	playsound(src.loc, 'sound/magic/lightningshock.ogg', 100, 1, extrarange = 5)
+	tesla_zap(src, 5, power_gen * 0.05)
+	addtimer(CALLBACK(GLOBAL_PROC, .proc/explosion, get_turf(src), 2, 3, 4, 8), 100) // Not a normal explosion.
+
+/obj/machinery/power/rtg/abductor/bullet_act(obj/item/projectile/Proj)
+	..()
+	if(!going_kaboom && istype(Proj) && !Proj.nodamage && ((Proj.damage_type == BURN) || (Proj.damage_type == BRUTE)))
+		message_admins("[ADMIN_LOOKUPFLW(Proj.firer)] triggered an Abductor Core explosion at [AREACOORD(src)] via projectile.")
+		log_game("[key_name(Proj.firer)] triggered an Abductor Core explosion at [AREACOORD(src)] via projectile.")
+		overload()
+
+/obj/machinery/power/rtg/abductor/blob_act(obj/structure/blob/B)
+	overload()
+
+/obj/machinery/power/rtg/abductor/ex_act()
+	if(going_kaboom)
+		qdel(src)
+	else
+		overload()
+
+/obj/machinery/power/rtg/abductor/fire_act(exposed_temperature, exposed_volume)
+	overload()
+
+/obj/machinery/power/rtg/abductor/tesla_act()
+	..() //extend the zap
+	overload()

code/modules/power/singularity/collector.dm

@@ -0,0 +1,231 @@
+// stored_power += (pulse_strength-RAD_COLLECTOR_EFFICIENCY)*RAD_COLLECTOR_COEFFICIENT
+#define RAD_COLLECTOR_EFFICIENCY 80 	// radiation needs to be over this amount to get power
+#define RAD_COLLECTOR_COEFFICIENT 100
+#define RAD_COLLECTOR_STORED_OUT 0.04	// (this*100)% of stored power outputted per tick. Doesn't actualy change output total, lower numbers just means collectors output for longer in absence of a source
+#define RAD_COLLECTOR_MINING_CONVERSION_RATE 0.00001 //This is gonna need a lot of tweaking to get right. This is the number used to calculate the conversion of watts to research points per process()
+#define RAD_COLLECTOR_OUTPUT min(stored_power, (stored_power*RAD_COLLECTOR_STORED_OUT)+1000) //Produces at least 1000 watts if it has more than that stored
+
+/obj/machinery/power/rad_collector
+	name = "Radiation Collector Array"
+	desc = "A device which uses Hawking Radiation and plasma to produce power."
+	icon = 'icons/obj/singularity.dmi'
+	icon_state = "ca"
+	anchored = FALSE
+	density = TRUE
+	req_access = list(ACCESS_ENGINE_EQUIP)
+//	use_power = NO_POWER_USE
+	max_integrity = 350
+	integrity_failure = 80
+	circuit = /obj/item/circuitboard/machine/rad_collector
+	var/obj/item/tank/internals/plasma/loaded_tank = null
+	var/stored_power = 0
+	var/active = 0
+	var/locked = FALSE
+	var/drainratio = 1
+	var/powerproduction_drain = 0.001
+
+	var/bitcoinproduction_drain = 0.15
+	var/bitcoinmining = FALSE
+	rad_insulation = RAD_EXTREME_INSULATION
+
+/obj/machinery/power/rad_collector/anchored
+	anchored = TRUE
+
+/obj/machinery/power/rad_collector/Destroy()
+	return ..()
+
+/obj/machinery/power/rad_collector/process()
+	if(!loaded_tank)
+		return
+	if(!bitcoinmining)
+		if(!loaded_tank.air_contents.gases[/datum/gas/plasma])
+			investigate_log("<font color='red'>out of fuel</font>.", INVESTIGATE_SINGULO)
+			playsound(src, 'sound/machines/ding.ogg', 50, 1)
+			eject()
+		else
+			var/gasdrained = min(powerproduction_drain*drainratio,loaded_tank.air_contents.gases[/datum/gas/plasma])
+			loaded_tank.air_contents.gases[/datum/gas/plasma] -= gasdrained
+			loaded_tank.air_contents.gases[/datum/gas/tritium] += gasdrained
+			GAS_GARBAGE_COLLECT(loaded_tank.air_contents.gases)
+
+			var/power_produced = RAD_COLLECTOR_OUTPUT
+			add_avail(power_produced)
+			stored_power-=power_produced
+	else if(is_station_level(z) && SSresearch.science_tech)
+		if(!loaded_tank.air_contents.gases[/datum/gas/tritium] || !loaded_tank.air_contents.gases[/datum/gas/oxygen])
+			playsound(src, 'sound/machines/ding.ogg', 50, 1)
+			eject()
+		else
+			var/gasdrained = bitcoinproduction_drain*drainratio
+			loaded_tank.air_contents.gases[/datum/gas/tritium] -= gasdrained
+			loaded_tank.air_contents.gases[/datum/gas/oxygen] -= gasdrained
+			loaded_tank.air_contents.gases[/datum/gas/carbon_dioxide] += gasdrained*2
+			GAS_GARBAGE_COLLECT(loaded_tank.air_contents.gases)
+			var/bitcoins_mined = RAD_COLLECTOR_OUTPUT
+			SSresearch.science_tech.add_point_type(TECHWEB_POINT_TYPE_DEFAULT, bitcoins_mined*RAD_COLLECTOR_MINING_CONVERSION_RATE)
+			stored_power-=bitcoins_mined
+
+/obj/machinery/power/rad_collector/interact(mob/user)
+	if(anchored)
+		if(!src.locked)
+			toggle_power()
+			user.visible_message("[user.name] turns the [src.name] [active? "on":"off"].", \
+			"<span class='notice'>You turn the [src.name] [active? "on":"off"].</span>")
+			var/fuel
+			if(loaded_tank)
+				fuel = loaded_tank.air_contents.gases[/datum/gas/plasma]
+			investigate_log("turned [active?"<font color='green'>on</font>":"<font color='red'>off</font>"] by [key_name(user)]. [loaded_tank?"Fuel: [round(fuel/0.29)]%":"<font color='red'>It is empty</font>"].", INVESTIGATE_SINGULO)
+			return
+		else
+			to_chat(user, "<span class='warning'>The controls are locked!</span>")
+			return
+
+/obj/machinery/power/rad_collector/can_be_unfasten_wrench(mob/user, silent)
+	if(loaded_tank)
+		if(!silent)
+			to_chat(user, "<span class='warning'>Remove the plasma tank first!</span>")
+		return FAILED_UNFASTEN
+	return ..()
+
+/obj/machinery/power/rad_collector/default_unfasten_wrench(mob/user, obj/item/I, time = 20)
+	. = ..()
+	if(. == SUCCESSFUL_UNFASTEN)
+		if(anchored)
+			connect_to_network()
+		else
+			disconnect_from_network()
+
+/obj/machinery/power/rad_collector/attackby(obj/item/W, mob/user, params)
+	if(istype(W, /obj/item/tank/internals/plasma))
+		if(!anchored)
+			to_chat(user, "<span class='warning'>[src] needs to be secured to the floor first!</span>")
+			return TRUE
+		if(loaded_tank)
+			to_chat(user, "<span class='warning'>There's already a plasma tank loaded!</span>")
+			return TRUE
+		if(panel_open)
+			to_chat(user, "<span class='warning'>Close the maintenance panel first!</span>")
+			return TRUE
+		if(!user.transferItemToLoc(W, src))
+			return
+		loaded_tank = W
+		update_icons()
+	else if(W.GetID())
+		if(allowed(user))
+			if(active)
+				locked = !locked
+				to_chat(user, "<span class='notice'>You [locked ? "lock" : "unlock"] the controls.</span>")
+			else
+				to_chat(user, "<span class='warning'>The controls can only be locked when \the [src] is active!</span>")
+		else
+			to_chat(user, "<span class='danger'>Access denied.</span>")
+			return TRUE
+	else
+		return ..()
+
+/obj/machinery/power/rad_collector/wrench_act(mob/living/user, obj/item/I)
+	default_unfasten_wrench(user, I)
+	return TRUE
+
+/obj/machinery/power/rad_collector/screwdriver_act(mob/living/user, obj/item/I)
+	if(..())
+		return TRUE
+	if(loaded_tank)
+		to_chat(user, "<span class='warning'>Remove the plasma tank first!</span>")
+	else
+		default_deconstruction_screwdriver(user, icon_state, icon_state, I)
+	return TRUE
+
+/obj/machinery/power/rad_collector/crowbar_act(mob/living/user, obj/item/I)
+	if(loaded_tank)
+		if(locked)
+			to_chat(user, "<span class='warning'>The controls are locked!</span>")
+			return TRUE
+		eject()
+		return TRUE
+	if(default_deconstruction_crowbar(I))
+		return TRUE
+	to_chat(user, "<span class='warning'>There isn't a tank loaded!</span>")
+	return TRUE
+
+/obj/machinery/power/rad_collector/multitool_act(mob/living/user, obj/item/I)
+	if(!is_station_level(z) && !SSresearch.science_tech)
+		to_chat(user, "<span class='warning'>[src] isn't linked to a research system!</span>")
+		return TRUE
+	if(locked)
+		to_chat(user, "<span class='warning'>[src] is locked!</span>")
+		return TRUE
+	if(active)
+		to_chat(user, "<span class='warning'>[src] is currently active, producing [bitcoinmining ? "research points":"power"].</span>")
+		return TRUE
+	bitcoinmining = !bitcoinmining
+	to_chat(user, "<span class='warning'>You [bitcoinmining ? "enable":"disable"] the research point production feature of [src].</span>")
+	return TRUE
+
+/obj/machinery/power/rad_collector/analyzer_act(mob/living/user, obj/item/I)
+	if(loaded_tank)
+		loaded_tank.analyzer_act(user, I)
+
+/obj/machinery/power/rad_collector/examine(mob/user)
+	. = ..()
+	if(active)
+		if(!bitcoinmining)
+			to_chat(user, "<span class='notice'>[src]'s display states that it has stored <b>[DisplayPower(stored_power)]</b>, and processing <b>[DisplayPower(RAD_COLLECTOR_OUTPUT)]</b>.</span>")
+		else
+			to_chat(user, "<span class='notice'>[src]'s display states that it has stored a total of <b>[stored_power*RAD_COLLECTOR_MINING_CONVERSION_RATE]</b>, and producing [RAD_COLLECTOR_OUTPUT*RAD_COLLECTOR_MINING_CONVERSION_RATE] research points per minute.</span>")
+	else
+		if(!bitcoinmining)
+			to_chat(user,"<span class='notice'><b>[src]'s display displays the words:</b> \"Power production mode. Please insert <b>Plasma</b>. Use a multitool to change production modes.\"</span>")
+		else
+			to_chat(user,"<span class='notice'><b>[src]'s display displays the words:</b> \"Research point production mode. Please insert <b>Tritium</b> and <b>Oxygen</b>. Use a multitool to change production modes.\"</span>")
+
+/obj/machinery/power/rad_collector/obj_break(damage_flag)
+	if(!(stat & BROKEN) && !(flags_1 & NODECONSTRUCT_1))
+		eject()
+		stat |= BROKEN
+
+/obj/machinery/power/rad_collector/proc/eject()
+	locked = FALSE
+	var/obj/item/tank/internals/plasma/Z = src.loaded_tank
+	if (!Z)
+		return
+	Z.forceMove(drop_location())
+	Z.layer = initial(Z.layer)
+	Z.plane = initial(Z.plane)
+	src.loaded_tank = null
+	if(active)
+		toggle_power()
+	else
+		update_icons()
+
+/obj/machinery/power/rad_collector/rad_act(pulse_strength)
+	. = ..()
+	if(loaded_tank && active && pulse_strength > RAD_COLLECTOR_EFFICIENCY)
+		stored_power += (pulse_strength-RAD_COLLECTOR_EFFICIENCY)*RAD_COLLECTOR_COEFFICIENT
+
+/obj/machinery/power/rad_collector/proc/update_icons()
+	cut_overlays()
+	if(loaded_tank)
+		add_overlay("ptank")
+	if(stat & (NOPOWER|BROKEN))
+		return
+	if(active)
+		add_overlay("on")
+
+
+/obj/machinery/power/rad_collector/proc/toggle_power()
+	active = !active
+	if(active)
+		icon_state = "ca_on"
+		flick("ca_active", src)
+	else
+		icon_state = "ca"
+		flick("ca_deactive", src)
+	update_icons()
+	return
+
+#undef RAD_COLLECTOR_EFFICIENCY
+#undef RAD_COLLECTOR_COEFFICIENT
+#undef RAD_COLLECTOR_STORED_OUT
+#undef RAD_COLLECTOR_MINING_CONVERSION_RATE
+#undef RAD_COLLECTOR_OUTPUT

code/modules/power/singularity/containment_field.dm

@@ -0,0 +1,134 @@
+
+
+/obj/machinery/field/containment
+	name = "containment field"
+	desc = "An energy field."
+	icon = 'icons/obj/singularity.dmi'
+	icon_state = "Contain_F"
+	density = FALSE
+	resistance_flags = INDESTRUCTIBLE | LAVA_PROOF | FIRE_PROOF | UNACIDABLE | ACID_PROOF
+	use_power = NO_POWER_USE
+	interaction_flags_atom = NONE
+	interaction_flags_machine = NONE
+	light_range = 4
+	layer = ABOVE_OBJ_LAYER
+	var/obj/machinery/field/generator/FG1 = null
+	var/obj/machinery/field/generator/FG2 = null
+
+/obj/machinery/field/containment/Destroy()
+	FG1.fields -= src
+	FG2.fields -= src
+	return ..()
+
+//ATTACK HAND IGNORING PARENT RETURN VALUE
+/obj/machinery/field/containment/attack_hand(mob/user)
+	if(get_dist(src, user) > 1)
+		return FALSE
+	else
+		shock(user)
+		return TRUE
+
+/obj/machinery/field/containment/attackby(obj/item/W, mob/user, params)
+	shock(user)
+	return TRUE
+
+/obj/machinery/field/containment/play_attack_sound(damage_amount, damage_type = BRUTE, damage_flag = 0)
+	switch(damage_type)
+		if(BURN)
+			playsound(loc, 'sound/effects/empulse.ogg', 75, 1)
+		if(BRUTE)
+			playsound(loc, 'sound/effects/empulse.ogg', 75, 1)
+
+/obj/machinery/field/containment/blob_act(obj/structure/blob/B)
+	return FALSE
+
+/obj/machinery/field/containment/ex_act(severity, target)
+	return FALSE
+
+/obj/machinery/field/containment/attack_animal(mob/living/simple_animal/M)
+	if(!FG1 || !FG2)
+		qdel(src)
+		return
+	if(ismegafauna(M))
+		M.visible_message("<span class='warning'>[M] glows fiercely as the containment field flickers out!</span>")
+		FG1.calc_power(INFINITY) //rip that 'containment' field
+		M.adjustHealth(-M.obj_damage)
+	else
+		..()
+
+/obj/machinery/field/containment/Crossed(mob/mover)
+	if(isliving(mover))
+		shock(mover)
+
+	if(ismachinery(mover) || isstructure(mover) || ismecha(mover))
+		bump_field(mover)
+
+/obj/machinery/field/containment/proc/set_master(master1,master2)
+	if(!master1 || !master2)
+		return FALSE
+	FG1 = master1
+	FG2 = master2
+	return TRUE
+
+/obj/machinery/field/containment/shock(mob/living/user)
+	if(!FG1 || !FG2)
+		qdel(src)
+		return FALSE
+	..()
+
+/obj/machinery/field/containment/Move()
+	qdel(src)
+	return FALSE
+
+
+// Abstract Field Class
+// Used for overriding certain procs
+
+/obj/machinery/field
+	var/hasShocked = FALSE //Used to add a delay between shocks. In some cases this used to crash servers by spawning hundreds of sparks every second.
+
+/obj/machinery/field/Bumped(atom/movable/mover)
+	if(hasShocked)
+		return
+	if(isliving(mover))
+		shock(mover)
+		return
+	if(ismachinery(mover) || isstructure(mover) || ismecha(mover))
+		bump_field(mover)
+		return
+
+
+/obj/machinery/field/CanPass(atom/movable/mover, turf/target)
+	if(hasShocked || isliving(mover) || ismachinery(mover) || isstructure(mover) || ismecha(mover))
+		return FALSE
+	return ..()
+
+/obj/machinery/field/proc/shock(mob/living/user)
+	var/shock_damage = min(rand(30,40),rand(30,40))
+
+	if(iscarbon(user))
+		user.Knockdown(300)
+		user.electrocute_act(shock_damage, src, 1)
+
+	else if(issilicon(user))
+		if(prob(20))
+			user.Stun(40)
+		user.take_overall_damage(0, shock_damage)
+		user.visible_message("<span class='danger'>[user.name] was shocked by the [src.name]!</span>", \
+		"<span class='userdanger'>Energy pulse detected, system damaged!</span>", \
+		"<span class='italics'>You hear an electrical crack.</span>")
+
+	user.updatehealth()
+	bump_field(user)
+
+/obj/machinery/field/proc/clear_shock()
+	hasShocked = FALSE
+
+/obj/machinery/field/proc/bump_field(atom/movable/AM as mob|obj)
+	if(hasShocked)
+		return FALSE
+	hasShocked = TRUE
+	do_sparks(5, TRUE, AM.loc)
+	var/atom/target = get_edge_target_turf(AM, get_dir(src, get_step_away(AM, src)))
+	AM.throw_at(target, 200, 4)
+	addtimer(CALLBACK(src, .proc/clear_shock), 5)

code/modules/power/singularity/emitter.dm

@@ -0,0 +1,502 @@
+//emitter construction defines
+#define EMITTER_UNWRENCHED 0
+#define EMITTER_WRENCHED 1
+#define EMITTER_WELDED 2
+
+/obj/machinery/power/emitter
+	name = "emitter"
+	desc = "A heavy-duty industrial laser, often used in containment fields and power generation."
+	icon = 'icons/obj/singularity.dmi'
+	icon_state = "emitter"
+
+	anchored = FALSE
+	density = TRUE
+	req_access = list(ACCESS_ENGINE_EQUIP)
+	circuit = /obj/item/circuitboard/machine/emitter
+
+	use_power = NO_POWER_USE
+	idle_power_usage = 10
+	active_power_usage = 300
+
+	var/icon_state_on = "emitter_+a"
+	var/active = FALSE
+	var/powered = FALSE
+	var/fire_delay = 100
+	var/maximum_fire_delay = 100
+	var/minimum_fire_delay = 20
+	var/last_shot = 0
+	var/shot_number = 0
+	var/state = EMITTER_UNWRENCHED
+	var/locked = FALSE
+	var/allow_switch_interact = TRUE
+
+	var/projectile_type = /obj/item/projectile/beam/emitter
+	var/projectile_sound = 'sound/weapons/emitter.ogg'
+	var/datum/effect_system/spark_spread/sparks
+
+	var/obj/item/gun/energy/gun
+	var/list/gun_properties
+	var/mode = 0
+
+	// The following 3 vars are mostly for the prototype
+	var/manual = FALSE
+	var/charge = 0
+	var/last_projectile_params
+
+
+/obj/machinery/power/emitter/anchored
+	anchored = TRUE
+
+/obj/machinery/power/emitter/ctf
+	name = "Energy Cannon"
+	active = TRUE
+	active_power_usage = FALSE
+	idle_power_usage = FALSE
+	locked = TRUE
+	req_access_txt = "100"
+	state = EMITTER_WELDED
+	use_power = FALSE
+
+/obj/machinery/power/emitter/Initialize()
+	. = ..()
+	RefreshParts()
+	wires = new /datum/wires/emitter(src)
+	if(state == EMITTER_WELDED && anchored)
+		connect_to_network()
+
+	sparks = new
+	sparks.attach(src)
+	sparks.set_up(1, TRUE, src)
+
+/obj/machinery/power/emitter/ComponentInitialize()
+	. = ..()
+	AddComponent(/datum/component/empprotection, EMP_PROTECT_SELF | EMP_PROTECT_WIRES)
+
+/obj/machinery/power/emitter/RefreshParts()
+	var/max_firedelay = 120
+	var/firedelay = 120
+	var/min_firedelay = 24
+	var/power_usage = 350
+	for(var/obj/item/stock_parts/micro_laser/L in component_parts)
+		max_firedelay -= 20 * L.rating
+		min_firedelay -= 4 * L.rating
+		firedelay -= 20 * L.rating
+	maximum_fire_delay = max_firedelay
+	minimum_fire_delay = min_firedelay
+	fire_delay = firedelay
+	for(var/obj/item/stock_parts/manipulator/M in component_parts)
+		power_usage -= 50 * M.rating
+	active_power_usage = power_usage
+
+/obj/machinery/power/emitter/ComponentInitialize()
+	. = ..()
+	AddComponent(/datum/component/simple_rotation, ROTATION_ALTCLICK | ROTATION_CLOCKWISE | ROTATION_COUNTERCLOCKWISE | ROTATION_VERBS, null, CALLBACK(src, .proc/can_be_rotated))
+
+/obj/machinery/power/emitter/proc/can_be_rotated(mob/user,rotation_type)
+	if (anchored)
+		to_chat(user, "<span class='warning'>It is fastened to the floor!</span>")
+		return FALSE
+	return TRUE
+
+/obj/machinery/power/emitter/Destroy()
+	if(SSticker.IsRoundInProgress())
+		var/turf/T = get_turf(src)
+		message_admins("Emitter deleted at [ADMIN_VERBOSEJMP(T)]")
+		log_game("Emitter deleted at [AREACOORD(T)]")
+		investigate_log("<font color='red'>deleted</font> at [AREACOORD(T)]", INVESTIGATE_SINGULO)
+	QDEL_NULL(sparks)
+	return ..()
+
+/obj/machinery/power/emitter/update_icon()
+	if (active && powernet && avail(active_power_usage))
+		icon_state = icon_state_on
+	else
+		icon_state = initial(icon_state)
+
+
+/obj/machinery/power/emitter/interact(mob/user)
+	add_fingerprint(user)
+	if(state == EMITTER_WELDED)
+		if(!powernet)
+			to_chat(user, "<span class='warning'>\The [src] isn't connected to a wire!</span>")
+			return TRUE
+		if(!locked && allow_switch_interact)
+			if(active == TRUE)
+				active = FALSE
+				to_chat(user, "<span class='notice'>You turn off [src].</span>")
+			else
+				active = TRUE
+				to_chat(user, "<span class='notice'>You turn on [src].</span>")
+				shot_number = 0
+				fire_delay = maximum_fire_delay
+
+			message_admins("Emitter turned [active ? "ON" : "OFF"] by [ADMIN_LOOKUPFLW(user)] in [ADMIN_VERBOSEJMP(src)]")
+			log_game("Emitter turned [active ? "ON" : "OFF"] by [key_name(user)] in [AREACOORD(src)]")
+			investigate_log("turned [active ? "<font color='green'>ON</font>" : "<font color='red'>OFF</font>"] by [key_name(user)] at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+
+			update_icon()
+
+		else
+			to_chat(user, "<span class='warning'>The controls are locked!</span>")
+	else
+		to_chat(user, "<span class='warning'>[src] needs to be firmly secured to the floor first!</span>")
+		return TRUE
+
+/obj/machinery/power/emitter/attack_animal(mob/living/simple_animal/M)
+	if(ismegafauna(M) && anchored)
+		state = EMITTER_UNWRENCHED
+		anchored = FALSE
+		M.visible_message("<span class='warning'>[M] rips [src] free from its moorings!</span>")
+	else
+		..()
+	if(!anchored)
+		step(src, get_dir(M, src))
+
+/obj/machinery/power/emitter/process()
+	if(stat & (BROKEN))
+		return
+	if(state != EMITTER_WELDED || (!powernet && active_power_usage))
+		active = FALSE
+		update_icon()
+		return
+	if(active == TRUE)
+		if(!active_power_usage || surplus() >= active_power_usage)
+			add_load(active_power_usage)
+			if(!powered)
+				powered = TRUE
+				update_icon()
+				investigate_log("regained power and turned <font color='green'>ON</font> at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+		else
+			if(powered)
+				powered = FALSE
+				update_icon()
+				investigate_log("lost power and turned <font color='red'>OFF</font> at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+				log_game("Emitter lost power in [AREACOORD(src)]")
+			return
+		if(charge <= 80)
+			charge += 5
+		if(!check_delay() || manual == TRUE)
+			return FALSE
+		fire_beam()
+
+/obj/machinery/power/emitter/proc/check_delay()
+	if((src.last_shot + src.fire_delay) <= world.time)
+		return TRUE
+	return FALSE
+
+/obj/machinery/power/emitter/proc/fire_beam_pulse()
+	if(!check_delay())
+		return FALSE
+	if(state != EMITTER_WELDED)
+		return FALSE
+	if(surplus() >= active_power_usage)
+		add_load(active_power_usage)
+		fire_beam()
+
+/obj/machinery/power/emitter/proc/fire_beam(mob/user)
+	var/obj/item/projectile/P = new projectile_type(get_turf(src))
+	playsound(get_turf(src), projectile_sound, 50, TRUE)
+	if(prob(35))
+		sparks.start()
+	P.firer = user ? user : src
+	if(last_projectile_params)
+		P.p_x = last_projectile_params[2]
+		P.p_y = last_projectile_params[3]
+		P.fire(last_projectile_params[1])
+	else
+		P.fire(dir2angle(dir))
+	if(!manual)
+		last_shot = world.time
+		if(shot_number < 3)
+			fire_delay = 20
+			shot_number ++
+		else
+			fire_delay = rand(minimum_fire_delay,maximum_fire_delay)
+			shot_number = 0
+	return P
+
+/obj/machinery/power/emitter/can_be_unfasten_wrench(mob/user, silent)
+	if(active)
+		if(!silent)
+			to_chat(user, "<span class='warning'>Turn \the [src] off first!</span>")
+		return FAILED_UNFASTEN
+
+	else if(state == EMITTER_WELDED)
+		if(!silent)
+			to_chat(user, "<span class='warning'>[src] is welded to the floor!</span>")
+		return FAILED_UNFASTEN
+
+	return ..()
+
+/obj/machinery/power/emitter/default_unfasten_wrench(mob/user, obj/item/I, time = 20)
+	. = ..()
+	if(. == SUCCESSFUL_UNFASTEN)
+		if(anchored)
+			state = EMITTER_WRENCHED
+		else
+			state = EMITTER_UNWRENCHED
+
+/obj/machinery/power/emitter/wrench_act(mob/living/user, obj/item/I)
+	default_unfasten_wrench(user, I)
+	return TRUE
+
+/obj/machinery/power/emitter/welder_act(mob/living/user, obj/item/I)
+	if(active)
+		to_chat(user, "Turn \the [src] off first.")
+		return TRUE
+
+	switch(state)
+		if(EMITTER_UNWRENCHED)
+			to_chat(user, "<span class='warning'>The [src.name] needs to be wrenched to the floor!</span>")
+		if(EMITTER_WRENCHED)
+			if(!I.tool_start_check(user, amount=0))
+				return TRUE
+			user.visible_message("[user.name] starts to weld the [name] to the floor.", \
+				"<span class='notice'>You start to weld \the [src] to the floor...</span>", \
+				"<span class='italics'>You hear welding.</span>")
+			if(I.use_tool(src, user, 20, volume=50))
+				state = EMITTER_WELDED
+				to_chat(user, "<span class='notice'>You weld \the [src] to the floor.</span>")
+				connect_to_network()
+		if(EMITTER_WELDED)
+			if(!I.tool_start_check(user, amount=0))
+				return TRUE
+			user.visible_message("[user.name] starts to cut the [name] free from the floor.", \
+				"<span class='notice'>You start to cut \the [src] free from the floor...</span>", \
+				"<span class='italics'>You hear welding.</span>")
+			if(I.use_tool(src, user, 20, volume=50))
+				state = EMITTER_WRENCHED
+				to_chat(user, "<span class='notice'>You cut \the [src] free from the floor.</span>")
+				disconnect_from_network()
+
+	return TRUE
+
+/obj/machinery/power/emitter/crowbar_act(mob/living/user, obj/item/I)
+	if(panel_open && gun)
+		return remove_gun(user)
+	default_deconstruction_crowbar(I)
+	return TRUE
+
+/obj/machinery/power/emitter/screwdriver_act(mob/living/user, obj/item/I)
+	if(..())
+		return TRUE
+	default_deconstruction_screwdriver(user, "emitter_open", "emitter", I)
+	return TRUE
+
+
+/obj/machinery/power/emitter/attackby(obj/item/I, mob/user, params)
+	if(I.GetID())
+		if(obj_flags & EMAGGED)
+			to_chat(user, "<span class='warning'>The lock seems to be broken!</span>")
+			return
+		if(allowed(user))
+			if(active)
+				locked = !locked
+				to_chat(user, "<span class='notice'>You [src.locked ? "lock" : "unlock"] the controls.</span>")
+			else
+				to_chat(user, "<span class='warning'>The controls can only be locked when \the [src] is online!</span>")
+		else
+			to_chat(user, "<span class='danger'>Access denied.</span>")
+		return
+
+	else if(is_wire_tool(I) && panel_open)
+		wires.interact(user)
+		return
+	else if(panel_open && !gun && istype(I,/obj/item/gun/energy))
+		if(integrate(I,user))
+			return
+	return ..()
+
+/obj/machinery/power/emitter/proc/integrate(obj/item/gun/energy/E,mob/user)
+	if(istype(E, /obj/item/gun/energy))
+		if(!user.transferItemToLoc(E, src))
+			return
+		gun = E
+		gun_properties = gun.get_turret_properties()
+		set_projectile()
+		return TRUE
+
+/obj/machinery/power/emitter/proc/remove_gun(mob/user)
+	if(!gun)
+		return
+	user.put_in_hands(gun)
+	gun = null
+	playsound(src, 'sound/items/deconstruct.ogg', 50, 1)
+	gun_properties = list()
+	set_projectile()
+	return TRUE
+
+/obj/machinery/power/emitter/proc/set_projectile()
+	if(LAZYLEN(gun_properties))
+		if(mode || !gun_properties["lethal_projectile"])
+			projectile_type = gun_properties["stun_projectile"]
+			projectile_sound = gun_properties["stun_projectile_sound"]
+		else
+			projectile_type = gun_properties["lethal_projectile"]
+			projectile_sound = gun_properties["lethal_projectile_sound"]
+		return
+	projectile_type = initial(projectile_type)
+	projectile_sound = initial(projectile_sound)
+
+/obj/machinery/power/emitter/emag_act(mob/user)
+	if(obj_flags & EMAGGED)
+		return
+	locked = FALSE
+	obj_flags |= EMAGGED
+	if(user)
+		user.visible_message("[user.name] emags [src].","<span class='notice'>You short out the lock.</span>")
+
+
+/obj/machinery/power/emitter/prototype
+	name = "Prototype Emitter"
+	icon = 'icons/obj/turrets.dmi'
+	icon_state = "protoemitter"
+	icon_state_on = "protoemitter_+a"
+	can_buckle = TRUE
+	buckle_lying = FALSE
+	var/view_range = 12
+	var/datum/action/innate/protoemitter/firing/auto
+
+//BUCKLE HOOKS
+
+/obj/machinery/power/emitter/prototype/unbuckle_mob(mob/living/buckled_mob,force = 0)
+	playsound(src,'sound/mecha/mechmove01.ogg', 50, TRUE)
+	manual = FALSE
+	for(var/obj/item/I in buckled_mob.held_items)
+		if(istype(I, /obj/item/turret_control))
+			qdel(I)
+	if(istype(buckled_mob))
+		buckled_mob.pixel_x = 0
+		buckled_mob.pixel_y = 0
+		if(buckled_mob.client)
+			buckled_mob.client.change_view(CONFIG_GET(string/default_view))
+	auto.Remove(buckled_mob)
+	. = ..()
+
+/obj/machinery/power/emitter/prototype/user_buckle_mob(mob/living/M, mob/living/carbon/user)
+	if(user.incapacitated() || !istype(user))
+		return
+	for(var/atom/movable/A in get_turf(src))
+		if(A.density && (A != src && A != M))
+			return
+	M.forceMove(get_turf(src))
+	..()
+	playsound(src,'sound/mecha/mechmove01.ogg', 50, TRUE)
+	M.pixel_y = 14
+	layer = 4.1
+	if(M.client)
+		M.client.change_view(view_range)
+	if(!auto)
+		auto = new()
+	auto.Grant(M, src)
+
+/datum/action/innate/protoemitter
+	check_flags = AB_CHECK_RESTRAINED | AB_CHECK_STUN | AB_CHECK_CONSCIOUS
+	var/obj/machinery/power/emitter/prototype/PE
+	var/mob/living/carbon/U
+
+
+/datum/action/innate/protoemitter/Grant(mob/living/carbon/L, obj/machinery/power/emitter/prototype/proto)
+	PE = proto
+	U = L
+	. = ..()
+
+/datum/action/innate/protoemitter/firing
+	name = "Switch to Manual Firing"
+	desc = "The emitter will only fire on your command and at your designated target"
+	button_icon_state = "mech_zoom_on"
+
+/datum/action/innate/protoemitter/firing/Activate()
+	if(PE.manual)
+		playsound(PE,'sound/mecha/mechmove01.ogg', 50, TRUE)
+		PE.manual = FALSE
+		name = "Switch to Manual Firing"
+		desc = "The emitter will only fire on your command and at your designated target"
+		button_icon_state = "mech_zoom_on"
+		for(var/obj/item/I in U.held_items)
+			if(istype(I, /obj/item/turret_control))
+				qdel(I)
+		UpdateButtonIcon()
+		return
+	else
+		playsound(PE,'sound/mecha/mechmove01.ogg', 50, TRUE)
+		name = "Switch to Automatic Firing"
+		desc = "Emitters will switch to periodic firing at your last target"
+		button_icon_state = "mech_zoom_off"
+		PE.manual = TRUE
+		for(var/V in U.held_items)
+			var/obj/item/I = V
+			if(istype(I))
+				if(U.dropItemToGround(I))
+					var/obj/item/turret_control/TC = new /obj/item/turret_control()
+					U.put_in_hands(TC)
+			else	//Entries in the list should only ever be items or null, so if it's not an item, we can assume it's an empty hand
+				var/obj/item/turret_control/TC = new /obj/item/turret_control()
+				U.put_in_hands(TC)
+		UpdateButtonIcon()
+
+
+/obj/item/turret_control
+	name = "turret controls"
+	icon_state = "offhand"
+	w_class = WEIGHT_CLASS_HUGE
+	item_flags = ABSTRACT | NOBLUDGEON
+	resistance_flags = FIRE_PROOF | UNACIDABLE | ACID_PROOF
+	var/delay = 0
+
+/obj/item/turret_control/Initialize()
+	. = ..()
+	ADD_TRAIT(src, TRAIT_NODROP, ABSTRACT_ITEM_TRAIT)
+
+/obj/item/turret_control/afterattack(atom/targeted_atom, mob/user, proxflag, clickparams)
+	. = ..()
+	var/obj/machinery/power/emitter/E = user.buckled
+	E.setDir(get_dir(E,targeted_atom))
+	user.setDir(E.dir)
+	switch(E.dir)
+		if(NORTH)
+			E.layer = 3.9
+			user.pixel_x = 0
+			user.pixel_y = -14
+		if(NORTHEAST)
+			E.layer = 3.9
+			user.pixel_x = -8
+			user.pixel_y = -12
+		if(EAST)
+			E.layer = 4.1
+			user.pixel_x = -14
+			user.pixel_y = 0
+		if(SOUTHEAST)
+			E.layer = 3.9
+			user.pixel_x = -8
+			user.pixel_y = 12
+		if(SOUTH)
+			E.layer = 4.1
+			user.pixel_x = 0
+			user.pixel_y = 14
+		if(SOUTHWEST)
+			E.layer = 3.9
+			user.pixel_x = 8
+			user.pixel_y = 12
+		if(WEST)
+			E.layer = 4.1
+			user.pixel_x = 14
+			user.pixel_y = 0
+		if(NORTHWEST)
+			E.layer = 3.9
+			user.pixel_x = 8
+			user.pixel_y = -12
+
+	E.last_projectile_params = calculate_projectile_angle_and_pixel_offsets(user, clickparams)
+
+	if(E.charge >= 10 && world.time > delay)
+		E.charge -= 10
+		E.fire_beam(user)
+		delay = world.time + 10
+	else if (E.charge < 10)
+		playsound(src,'sound/machines/buzz-sigh.ogg', 50, TRUE)
+
+
+#undef EMITTER_UNWRENCHED
+#undef EMITTER_WRENCHED
+#undef EMITTER_WELDED

code/modules/power/singularity/field_generator.dm

@@ -0,0 +1,353 @@
+
+
+
+/*
+field_generator power level display
+   The icon used for the field_generator need to have 'num_power_levels' number of icon states
+   named 'Field_Gen +p[num]' where 'num' ranges from 1 to 'num_power_levels'
+
+   The power level is displayed using overlays. The current displayed power level is stored in 'powerlevel'.
+   The overlay in use and the powerlevel variable must be kept in sync.  A powerlevel equal to 0 means that
+   no power level overlay is currently in the overlays list.
+   -Aygar
+*/
+
+#define field_generator_max_power 250
+
+#define FG_OFFLINE 0
+#define FG_CHARGING 1
+#define FG_ONLINE 2
+
+//field generator construction defines
+#define FG_UNSECURED 0
+#define FG_SECURED 1
+#define FG_WELDED 2
+
+/obj/machinery/field/generator
+	name = "field generator"
+	desc = "A large thermal battery that projects a high amount of energy when powered."
+	icon = 'icons/obj/machines/field_generator.dmi'
+	icon_state = "Field_Gen"
+	anchored = FALSE
+	density = TRUE
+	use_power = NO_POWER_USE
+	max_integrity = 500
+	//100% immune to lasers and energy projectiles since it absorbs their energy.
+	armor = list("melee" = 25, "bullet" = 10, "laser" = 100, "energy" = 100, "bomb" = 0, "bio" = 0, "rad" = 0, "fire" = 50, "acid" = 70)
+	var/const/num_power_levels = 6	// Total number of power level icon has
+	var/power_level = 0
+	var/active = FG_OFFLINE
+	var/power = 20  // Current amount of power
+	var/state = FG_UNSECURED
+	var/warming_up = 0
+	var/list/obj/machinery/field/containment/fields
+	var/list/obj/machinery/field/generator/connected_gens
+	var/clean_up = 0
+
+/obj/machinery/field/generator/update_icon()
+	cut_overlays()
+	if(warming_up)
+		add_overlay("+a[warming_up]")
+	if(fields.len)
+		add_overlay("+on")
+	if(power_level)
+		add_overlay("+p[power_level]")
+
+
+/obj/machinery/field/generator/Initialize()
+	. = ..()
+	fields = list()
+	connected_gens = list()
+
+/obj/machinery/field/generator/ComponentInitialize()
+	. = ..()
+	AddComponent(/datum/component/empprotection, EMP_PROTECT_SELF | EMP_PROTECT_WIRES)
+
+/obj/machinery/field/generator/process()
+	if(active == FG_ONLINE)
+		calc_power()
+
+/obj/machinery/field/generator/interact(mob/user)
+	if(state == FG_WELDED)
+		if(get_dist(src, user) <= 1)//Need to actually touch the thing to turn it on
+			if(active >= FG_CHARGING)
+				to_chat(user, "<span class='warning'>You are unable to turn off [src] once it is online!</span>")
+				return 1
+			else
+				user.visible_message("[user] turns on [src].", \
+					"<span class='notice'>You turn on [src].</span>", \
+					"<span class='italics'>You hear heavy droning.</span>")
+				turn_on()
+				investigate_log("<font color='green'>activated</font> by [key_name(user)].", INVESTIGATE_SINGULO)
+
+				add_fingerprint(user)
+	else
+		to_chat(user, "<span class='warning'>[src] needs to be firmly secured to the floor first!</span>")
+
+/obj/machinery/field/generator/can_be_unfasten_wrench(mob/user, silent)
+	if(active)
+		if(!silent)
+			to_chat(user, "<span class='warning'>Turn \the [src] off first!</span>")
+		return FAILED_UNFASTEN
+
+	else if(state == FG_WELDED)
+		if(!silent)
+			to_chat(user, "<span class='warning'>[src] is welded to the floor!</span>")
+		return FAILED_UNFASTEN
+
+	return ..()
+
+/obj/machinery/field/generator/default_unfasten_wrench(mob/user, obj/item/I, time = 20)
+	. = ..()
+	if(. == SUCCESSFUL_UNFASTEN)
+		if(anchored)
+			state = FG_SECURED
+		else
+			state = FG_UNSECURED
+
+/obj/machinery/field/generator/wrench_act(mob/living/user, obj/item/I)
+	default_unfasten_wrench(user, I)
+	return TRUE
+
+/obj/machinery/field/generator/welder_act(mob/living/user, obj/item/I)
+	if(active)
+		to_chat(user, "<span class='warning'>[src] needs to be off!</span>")
+		return TRUE
+
+	switch(state)
+		if(FG_UNSECURED)
+			to_chat(user, "<span class='warning'>[src] needs to be wrenched to the floor!</span>")
+
+		if(FG_SECURED)
+			if(!I.tool_start_check(user, amount=0))
+				return TRUE
+			user.visible_message("[user] starts to weld [src] to the floor.", \
+				"<span class='notice'>You start to weld \the [src] to the floor...</span>", \
+				"<span class='italics'>You hear welding.</span>")
+			if(I.use_tool(src, user, 20, volume=50) && state == FG_SECURED)
+				state = FG_WELDED
+				to_chat(user, "<span class='notice'>You weld the field generator to the floor.</span>")
+
+		if(FG_WELDED)
+			if(!I.tool_start_check(user, amount=0))
+				return TRUE
+			user.visible_message("[user] starts to cut [src] free from the floor.", \
+				"<span class='notice'>You start to cut \the [src] free from the floor...</span>", \
+				"<span class='italics'>You hear welding.</span>")
+			if(I.use_tool(src, user, 20, volume=50) && state == FG_WELDED)
+				state = FG_SECURED
+				to_chat(user, "<span class='notice'>You cut \the [src] free from the floor.</span>")
+
+	return TRUE
+
+
+/obj/machinery/field/generator/attack_animal(mob/living/simple_animal/M)
+	if(M.environment_smash & ENVIRONMENT_SMASH_RWALLS && active == FG_OFFLINE && state != FG_UNSECURED)
+		state = FG_UNSECURED
+		anchored = FALSE
+		M.visible_message("<span class='warning'>[M] rips [src] free from its moorings!</span>")
+	else
+		..()
+	if(!anchored)
+		step(src, get_dir(M, src))
+
+/obj/machinery/field/generator/blob_act(obj/structure/blob/B)
+	if(active)
+		return 0
+	else
+		..()
+
+/obj/machinery/field/generator/bullet_act(obj/item/projectile/Proj)
+	if(Proj.flag != "bullet")
+		power = min(power + Proj.damage, field_generator_max_power)
+		check_power_level()
+	..()
+
+
+/obj/machinery/field/generator/Destroy()
+	cleanup()
+	return ..()
+
+
+/obj/machinery/field/generator/proc/check_power_level()
+	var/new_level = round(num_power_levels * power / field_generator_max_power)
+	if(new_level != power_level)
+		power_level = new_level
+		update_icon()
+
+/obj/machinery/field/generator/proc/turn_off()
+	active = FG_OFFLINE
+	spawn(1)
+		cleanup()
+		while (warming_up>0 && !active)
+			sleep(50)
+			warming_up--
+			update_icon()
+
+/obj/machinery/field/generator/proc/turn_on()
+	active = FG_CHARGING
+	spawn(1)
+		while (warming_up<3 && active)
+			sleep(50)
+			warming_up++
+			update_icon()
+			if(warming_up >= 3)
+				start_fields()
+
+
+/obj/machinery/field/generator/proc/calc_power(set_power_draw)
+	var/power_draw = 2 + fields.len
+	if(set_power_draw)
+		power_draw = set_power_draw
+
+	if(draw_power(round(power_draw/2,1)))
+		check_power_level()
+		return 1
+	else
+		visible_message("<span class='danger'>The [name] shuts down!</span>", "<span class='italics'>You hear something shutting down.</span>")
+		turn_off()
+		investigate_log("ran out of power and <font color='red'>deactivated</font>", INVESTIGATE_SINGULO)
+		power = 0
+		check_power_level()
+		return 0
+
+//This could likely be better, it tends to start loopin if you have a complex generator loop setup.  Still works well enough to run the engine fields will likely recode the field gens and fields sometime -Mport
+/obj/machinery/field/generator/proc/draw_power(draw = 0, failsafe = FALSE, obj/machinery/field/generator/G = null, obj/machinery/field/generator/last = null)
+	if((G && (G == src)) || (failsafe >= 8))//Loopin, set fail
+		return 0
+	else
+		failsafe++
+
+	if(power >= draw)//We have enough power
+		power -= draw
+		return 1
+
+	else//Need more power
+		draw -= power
+		power = 0
+		for(var/CG in connected_gens)
+			var/obj/machinery/field/generator/FG = CG
+			if(FG == last)//We just asked you
+				continue
+			if(G)//Another gen is askin for power and we dont have it
+				if(FG.draw_power(draw,failsafe,G,src))//Can you take the load
+					return 1
+				else
+					return 0
+			else//We are askin another for power
+				if(FG.draw_power(draw,failsafe,src,src))
+					return 1
+				else
+					return 0
+
+
+/obj/machinery/field/generator/proc/start_fields()
+	if(state != FG_WELDED || !anchored)
+		turn_off()
+		return
+	spawn(1)
+		setup_field(1)
+	spawn(2)
+		setup_field(2)
+	spawn(3)
+		setup_field(4)
+	spawn(4)
+		setup_field(8)
+	spawn(5)
+		active = FG_ONLINE
+
+
+/obj/machinery/field/generator/proc/setup_field(NSEW)
+	var/turf/T = loc
+	if(!istype(T))
+		return 0
+
+	var/obj/machinery/field/generator/G = null
+	var/steps = 0
+	if(!NSEW)//Make sure its ran right
+		return 0
+	for(var/dist in 0 to 7) // checks out to 8 tiles away for another generator
+		T = get_step(T, NSEW)
+		if(T.density)//We cant shoot a field though this
+			return 0
+
+		G = locate(/obj/machinery/field/generator) in T
+		if(G)
+			steps -= 1
+			if(!G.active)
+				return 0
+			break
+
+		for(var/TC in T.contents)
+			var/atom/A = TC
+			if(ismob(A))
+				continue
+			if(A.density)
+				return 0
+
+		steps++
+
+	if(!G)
+		return 0
+
+	T = loc
+	for(var/dist in 0 to steps) // creates each field tile
+		var/field_dir = get_dir(T,get_step(G.loc, NSEW))
+		T = get_step(T, NSEW)
+		if(!locate(/obj/machinery/field/containment) in T)
+			var/obj/machinery/field/containment/CF = new(T)
+			CF.set_master(src,G)
+			CF.setDir(field_dir)
+			fields += CF
+			G.fields += CF
+			for(var/mob/living/L in T)
+				CF.Crossed(L)
+
+	connected_gens |= G
+	G.connected_gens |= src
+	update_icon()
+
+
+/obj/machinery/field/generator/proc/cleanup()
+	clean_up = 1
+	for (var/F in fields)
+		qdel(F)
+
+	for(var/CG in connected_gens)
+		var/obj/machinery/field/generator/FG = CG
+		FG.connected_gens -= src
+		if(!FG.clean_up)//Makes the other gens clean up as well
+			FG.cleanup()
+		connected_gens -= FG
+	clean_up = 0
+	update_icon()
+
+	//This is here to help fight the "hurr durr, release singulo cos nobody will notice before the
+	//singulo eats the evidence". It's not fool-proof but better than nothing.
+	//I want to avoid using global variables.
+	spawn(1)
+		var/temp = 1 //stops spam
+		for(var/obj/singularity/O in GLOB.singularities)
+			if(O.last_warning && temp)
+				if((world.time - O.last_warning) > 50) //to stop message-spam
+					temp = 0
+					var/turf/T = get_turf(src)
+					message_admins("A singulo exists and a containment field has failed at [ADMIN_VERBOSEJMP(T)].")
+					investigate_log("has <font color='red'>failed</font> whilst a singulo exists at [AREACOORD(T)].", INVESTIGATE_SINGULO)
+			O.last_warning = world.time
+
+/obj/machinery/field/generator/shock(mob/living/user)
+	if(fields.len)
+		..()
+
+/obj/machinery/field/generator/bump_field(atom/movable/AM as mob|obj)
+	if(fields.len)
+		..()
+
+#undef FG_UNSECURED
+#undef FG_SECURED
+#undef FG_WELDED
+
+#undef FG_OFFLINE
+#undef FG_CHARGING
+#undef FG_ONLINE

code/modules/power/singularity/generator.dm

@@ -0,0 +1,35 @@
+/////SINGULARITY SPAWNER
+/obj/machinery/the_singularitygen
+	name = "Gravitational Singularity Generator"
+	desc = "An odd device which produces a Gravitational Singularity when set up."
+	icon = 'icons/obj/singularity.dmi'
+	icon_state = "TheSingGen"
+	anchored = FALSE
+	density = TRUE
+	use_power = NO_POWER_USE
+	resistance_flags = FIRE_PROOF
+
+	// You can buckle someone to the singularity generator, then start the engine. Fun!
+	can_buckle = TRUE
+	buckle_lying = FALSE
+	buckle_requires_restraints = TRUE
+
+	var/energy = 0
+	var/creation_type = /obj/singularity
+
+/obj/machinery/the_singularitygen/attackby(obj/item/W, mob/user, params)
+	if(istype(W, /obj/item/wrench))
+		default_unfasten_wrench(user, W, 0)
+	else
+		return ..()
+
+/obj/machinery/the_singularitygen/process()
+	if(energy > 0)
+		if(energy >= 200)
+			var/turf/T = get_turf(src)
+			SSblackbox.record_feedback("tally", "engine_started", 1, type)
+			var/obj/singularity/S = new creation_type(T, 50)
+			transfer_fingerprints_to(S)
+			qdel(src)
+		else
+			energy -= 1

code/modules/power/singularity/investigate.dm

@@ -0,0 +1,4 @@
+/area/engine/engineering/poweralert(state, source)
+	if (state != poweralm)
+		investigate_log("has a power alarm!", INVESTIGATE_SINGULO)
+	..()

code/modules/power/singularity/narsie.dm

@@ -0,0 +1,220 @@
+/obj/singularity/narsie //Moving narsie to a child object of the singularity so it can be made to function differently. --NEO
+	name = "Nar'Sie's Avatar"
+	desc = "Your mind begins to bubble and ooze as it tries to comprehend what it sees."
+	icon = 'icons/obj/magic_terror.dmi'
+	pixel_x = -89
+	pixel_y = -85
+	density = FALSE
+	current_size = 9 //It moves/eats like a max-size singulo, aside from range. --NEO
+	contained = 0 //Are we going to move around?
+	dissipate = 0 //Do we lose energy over time?
+	move_self = 1 //Do we move on our own?
+	grav_pull = 5 //How many tiles out do we pull?
+	consume_range = 6 //How many tiles out do we eat
+	light_power = 0.7
+	light_range = 15
+	light_color = rgb(255, 0, 0)
+	gender = FEMALE
+	var/clashing = FALSE //If Nar'Sie is fighting Ratvar
+
+/obj/singularity/narsie/large
+	name = "Nar'Sie"
+	icon = 'icons/obj/narsie.dmi'
+	// Pixel stuff centers Narsie.
+	pixel_x = -236
+	pixel_y = -256
+	current_size = 12
+	grav_pull = 10
+	consume_range = 12 //How many tiles out do we eat
+
+/obj/singularity/narsie/large/Initialize()
+	. = ..()
+	send_to_playing_players("<span class='narsie'>NAR'SIE HAS RISEN</span>")
+	sound_to_playing_players('sound/creatures/narsie_rises.ogg')
+
+	var/area/A = get_area(src)
+	if(A)
+		var/mutable_appearance/alert_overlay = mutable_appearance('icons/effects/cult_effects.dmi', "ghostalertsie")
+		notify_ghosts("Nar'Sie has risen in \the [A.name]. Reach out to the Geometer to be given a new shell for your soul.", source = src, alert_overlay = alert_overlay, action=NOTIFY_ATTACK)
+	INVOKE_ASYNC(src, .proc/narsie_spawn_animation)
+
+/obj/singularity/narsie/large/cult  // For the new cult ending, guaranteed to end the round within 3 minutes
+	var/list/souls_needed = list()
+	var/soul_goal = 0
+	var/souls = 0
+	var/resolved = FALSE
+
+/obj/singularity/narsie/large/cult/Initialize()
+	. = ..()
+	GLOB.cult_narsie = src
+	var/list/all_cults = list()
+	for(var/datum/antagonist/cult/C in GLOB.antagonists)
+		if(!C.owner)
+			continue
+		all_cults |= C.cult_team
+	for(var/datum/team/cult/T in all_cults)
+		deltimer(T.blood_target_reset_timer)
+		T.blood_target = src
+		var/datum/objective/eldergod/summon_objective = locate() in T.objectives
+		if(summon_objective)
+			summon_objective.summoned = TRUE
+	for(var/datum/mind/cult_mind in SSticker.mode.cult)
+		if(isliving(cult_mind.current))
+			var/mob/living/L = cult_mind.current
+			L.narsie_act()
+	for(var/mob/living/player in GLOB.player_list)
+		if(player.stat != DEAD && player.loc && is_station_level(player.loc.z) && !iscultist(player) && !isanimal(player))
+			souls_needed[player] = TRUE
+	soul_goal = round(1 + LAZYLEN(souls_needed) * 0.75)
+	INVOKE_ASYNC(src, .proc/begin_the_end)
+
+/obj/singularity/narsie/large/cult/proc/begin_the_end()
+	sleep(50)
+	priority_announce("An acausal dimensional event has been detected in your sector. Event has been flagged EXTINCTION-CLASS. Directing all available assets toward simulating solutions. SOLUTION ETA: 60 SECONDS.","Central Command Higher Dimensional Affairs", 'sound/misc/airraid.ogg')
+	sleep(500)
+	priority_announce("Simulations on acausal dimensional event complete. Deploying solution package now. Deployment ETA: ONE MINUTE. ","Central Command Higher Dimensional Affairs")
+	sleep(50)
+	set_security_level("delta")
+	SSshuttle.registerHostileEnvironment(src)
+	SSshuttle.lockdown = TRUE
+	sleep(600)
+	if(resolved == FALSE)
+		resolved = TRUE
+		sound_to_playing_players('sound/machines/alarm.ogg')
+		addtimer(CALLBACK(GLOBAL_PROC, .proc/cult_ending_helper), 120)
+
+/obj/singularity/narsie/large/cult/Destroy()
+	GLOB.cult_narsie = null
+	return ..()
+
+/proc/ending_helper()
+	SSticker.force_ending = 1
+
+/proc/cult_ending_helper(var/no_explosion = 0)
+	if(no_explosion)
+		Cinematic(CINEMATIC_CULT,world,CALLBACK(GLOBAL_PROC,/proc/ending_helper))
+	else
+		Cinematic(CINEMATIC_CULT_NUKE,world,CALLBACK(GLOBAL_PROC,/proc/ending_helper))
+
+//ATTACK GHOST IGNORING PARENT RETURN VALUE
+/obj/singularity/narsie/large/attack_ghost(mob/dead/observer/user as mob)
+	makeNewConstruct(/mob/living/simple_animal/hostile/construct/harvester, user, cultoverride = TRUE, loc_override = src.loc)
+
+/obj/singularity/narsie/process()
+	if(clashing)
+		return
+	eat()
+	if(!target || prob(5))
+		pickcultist()
+	if(istype(target, /obj/structure/destructible/clockwork/massive/ratvar))
+		move(get_dir(src, target)) //Oh, it's you again.
+	else
+		move()
+	if(prob(25))
+		mezzer()
+
+
+/obj/singularity/narsie/Process_Spacemove()
+	return clashing
+
+
+/obj/singularity/narsie/Bump(atom/A)
+	var/turf/T = get_turf(A)
+	if(T == loc)
+		T = get_step(A, A.dir) //please don't slam into a window like a bird, Nar'Sie
+	forceMove(T)
+
+
+/obj/singularity/narsie/mezzer()
+	for(var/mob/living/carbon/M in viewers(consume_range, src))
+		if(M.stat == CONSCIOUS)
+			if(!iscultist(M))
+				to_chat(M, "<span class='cultsmall'>You feel conscious thought crumble away in an instant as you gaze upon [src.name]...</span>")
+				M.apply_effect(60, EFFECT_STUN)
+
+
+/obj/singularity/narsie/consume(atom/A)
+	if(isturf(A))
+		A.narsie_act()
+
+
+/obj/singularity/narsie/ex_act() //No throwing bombs at her either.
+	return
+
+
+/obj/singularity/narsie/proc/pickcultist() //Narsie rewards her cultists with being devoured first, then picks a ghost to follow.
+	var/list/cultists = list()
+	var/list/noncultists = list()
+	for(var/obj/structure/destructible/clockwork/massive/ratvar/enemy in GLOB.poi_list) //Prioritize killing Ratvar
+		if(enemy.z != z)
+			continue
+		acquire(enemy)
+		return
+
+	for(var/mob/living/carbon/food in GLOB.alive_mob_list) //we don't care about constructs or cult-Ians or whatever. cult-monkeys are fair game i guess
+		var/turf/pos = get_turf(food)
+		if(!pos || (pos.z != z))
+			continue
+
+		if(iscultist(food))
+			cultists += food
+		else
+			noncultists += food
+
+		if(cultists.len) //cultists get higher priority
+			acquire(pick(cultists))
+			return
+
+		if(noncultists.len)
+			acquire(pick(noncultists))
+			return
+
+	//no living humans, follow a ghost instead.
+	for(var/mob/dead/observer/ghost in GLOB.player_list)
+		if(!ghost.client)
+			continue
+		var/turf/pos = get_turf(ghost)
+		if(!pos || (pos.z != z))
+			continue
+		cultists += ghost
+	if(cultists.len)
+		acquire(pick(cultists))
+		return
+
+
+/obj/singularity/narsie/proc/acquire(atom/food)
+	if(food == target)
+		return
+	to_chat(target, "<span class='cultsmall'>NAR'SIE HAS LOST INTEREST IN YOU.</span>")
+	target = food
+	if(ishuman(target))
+		to_chat(target, "<span class ='cult'>NAR'SIE HUNGERS FOR YOUR SOUL.</span>")
+	else
+		to_chat(target, "<span class ='cult'>NAR'SIE HAS CHOSEN YOU TO LEAD HER TO HER NEXT MEAL.</span>")
+
+//Wizard narsie
+/obj/singularity/narsie/wizard
+	grav_pull = 0
+
+/obj/singularity/narsie/wizard/eat()
+//	if(defer_powernet_rebuild != 2)
+//		defer_powernet_rebuild = 1
+	for(var/atom/X in urange(consume_range,src,1))
+		if(isturf(X) || ismovableatom(X))
+			consume(X)
+//	if(defer_powernet_rebuild != 2)
+//		defer_powernet_rebuild = 0
+	return
+
+
+/obj/singularity/narsie/proc/narsie_spawn_animation()
+	icon = 'icons/obj/narsie_spawn_anim.dmi'
+	setDir(SOUTH)
+	move_self = 0
+	flick("narsie_spawn_anim",src)
+	sleep(11)
+	move_self = 1
+	icon = initial(icon)
+
+
+

code/modules/power/singularity/particle_accelerator/particle.dm

@@ -0,0 +1,68 @@
+/obj/effect/accelerated_particle
+	name = "Accelerated Particles"
+	desc = "Small things moving very fast."
+	icon = 'icons/obj/machines/particle_accelerator.dmi'
+	icon_state = "particle"
+	anchored = TRUE
+	density = FALSE
+	var/movement_range = 10
+	var/energy = 10
+	var/speed = 1
+
+/obj/effect/accelerated_particle/weak
+	movement_range = 8
+	energy = 5
+
+/obj/effect/accelerated_particle/strong
+	movement_range = 15
+	energy = 15
+
+/obj/effect/accelerated_particle/powerful
+	movement_range = 20
+	energy = 50
+
+
+/obj/effect/accelerated_particle/New(loc)
+	..()
+
+	addtimer(CALLBACK(src, .proc/move), 1)
+
+
+/obj/effect/accelerated_particle/Bump(atom/A)
+	if(A)
+		if(isliving(A))
+			toxmob(A)
+		else if(istype(A, /obj/machinery/the_singularitygen))
+			var/obj/machinery/the_singularitygen/S = A
+			S.energy += energy
+		else if(istype(A, /obj/singularity))
+			var/obj/singularity/S = A
+			S.energy += energy
+		else if(istype(A, /obj/structure/blob))
+			var/obj/structure/blob/B = A
+			B.take_damage(energy*0.6)
+			movement_range = 0
+
+/obj/effect/accelerated_particle/Crossed(atom/A)
+	if(isliving(A))
+		toxmob(A)
+
+
+/obj/effect/accelerated_particle/ex_act(severity, target)
+	qdel(src)
+
+/obj/effect/accelerated_particle/singularity_pull()
+	return
+
+/obj/effect/accelerated_particle/proc/toxmob(mob/living/M)
+	M.rad_act(energy*6)
+
+/obj/effect/accelerated_particle/proc/move()
+	if(!step(src,dir))
+		forceMove(get_step(src,dir))
+	movement_range--
+	if(movement_range == 0)
+		qdel(src)
+	else
+		sleep(speed)
+		move()

code/modules/power/singularity/particle_accelerator/particle_accelerator.dm

@@ -0,0 +1,173 @@
+/*Composed of 7 parts :
+
+ 3 Particle Emitters
+ 1 Power Box
+ 1 Fuel Chamber
+ 1 End Cap
+ 1 Control computer
+
+ Setup map
+
+   |EC|
+ CC|FC|
+   |PB|
+ PE|PE|PE
+
+*/
+#define PA_CONSTRUCTION_UNSECURED  0
+#define PA_CONSTRUCTION_UNWIRED    1
+#define PA_CONSTRUCTION_PANEL_OPEN 2
+#define PA_CONSTRUCTION_COMPLETE   3
+
+/obj/structure/particle_accelerator
+	name = "Particle Accelerator"
+	desc = "Part of a Particle Accelerator."
+	icon = 'icons/obj/machines/particle_accelerator.dmi'
+	icon_state = "none"
+	anchored = FALSE
+	density = TRUE
+	max_integrity = 500
+	armor = list("melee" = 30, "bullet" = 20, "laser" = 20, "energy" = 0, "bomb" = 0, "bio" = 0, "rad" = 0, "fire" = 90, "acid" = 80)
+
+	var/obj/machinery/particle_accelerator/control_box/master = null
+	var/construction_state = PA_CONSTRUCTION_UNSECURED
+	var/reference = null
+	var/powered = 0
+	var/strength = null
+
+/obj/structure/particle_accelerator/examine(mob/user)
+	..()
+
+	switch(construction_state)
+		if(PA_CONSTRUCTION_UNSECURED)
+			to_chat(user, "Looks like it's not attached to the flooring.")
+		if(PA_CONSTRUCTION_UNWIRED)
+			to_chat(user, "It is missing some cables.")
+		if(PA_CONSTRUCTION_PANEL_OPEN)
+			to_chat(user, "The panel is open.")
+
+/obj/structure/particle_accelerator/Destroy()
+	construction_state = PA_CONSTRUCTION_UNSECURED
+	if(master)
+		master.connected_parts -= src
+		master.assembled = 0
+		master = null
+	return ..()
+
+/obj/structure/particle_accelerator/ComponentInitialize()
+	. = ..()
+	AddComponent(/datum/component/simple_rotation,ROTATION_ALTCLICK | ROTATION_CLOCKWISE | ROTATION_COUNTERCLOCKWISE | ROTATION_VERBS )
+
+
+/obj/structure/particle_accelerator/attackby(obj/item/W, mob/user, params)
+	var/did_something = FALSE
+
+	switch(construction_state)
+		if(PA_CONSTRUCTION_UNSECURED)
+			if(istype(W, /obj/item/wrench) && !isinspace())
+				W.play_tool_sound(src, 75)
+				anchored = TRUE
+				user.visible_message("[user.name] secures the [name] to the floor.", \
+					"You secure the external bolts.")
+				construction_state = PA_CONSTRUCTION_UNWIRED
+				did_something = TRUE
+		if(PA_CONSTRUCTION_UNWIRED)
+			if(istype(W, /obj/item/wrench))
+				W.play_tool_sound(src, 75)
+				anchored = FALSE
+				user.visible_message("[user.name] detaches the [name] from the floor.", \
+					"You remove the external bolts.")
+				construction_state = PA_CONSTRUCTION_UNSECURED
+				did_something = TRUE
+			else if(istype(W, /obj/item/stack/cable_coil))
+				var/obj/item/stack/cable_coil/CC = W
+				if(CC.use(1))
+					user.visible_message("[user.name] adds wires to the [name].", \
+						"You add some wires.")
+					construction_state = PA_CONSTRUCTION_PANEL_OPEN
+					did_something = TRUE
+		if(PA_CONSTRUCTION_PANEL_OPEN)
+			if(istype(W, /obj/item/wirecutters))//TODO:Shock user if its on?
+				user.visible_message("[user.name] removes some wires from the [name].", \
+					"You remove some wires.")
+				construction_state = PA_CONSTRUCTION_UNWIRED
+				did_something = TRUE
+			else if(istype(W, /obj/item/screwdriver))
+				user.visible_message("[user.name] closes the [name]'s access panel.", \
+					"You close the access panel.")
+				construction_state = PA_CONSTRUCTION_COMPLETE
+				did_something = TRUE
+		if(PA_CONSTRUCTION_COMPLETE)
+			if(istype(W, /obj/item/screwdriver))
+				user.visible_message("[user.name] opens the [name]'s access panel.", \
+					"You open the access panel.")
+				construction_state = PA_CONSTRUCTION_PANEL_OPEN
+				did_something = TRUE
+
+	if(did_something)
+		user.changeNext_move(CLICK_CD_MELEE)
+		update_state()
+		update_icon()
+		return
+
+	return ..()
+
+
+/obj/structure/particle_accelerator/deconstruct(disassembled = TRUE)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		new /obj/item/stack/sheet/metal (loc, 5)
+	qdel(src)
+
+/obj/structure/particle_accelerator/Move()
+	. = ..()
+	if(master && master.active)
+		master.toggle_power()
+		investigate_log("was moved whilst active; it <font color='red'>powered down</font>.", INVESTIGATE_SINGULO)
+
+
+/obj/structure/particle_accelerator/update_icon()
+	switch(construction_state)
+		if(PA_CONSTRUCTION_UNSECURED,PA_CONSTRUCTION_UNWIRED)
+			icon_state="[reference]"
+		if(PA_CONSTRUCTION_PANEL_OPEN)
+			icon_state="[reference]w"
+		if(PA_CONSTRUCTION_COMPLETE)
+			if(powered)
+				icon_state="[reference]p[strength]"
+			else
+				icon_state="[reference]c"
+
+/obj/structure/particle_accelerator/proc/update_state()
+	if(master)
+		master.update_state()
+
+/obj/structure/particle_accelerator/proc/connect_master(obj/O)
+	if(O.dir == dir)
+		master = O
+		return 1
+	return 0
+
+///////////
+// PARTS //
+///////////
+
+
+/obj/structure/particle_accelerator/end_cap
+	name = "Alpha Particle Generation Array"
+	desc = "This is where Alpha particles are generated from \[REDACTED\]."
+	icon_state = "end_cap"
+	reference = "end_cap"
+
+/obj/structure/particle_accelerator/power_box
+	name = "Particle Focusing EM Lens"
+	desc = "This uses electromagnetic waves to focus the Alpha particles."
+	icon = 'icons/obj/machines/particle_accelerator.dmi'
+	icon_state = "power_box"
+	reference = "power_box"
+
+/obj/structure/particle_accelerator/fuel_chamber
+	name = "EM Acceleration Chamber"
+	desc = "This is where the Alpha particles are accelerated to <b><i>radical speeds</i></b>."
+	icon = 'icons/obj/machines/particle_accelerator.dmi'
+	icon_state = "fuel_chamber"
+	reference = "fuel_chamber"

code/modules/power/singularity/particle_accelerator/particle_control.dm

@@ -0,0 +1,330 @@
+/obj/machinery/particle_accelerator/control_box
+	name = "Particle Accelerator Control Console"
+	desc = "This controls the density of the particles."
+	icon = 'icons/obj/machines/particle_accelerator.dmi'
+	icon_state = "control_box"
+	anchored = FALSE
+	density = TRUE
+	use_power = NO_POWER_USE
+	idle_power_usage = 500
+	active_power_usage = 10000
+	dir = NORTH
+	var/strength_upper_limit = 2
+	var/interface_control = 1
+	var/list/obj/structure/particle_accelerator/connected_parts
+	var/assembled = 0
+	var/construction_state = PA_CONSTRUCTION_UNSECURED
+	var/active = 0
+	var/strength = 0
+	var/powered = 0
+	mouse_opacity = MOUSE_OPACITY_OPAQUE
+
+/obj/machinery/particle_accelerator/control_box/Initialize()
+	. = ..()
+	wires = new /datum/wires/particle_accelerator/control_box(src)
+	connected_parts = list()
+
+/obj/machinery/particle_accelerator/control_box/Destroy()
+	if(active)
+		toggle_power()
+	for(var/CP in connected_parts)
+		var/obj/structure/particle_accelerator/part = CP
+		part.master = null
+	connected_parts.Cut()
+	QDEL_NULL(wires)
+	return ..()
+
+/obj/machinery/particle_accelerator/control_box/attack_hand(mob/user)
+	. = ..()
+	if(.)
+		return
+	if(construction_state == PA_CONSTRUCTION_COMPLETE)
+		interact(user)
+	else if(construction_state == PA_CONSTRUCTION_PANEL_OPEN)
+		wires.interact(user)
+
+/obj/machinery/particle_accelerator/control_box/proc/update_state()
+	if(construction_state < PA_CONSTRUCTION_COMPLETE)
+		use_power = NO_POWER_USE
+		assembled = 0
+		active = 0
+		for(var/CP in connected_parts)
+			var/obj/structure/particle_accelerator/part = CP
+			part.strength = null
+			part.powered = 0
+			part.update_icon()
+		connected_parts.Cut()
+		return
+	if(!part_scan())
+		use_power = IDLE_POWER_USE
+		active = 0
+		connected_parts.Cut()
+
+/obj/machinery/particle_accelerator/control_box/update_icon()
+	if(active)
+		icon_state = "control_boxp1"
+	else
+		if(use_power)
+			if(assembled)
+				icon_state = "control_boxp"
+			else
+				icon_state = "ucontrol_boxp"
+		else
+			switch(construction_state)
+				if(PA_CONSTRUCTION_UNSECURED, PA_CONSTRUCTION_UNWIRED)
+					icon_state = "control_box"
+				if(PA_CONSTRUCTION_PANEL_OPEN)
+					icon_state = "control_boxw"
+				else
+					icon_state = "control_boxc"
+
+/obj/machinery/particle_accelerator/control_box/Topic(href, href_list)
+	if(..())
+		return
+
+	if(!interface_control)
+		to_chat(usr, "<span class='error'>ERROR: Request timed out. Check wire contacts.</span>")
+		return
+
+	if(href_list["close"])
+		usr << browse(null, "window=pacontrol")
+		usr.unset_machine()
+		return
+	if(href_list["togglep"])
+		if(!wires.is_cut(WIRE_POWER))
+			toggle_power()
+
+	else if(href_list["scan"])
+		part_scan()
+
+	else if(href_list["strengthup"])
+		if(!wires.is_cut(WIRE_STRENGTH))
+			add_strength()
+
+	else if(href_list["strengthdown"])
+		if(!wires.is_cut(WIRE_STRENGTH))
+			remove_strength()
+
+	updateDialog()
+	update_icon()
+
+/obj/machinery/particle_accelerator/control_box/proc/strength_change()
+	for(var/CP in connected_parts)
+		var/obj/structure/particle_accelerator/part = CP
+		part.strength = strength
+		part.update_icon()
+
+/obj/machinery/particle_accelerator/control_box/proc/add_strength(s)
+	if(assembled && (strength < strength_upper_limit))
+		strength++
+		strength_change()
+
+		message_admins("PA Control Computer increased to [strength] by [ADMIN_LOOKUPFLW(usr)] in [ADMIN_VERBOSEJMP(src)]")
+		log_game("PA Control Computer increased to [strength] by [key_name(usr)] in [AREACOORD(src)]")
+		investigate_log("increased to <font color='red'>[strength]</font> by [key_name(usr)] at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+
+
+/obj/machinery/particle_accelerator/control_box/proc/remove_strength(s)
+	if(assembled && (strength > 0))
+		strength--
+		strength_change()
+
+		message_admins("PA Control Computer decreased to [strength] by [ADMIN_LOOKUPFLW(usr)] in [ADMIN_VERBOSEJMP(src)]")
+		log_game("PA Control Computer decreased to [strength] by [key_name(usr)] in [AREACOORD(src)]")
+		investigate_log("decreased to <font color='green'>[strength]</font> by [key_name(usr)] at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+
+
+/obj/machinery/particle_accelerator/control_box/power_change()
+	..()
+	if(stat & NOPOWER)
+		active = 0
+		use_power = NO_POWER_USE
+	else if(!stat && construction_state == PA_CONSTRUCTION_COMPLETE)
+		use_power = IDLE_POWER_USE
+
+/obj/machinery/particle_accelerator/control_box/process()
+	if(active)
+		//a part is missing!
+		if(connected_parts.len < 6)
+			investigate_log("lost a connected part; It <font color='red'>powered down</font>.", INVESTIGATE_SINGULO)
+			toggle_power()
+			update_icon()
+			return
+		//emit some particles
+		for(var/obj/structure/particle_accelerator/particle_emitter/PE in connected_parts)
+			PE.emit_particle(strength)
+
+/obj/machinery/particle_accelerator/control_box/proc/part_scan()
+	var/ldir = turn(dir,-90)
+	var/rdir = turn(dir,90)
+	var/odir = turn(dir,180)
+	var/turf/T = loc
+
+	assembled = 0
+	critical_machine = FALSE
+
+	var/obj/structure/particle_accelerator/fuel_chamber/F = locate() in orange(1,src)
+	if(!F)
+		return 0
+
+	setDir(F.dir)
+	connected_parts.Cut()
+
+	T = get_step(T,rdir)
+	if(!check_part(T, /obj/structure/particle_accelerator/fuel_chamber))
+		return 0
+	T = get_step(T,odir)
+	if(!check_part(T, /obj/structure/particle_accelerator/end_cap))
+		return 0
+	T = get_step(T,dir)
+	T = get_step(T,dir)
+	if(!check_part(T, /obj/structure/particle_accelerator/power_box))
+		return 0
+	T = get_step(T,dir)
+	if(!check_part(T, /obj/structure/particle_accelerator/particle_emitter/center))
+		return 0
+	T = get_step(T,ldir)
+	if(!check_part(T, /obj/structure/particle_accelerator/particle_emitter/left))
+		return 0
+	T = get_step(T,rdir)
+	T = get_step(T,rdir)
+	if(!check_part(T, /obj/structure/particle_accelerator/particle_emitter/right))
+		return 0
+
+	assembled = 1
+	critical_machine = TRUE	//Only counts if the PA is actually assembled.
+	return 1
+
+/obj/machinery/particle_accelerator/control_box/proc/check_part(turf/T, type)
+	var/obj/structure/particle_accelerator/PA = locate(/obj/structure/particle_accelerator) in T
+	if(istype(PA, type) && (PA.construction_state == PA_CONSTRUCTION_COMPLETE))
+		if(PA.connect_master(src))
+			connected_parts.Add(PA)
+			return 1
+	return 0
+
+
+/obj/machinery/particle_accelerator/control_box/proc/toggle_power()
+	active = !active
+	investigate_log("turned [active?"<font color='green'>ON</font>":"<font color='red'>OFF</font>"] by [usr ? key_name(usr) : "outside forces"] at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+	message_admins("PA Control Computer turned [active ?"ON":"OFF"] by [usr ? ADMIN_LOOKUPFLW(usr) : "outside forces"] in [ADMIN_VERBOSEJMP(src)]")
+	log_game("PA Control Computer turned [active ?"ON":"OFF"] by [usr ? "[key_name(usr)]" : "outside forces"] at [AREACOORD(src)]")
+	if(active)
+		use_power = ACTIVE_POWER_USE
+		for(var/CP in connected_parts)
+			var/obj/structure/particle_accelerator/part = CP
+			part.strength = strength
+			part.powered = 1
+			part.update_icon()
+	else
+		use_power = IDLE_POWER_USE
+		for(var/CP in connected_parts)
+			var/obj/structure/particle_accelerator/part = CP
+			part.strength = null
+			part.powered = 0
+			part.update_icon()
+	return 1
+
+
+/obj/machinery/particle_accelerator/control_box/ui_interact(mob/user)
+	. = ..()
+	if((get_dist(src, user) > 1) || (stat & (BROKEN|NOPOWER)))
+		if(!issilicon(user))
+			user.unset_machine()
+			user << browse(null, "window=pacontrol")
+			return
+
+	var/dat = ""
+	dat += "<A href='?src=[REF(src)];close=1'>Close</A><BR><BR>"
+	dat += "<h3>Status</h3>"
+	if(!assembled)
+		dat += "Unable to detect all parts!<BR>"
+		dat += "<A href='?src=[REF(src)];scan=1'>Run Scan</A><BR><BR>"
+	else
+		dat += "All parts in place.<BR><BR>"
+		dat += "Power:"
+		if(active)
+			dat += "On<BR>"
+		else
+			dat += "Off <BR>"
+		dat += "<A href='?src=[REF(src)];togglep=1'>Toggle Power</A><BR><BR>"
+		dat += "Particle Strength: [strength] "
+		dat += "<A href='?src=[REF(src)];strengthdown=1'>--</A>|<A href='?src=[REF(src)];strengthup=1'>++</A><BR><BR>"
+
+	var/datum/browser/popup = new(user, "pacontrol", name, 420, 300)
+	popup.set_content(dat)
+	popup.set_title_image(user.browse_rsc_icon(icon, icon_state))
+	popup.open()
+
+/obj/machinery/particle_accelerator/control_box/examine(mob/user)
+	..()
+	switch(construction_state)
+		if(PA_CONSTRUCTION_UNSECURED)
+			to_chat(user, "Looks like it's not attached to the flooring.")
+		if(PA_CONSTRUCTION_UNWIRED)
+			to_chat(user, "It is missing some cables.")
+		if(PA_CONSTRUCTION_PANEL_OPEN)
+			to_chat(user, "The panel is open.")
+
+
+/obj/machinery/particle_accelerator/control_box/attackby(obj/item/W, mob/user, params)
+	var/did_something = FALSE
+
+	switch(construction_state)
+		if(PA_CONSTRUCTION_UNSECURED)
+			if(istype(W, /obj/item/wrench) && !isinspace())
+				W.play_tool_sound(src, 75)
+				anchored = TRUE
+				user.visible_message("[user.name] secures the [name] to the floor.", \
+					"You secure the external bolts.")
+				construction_state = PA_CONSTRUCTION_UNWIRED
+				did_something = TRUE
+		if(PA_CONSTRUCTION_UNWIRED)
+			if(istype(W, /obj/item/wrench))
+				W.play_tool_sound(src, 75)
+				anchored = FALSE
+				user.visible_message("[user.name] detaches the [name] from the floor.", \
+					"You remove the external bolts.")
+				construction_state = PA_CONSTRUCTION_UNSECURED
+				did_something = TRUE
+			else if(istype(W, /obj/item/stack/cable_coil))
+				var/obj/item/stack/cable_coil/CC = W
+				if(CC.use(1))
+					user.visible_message("[user.name] adds wires to the [name].", \
+						"You add some wires.")
+					construction_state = PA_CONSTRUCTION_PANEL_OPEN
+					did_something = TRUE
+		if(PA_CONSTRUCTION_PANEL_OPEN)
+			if(istype(W, /obj/item/wirecutters))//TODO:Shock user if its on?
+				user.visible_message("[user.name] removes some wires from the [name].", \
+					"You remove some wires.")
+				construction_state = PA_CONSTRUCTION_UNWIRED
+				did_something = TRUE
+			else if(istype(W, /obj/item/screwdriver))
+				user.visible_message("[user.name] closes the [name]'s access panel.", \
+					"You close the access panel.")
+				construction_state = PA_CONSTRUCTION_COMPLETE
+				did_something = TRUE
+		if(PA_CONSTRUCTION_COMPLETE)
+			if(istype(W, /obj/item/screwdriver))
+				user.visible_message("[user.name] opens the [name]'s access panel.", \
+					"You open the access panel.")
+				construction_state = PA_CONSTRUCTION_PANEL_OPEN
+				did_something = TRUE
+
+	if(did_something)
+		user.changeNext_move(CLICK_CD_MELEE)
+		update_state()
+		update_icon()
+		return
+
+	..()
+
+/obj/machinery/particle_accelerator/control_box/blob_act(obj/structure/blob/B)
+	if(prob(50))
+		qdel(src)
+
+#undef PA_CONSTRUCTION_UNSECURED
+#undef PA_CONSTRUCTION_UNWIRED
+#undef PA_CONSTRUCTION_PANEL_OPEN
+#undef PA_CONSTRUCTION_COMPLETE

code/modules/power/singularity/particle_accelerator/particle_emitter.dm

@@ -0,0 +1,43 @@
+/obj/structure/particle_accelerator/particle_emitter
+	name = "EM Containment Grid"
+	desc = "This launches the Alpha particles, might not want to stand near this end."
+	icon = 'icons/obj/machines/particle_accelerator.dmi'
+	icon_state = "none"
+	var/fire_delay = 50
+	var/last_shot = 0
+
+/obj/structure/particle_accelerator/particle_emitter/center
+	icon_state = "emitter_center"
+	reference = "emitter_center"
+
+/obj/structure/particle_accelerator/particle_emitter/left
+	icon_state = "emitter_left"
+	reference = "emitter_left"
+
+/obj/structure/particle_accelerator/particle_emitter/right
+	icon_state = "emitter_right"
+	reference = "emitter_right"
+
+/obj/structure/particle_accelerator/particle_emitter/proc/set_delay(delay)
+	if(delay >= 0)
+		fire_delay = delay
+		return 1
+	return 0
+
+/obj/structure/particle_accelerator/particle_emitter/proc/emit_particle(strength = 0)
+	if((last_shot + fire_delay) <= world.time)
+		last_shot = world.time
+		var/turf/T = get_turf(src)
+		var/obj/effect/accelerated_particle/P
+		switch(strength)
+			if(0)
+				P = new/obj/effect/accelerated_particle/weak(T)
+			if(1)
+				P = new/obj/effect/accelerated_particle(T)
+			if(2)
+				P = new/obj/effect/accelerated_particle/strong(T)
+			if(3)
+				P = new/obj/effect/accelerated_particle/powerful(T)
+		P.setDir(dir)
+		return 1
+	return 0

code/modules/power/singularity/singularity.dm

@@ -0,0 +1,446 @@
+
+
+/obj/singularity
+	name = "gravitational singularity"
+	desc = "A gravitational singularity."
+	icon = 'icons/obj/singularity.dmi'
+	icon_state = "singularity_s1"
+	anchored = TRUE
+	density = TRUE
+	layer = MASSIVE_OBJ_LAYER
+	light_range = 6
+	appearance_flags = 0
+	var/current_size = 1
+	var/allowed_size = 1
+	var/contained = 1 //Are we going to move around?
+	var/energy = 100 //How strong are we?
+	var/dissipate = 1 //Do we lose energy over time?
+	var/dissipate_delay = 10
+	var/dissipate_track = 0
+	var/dissipate_strength = 1 //How much energy do we lose?
+	var/move_self = 1 //Do we move on our own?
+	var/grav_pull = 4 //How many tiles out do we pull?
+	var/consume_range = 0 //How many tiles out do we eat
+	var/event_chance = 10 //Prob for event each tick
+	var/target = null //its target. moves towards the target if it has one
+	var/last_failed_movement = 0//Will not move in the same dir if it couldnt before, will help with the getting stuck on fields thing
+	var/last_warning
+	var/consumedSupermatter = 0 //If the singularity has eaten a supermatter shard and can go to stage six
+	resistance_flags = INDESTRUCTIBLE | LAVA_PROOF | FIRE_PROOF | UNACIDABLE | ACID_PROOF | FREEZE_PROOF
+	obj_flags = CAN_BE_HIT | DANGEROUS_POSSESSION
+
+/obj/singularity/Initialize(mapload, starting_energy = 50)
+	//CARN: admin-alert for chuckle-fuckery.
+	admin_investigate_setup()
+
+	src.energy = starting_energy
+	. = ..()
+	START_PROCESSING(SSobj, src)
+	GLOB.poi_list |= src
+	GLOB.singularities |= src
+	for(var/obj/machinery/power/singularity_beacon/singubeacon in GLOB.machines)
+		if(singubeacon.active)
+			target = singubeacon
+			break
+	return
+
+/obj/singularity/Destroy()
+	STOP_PROCESSING(SSobj, src)
+	GLOB.poi_list.Remove(src)
+	GLOB.singularities.Remove(src)
+	return ..()
+
+/obj/singularity/Move(atom/newloc, direct)
+	if(current_size >= STAGE_FIVE || check_turfs_in(direct))
+		last_failed_movement = 0//Reset this because we moved
+		return ..()
+	else
+		last_failed_movement = direct
+		return 0
+
+/obj/singularity/attack_hand(mob/user)
+	consume(user)
+	return TRUE
+
+/obj/singularity/attack_paw(mob/user)
+	consume(user)
+
+/obj/singularity/attack_alien(mob/user)
+	consume(user)
+
+/obj/singularity/attack_animal(mob/user)
+	consume(user)
+
+/obj/singularity/attackby(obj/item/W, mob/user, params)
+	consume(user)
+	return 1
+
+/obj/singularity/Process_Spacemove() //The singularity stops drifting for no man!
+	return 0
+
+/obj/singularity/blob_act(obj/structure/blob/B)
+	return
+
+/obj/singularity/attack_tk(mob/user)
+	if(iscarbon(user))
+		var/mob/living/carbon/C = user
+		C.visible_message("<span class='danger'>[C]'s head begins to collapse in on itself!</span>", "<span class='userdanger'>Your head feels like it's collapsing in on itself! This was really not a good idea!</span>", "<span class='italics'>You hear something crack and explode in gore.</span>")
+		var/turf/T = get_turf(C)
+		for(var/i in 1 to 3)
+			C.apply_damage(30, BRUTE, BODY_ZONE_HEAD)
+			new /obj/effect/gibspawner/generic(T)
+			sleep(1)
+		C.ghostize()
+		var/obj/item/bodypart/head/rip_u = C.get_bodypart(BODY_ZONE_HEAD)
+		rip_u.dismember(BURN) //nice try jedi
+		qdel(rip_u)
+
+/obj/singularity/ex_act(severity, target)
+	switch(severity)
+		if(1)
+			if(current_size <= STAGE_TWO)
+				investigate_log("has been destroyed by a heavy explosion.", INVESTIGATE_SINGULO)
+				qdel(src)
+				return
+			else
+				energy -= round(((energy+1)/2),1)
+		if(2)
+			energy -= round(((energy+1)/3),1)
+		if(3)
+			energy -= round(((energy+1)/4),1)
+	return
+
+
+/obj/singularity/bullet_act(obj/item/projectile/P)
+	return 0 //Will there be an impact? Who knows.  Will we see it? No.
+
+
+/obj/singularity/Bump(atom/A)
+	consume(A)
+	return
+
+
+/obj/singularity/Bumped(atom/movable/AM)
+	consume(AM)
+
+
+/obj/singularity/process()
+	if(current_size >= STAGE_TWO)
+		move()
+		radiation_pulse(src, min(5000, (energy*4.5)+1000), RAD_DISTANCE_COEFFICIENT*0.5)
+		if(prob(event_chance))//Chance for it to run a special event TODO:Come up with one or two more that fit
+			event()
+	eat()
+	dissipate()
+	check_energy()
+
+	return
+
+
+/obj/singularity/attack_ai() //to prevent ais from gibbing themselves when they click on one.
+	return
+
+
+/obj/singularity/proc/admin_investigate_setup()
+	var/turf/T = get_turf(src)
+	last_warning = world.time
+	var/count = locate(/obj/machinery/field/containment) in urange(30, src, 1)
+	if(!count)
+		message_admins("A singulo has been created without containment fields active at [ADMIN_VERBOSEJMP(T)].")
+	investigate_log("was created at [AREACOORD(T)]. [count?"":"<font color='red'>No containment fields were active</font>"]", INVESTIGATE_SINGULO)
+
+/obj/singularity/proc/dissipate()
+	if(!dissipate)
+		return
+	if(dissipate_track >= dissipate_delay)
+		src.energy -= dissipate_strength
+		dissipate_track = 0
+	else
+		dissipate_track++
+
+
+/obj/singularity/proc/expand(force_size = 0)
+	var/temp_allowed_size = src.allowed_size
+	if(force_size)
+		temp_allowed_size = force_size
+	if(temp_allowed_size >= STAGE_SIX && !consumedSupermatter)
+		temp_allowed_size = STAGE_FIVE
+	switch(temp_allowed_size)
+		if(STAGE_ONE)
+			current_size = STAGE_ONE
+			icon = 'icons/obj/singularity.dmi'
+			icon_state = "singularity_s1"
+			pixel_x = 0
+			pixel_y = 0
+			grav_pull = 4
+			consume_range = 0
+			dissipate_delay = 10
+			dissipate_track = 0
+			dissipate_strength = 1
+		if(STAGE_TWO)
+			if(check_cardinals_range(1, TRUE))
+				current_size = STAGE_TWO
+				icon = 'icons/effects/96x96.dmi'
+				icon_state = "singularity_s3"
+				pixel_x = -32
+				pixel_y = -32
+				grav_pull = 6
+				consume_range = 1
+				dissipate_delay = 5
+				dissipate_track = 0
+				dissipate_strength = 5
+		if(STAGE_THREE)
+			if(check_cardinals_range(2, TRUE))
+				current_size = STAGE_THREE
+				icon = 'icons/effects/160x160.dmi'
+				icon_state = "singularity_s5"
+				pixel_x = -64
+				pixel_y = -64
+				grav_pull = 8
+				consume_range = 2
+				dissipate_delay = 4
+				dissipate_track = 0
+				dissipate_strength = 20
+		if(STAGE_FOUR)
+			if(check_cardinals_range(3, TRUE))
+				current_size = STAGE_FOUR
+				icon = 'icons/effects/224x224.dmi'
+				icon_state = "singularity_s7"
+				pixel_x = -96
+				pixel_y = -96
+				grav_pull = 10
+				consume_range = 3
+				dissipate_delay = 10
+				dissipate_track = 0
+				dissipate_strength = 10
+		if(STAGE_FIVE)//this one also lacks a check for gens because it eats everything
+			current_size = STAGE_FIVE
+			icon = 'icons/effects/288x288.dmi'
+			icon_state = "singularity_s9"
+			pixel_x = -128
+			pixel_y = -128
+			grav_pull = 10
+			consume_range = 4
+			dissipate = 0 //It cant go smaller due to e loss
+		if(STAGE_SIX) //This only happens if a stage 5 singulo consumes a supermatter shard.
+			current_size = STAGE_SIX
+			icon = 'icons/effects/352x352.dmi'
+			icon_state = "singularity_s11"
+			pixel_x = -160
+			pixel_y = -160
+			grav_pull = 15
+			consume_range = 5
+			dissipate = 0
+	if(current_size == allowed_size)
+		investigate_log("<font color='red'>grew to size [current_size]</font>", INVESTIGATE_SINGULO)
+		return 1
+	else if(current_size < (--temp_allowed_size))
+		expand(temp_allowed_size)
+	else
+		return 0
+
+
+/obj/singularity/proc/check_energy()
+	if(energy <= 0)
+		investigate_log("collapsed.", INVESTIGATE_SINGULO)
+		qdel(src)
+		return 0
+	switch(energy)//Some of these numbers might need to be changed up later -Mport
+		if(1 to 199)
+			allowed_size = STAGE_ONE
+		if(200 to 499)
+			allowed_size = STAGE_TWO
+		if(500 to 999)
+			allowed_size = STAGE_THREE
+		if(1000 to 1999)
+			allowed_size = STAGE_FOUR
+		if(2000 to INFINITY)
+			if(energy >= 3000 && consumedSupermatter)
+				allowed_size = STAGE_SIX
+			else
+				allowed_size = STAGE_FIVE
+	if(current_size != allowed_size)
+		expand()
+	return 1
+
+
+/obj/singularity/proc/eat()
+	for(var/tile in spiral_range_turfs(grav_pull, src))
+		var/turf/T = tile
+		if(!T || !isturf(loc))
+			continue
+		if(get_dist(T, src) > consume_range)
+			T.singularity_pull(src, current_size)
+		else
+			consume(T)
+		for(var/thing in T)
+			if(isturf(loc) && thing != src)
+				var/atom/movable/X = thing
+				if(get_dist(X, src) > consume_range)
+					X.singularity_pull(src, current_size)
+				else
+					consume(X)
+			CHECK_TICK
+	return
+
+
+/obj/singularity/proc/consume(atom/A)
+	var/gain = A.singularity_act(current_size, src)
+	src.energy += gain
+	if(istype(A, /obj/machinery/power/supermatter_crystal) && !consumedSupermatter)
+		desc = "[initial(desc)] It glows fiercely with inner fire."
+		name = "supermatter-charged [initial(name)]"
+		consumedSupermatter = 1
+		set_light(10)
+	return
+
+
+/obj/singularity/proc/move(force_move = 0)
+	if(!move_self)
+		return 0
+
+	var/movement_dir = pick(GLOB.alldirs - last_failed_movement)
+
+	if(force_move)
+		movement_dir = force_move
+
+	if(target && prob(60))
+		movement_dir = get_dir(src,target) //moves to a singulo beacon, if there is one
+
+	step(src, movement_dir)
+
+/obj/singularity/proc/check_cardinals_range(steps, retry_with_move = FALSE)
+	. = length(GLOB.cardinals)			//Should be 4.
+	for(var/i in GLOB.cardinals)
+		. -= check_turfs_in(i, steps)	//-1 for each working direction
+	if(. && retry_with_move)			//If there's still a positive value it means it didn't pass. Retry with move if applicable
+		for(var/i in GLOB.cardinals)
+			if(step(src, i))			//Move in each direction.
+				if(check_cardinals_range(steps, FALSE))		//New location passes, return true.
+					return TRUE
+	. = !.
+
+/obj/singularity/proc/check_turfs_in(direction = 0, step = 0)
+	if(!direction)
+		return 0
+	var/steps = 0
+	if(!step)
+		switch(current_size)
+			if(STAGE_ONE)
+				steps = 1
+			if(STAGE_TWO)
+				steps = 3//Yes this is right
+			if(STAGE_THREE)
+				steps = 3
+			if(STAGE_FOUR)
+				steps = 4
+			if(STAGE_FIVE)
+				steps = 5
+	else
+		steps = step
+	var/list/turfs = list()
+	var/turf/T = src.loc
+	for(var/i = 1 to steps)
+		T = get_step(T,direction)
+	if(!isturf(T))
+		return 0
+	turfs.Add(T)
+	var/dir2 = 0
+	var/dir3 = 0
+	switch(direction)
+		if(NORTH||SOUTH)
+			dir2 = 4
+			dir3 = 8
+		if(EAST||WEST)
+			dir2 = 1
+			dir3 = 2
+	var/turf/T2 = T
+	for(var/j = 1 to steps-1)
+		T2 = get_step(T2,dir2)
+		if(!isturf(T2))
+			return 0
+		turfs.Add(T2)
+	for(var/k = 1 to steps-1)
+		T = get_step(T,dir3)
+		if(!isturf(T))
+			return 0
+		turfs.Add(T)
+	for(var/turf/T3 in turfs)
+		if(isnull(T3))
+			continue
+		if(!can_move(T3))
+			return 0
+	return 1
+
+
+/obj/singularity/proc/can_move(turf/T)
+	if(!T)
+		return 0
+	if((locate(/obj/machinery/field/containment) in T)||(locate(/obj/machinery/shieldwall) in T))
+		return 0
+	else if(locate(/obj/machinery/field/generator) in T)
+		var/obj/machinery/field/generator/G = locate(/obj/machinery/field/generator) in T
+		if(G && G.active)
+			return 0
+	else if(locate(/obj/machinery/shieldwallgen) in T)
+		var/obj/machinery/shieldwallgen/S = locate(/obj/machinery/shieldwallgen) in T
+		if(S && S.active)
+			return 0
+	return 1
+
+
+/obj/singularity/proc/event()
+	var/numb = rand(1,4)
+	switch(numb)
+		if(1)//EMP
+			emp_area()
+		if(2)//Stun mobs who lack optic scanners
+			mezzer()
+		if(3,4) //Sets all nearby mobs on fire
+			if(current_size < STAGE_SIX)
+				return 0
+			combust_mobs()
+		else
+			return 0
+	return 1
+
+
+/obj/singularity/proc/combust_mobs()
+	for(var/mob/living/carbon/C in urange(20, src, 1))
+		C.visible_message("<span class='warning'>[C]'s skin bursts into flame!</span>", \
+						  "<span class='userdanger'>You feel an inner fire as your skin bursts into flames!</span>")
+		C.adjust_fire_stacks(5)
+		C.IgniteMob()
+	return
+
+
+/obj/singularity/proc/mezzer()
+	for(var/mob/living/carbon/M in oviewers(8, src))
+		if(isbrain(M)) //Ignore brains
+			continue
+
+		if(M.stat == CONSCIOUS)
+			if (ishuman(M))
+				var/mob/living/carbon/human/H = M
+				if(istype(H.glasses, /obj/item/clothing/glasses/meson))
+					var/obj/item/clothing/glasses/meson/MS = H.glasses
+					if(MS.vision_flags == SEE_TURFS)
+						to_chat(H, "<span class='notice'>You look directly into the [src.name], good thing you had your protective eyewear on!</span>")
+						return
+
+		M.apply_effect(60, EFFECT_STUN)
+		M.visible_message("<span class='danger'>[M] stares blankly at the [src.name]!</span>", \
+						"<span class='userdanger'>You look directly into the [src.name] and feel weak.</span>")
+	return
+
+
+/obj/singularity/proc/emp_area()
+	empulse(src, 8, 10)
+	return
+
+/obj/singularity/singularity_act()
+	var/gain = (energy/2)
+	var/dist = max((current_size - 2),1)
+	explosion(src.loc,(dist),(dist*2),(dist*4))
+	qdel(src)
+	return(gain)

code/modules/power/smes.dm

@@ -0,0 +1,447 @@
+// the SMES
+// stores power
+
+#define SMESRATE 0.05			// rate of internal charge to external power
+
+//Cache defines
+#define SMES_CLEVEL_1		1
+#define SMES_CLEVEL_2		2
+#define SMES_CLEVEL_3		3
+#define SMES_CLEVEL_4		4
+#define SMES_CLEVEL_5		5
+#define SMES_OUTPUTTING		6
+#define SMES_NOT_OUTPUTTING 7
+#define SMES_INPUTTING		8
+#define SMES_INPUT_ATTEMPT	9
+
+/obj/machinery/power/smes
+	name = "power storage unit"
+	desc = "A high-capacity superconducting magnetic energy storage (SMES) unit."
+	icon_state = "smes"
+	density = TRUE
+	use_power = NO_POWER_USE
+	circuit = /obj/item/circuitboard/machine/smes
+	var/capacity = 5e6 // maximum charge
+	var/charge = 0 // actual charge
+
+	var/input_attempt = TRUE // TRUE = attempting to charge, FALSE = not attempting to charge
+	var/inputting = TRUE // TRUE = actually inputting, FALSE = not inputting
+	var/input_level = 50000 // amount of power the SMES attempts to charge by
+	var/input_level_max = 200000 // cap on input_level
+	var/input_available = 0 // amount of charge available from input last tick
+
+	var/output_attempt = TRUE // TRUE = attempting to output, FALSE = not attempting to output
+	var/outputting = TRUE // TRUE = actually outputting, FALSE = not outputting
+	var/output_level = 50000 // amount of power the SMES attempts to output
+	var/output_level_max = 200000 // cap on output_level
+	var/output_used = 0 // amount of power actually outputted. may be less than output_level if the powernet returns excess power
+
+	var/obj/machinery/power/terminal/terminal = null
+
+/obj/machinery/power/smes/examine(user)
+	..()
+	if(!terminal)
+		to_chat(user, "<span class='warning'>This SMES has no power terminal!</span>")
+
+/obj/machinery/power/smes/Initialize()
+	. = ..()
+	dir_loop:
+		for(var/d in GLOB.cardinals)
+			var/turf/T = get_step(src, d)
+			for(var/obj/machinery/power/terminal/term in T)
+				if(term && term.dir == turn(d, 180))
+					terminal = term
+					break dir_loop
+
+	if(!terminal)
+		stat |= BROKEN
+		return
+	terminal.master = src
+	update_icon()
+
+/obj/machinery/power/smes/RefreshParts()
+	var/IO = 0
+	var/MC = 0
+	var/C
+	for(var/obj/item/stock_parts/capacitor/CP in component_parts)
+		IO += CP.rating
+	input_level_max = initial(input_level_max) * IO
+	output_level_max = initial(output_level_max) * IO
+	for(var/obj/item/stock_parts/cell/PC in component_parts)
+		MC += PC.maxcharge
+		C += PC.charge
+	capacity = MC / (15000) * 1e6
+	if(!initial(charge) && !charge)
+		charge = C / 15000 * 1e6
+
+/obj/machinery/power/smes/attackby(obj/item/I, mob/user, params)
+	//opening using screwdriver
+	if(default_deconstruction_screwdriver(user, "[initial(icon_state)]-o", initial(icon_state), I))
+		update_icon()
+		return
+
+	//changing direction using wrench
+	if(default_change_direction_wrench(user, I))
+		terminal = null
+		var/turf/T = get_step(src, dir)
+		for(var/obj/machinery/power/terminal/term in T)
+			if(term && term.dir == turn(dir, 180))
+				terminal = term
+				terminal.master = src
+				to_chat(user, "<span class='notice'>Terminal found.</span>")
+				break
+		if(!terminal)
+			to_chat(user, "<span class='alert'>No power terminal found.</span>")
+			return
+		stat &= ~BROKEN
+		update_icon()
+		return
+
+	//building and linking a terminal
+	if(istype(I, /obj/item/stack/cable_coil))
+		var/dir = get_dir(user,src)
+		if(dir & (dir-1))//we don't want diagonal click
+			return
+
+		if(terminal) //is there already a terminal ?
+			to_chat(user, "<span class='warning'>This SMES already has a power terminal!</span>")
+			return
+
+		if(!panel_open) //is the panel open ?
+			to_chat(user, "<span class='warning'>You must open the maintenance panel first!</span>")
+			return
+
+		var/turf/T = get_turf(user)
+		if (T.intact) //is the floor plating removed ?
+			to_chat(user, "<span class='warning'>You must first remove the floor plating!</span>")
+			return
+
+
+		var/obj/item/stack/cable_coil/C = I
+		if(C.get_amount() < 10)
+			to_chat(user, "<span class='warning'>You need more wires!</span>")
+			return
+
+		to_chat(user, "<span class='notice'>You start building the power terminal...</span>")
+		playsound(src.loc, 'sound/items/deconstruct.ogg', 50, 1)
+
+		if(do_after(user, 20, target = src) && C.get_amount() >= 10)
+			if(C.get_amount() < 10 || !C)
+				return
+			var/obj/structure/cable/N = T.get_cable_node() //get the connecting node cable, if there's one
+			if (prob(50) && electrocute_mob(usr, N, N, 1, TRUE)) //animate the electrocution if uncautious and unlucky
+				do_sparks(5, TRUE, src)
+				return
+
+			C.use(10)
+			user.visible_message(\
+				"[user.name] has built a power terminal.",\
+				"<span class='notice'>You build the power terminal.</span>")
+
+			//build the terminal and link it to the network
+			make_terminal(T)
+			terminal.connect_to_network()
+			connect_to_network()
+		return
+
+	//crowbarring it !
+	var/turf/T = get_turf(src)
+	if(default_deconstruction_crowbar(I))
+		message_admins("[src] has been deconstructed by [ADMIN_LOOKUPFLW(user)] in [ADMIN_VERBOSEJMP(T)]")
+		log_game("[src] has been deconstructed by [key_name(user)] at [AREACOORD(src)]")
+		investigate_log("SMES deconstructed by [key_name(user)] at [AREACOORD(src)]", INVESTIGATE_SINGULO)
+		return
+	else if(panel_open && istype(I, /obj/item/crowbar))
+		return
+
+	return ..()
+
+/obj/machinery/power/smes/wirecutter_act(mob/living/user, obj/item/I)
+	//disassembling the terminal
+	if(terminal && panel_open)
+		terminal.dismantle(user, I)
+		return TRUE
+
+
+/obj/machinery/power/smes/default_deconstruction_crowbar(obj/item/crowbar/C)
+	if(istype(C) && terminal)
+		to_chat(usr, "<span class='warning'>You must first remove the power terminal!</span>")
+		return FALSE
+
+	return ..()
+
+/obj/machinery/power/smes/on_deconstruction()
+	for(var/obj/item/stock_parts/cell/cell in component_parts)
+		cell.charge = (charge / capacity) * cell.maxcharge
+
+/obj/machinery/power/smes/Destroy()
+	if(SSticker.IsRoundInProgress())
+		var/turf/T = get_turf(src)
+		message_admins("SMES deleted at [ADMIN_VERBOSEJMP(T)]")
+		log_game("SMES deleted at [AREACOORD(T)]")
+		investigate_log("<font color='red'>deleted</font> at [AREACOORD(T)]", INVESTIGATE_SINGULO)
+	if(terminal)
+		disconnect_terminal()
+	return ..()
+
+// create a terminal object pointing towards the SMES
+// wires will attach to this
+/obj/machinery/power/smes/proc/make_terminal(turf/T)
+	terminal = new/obj/machinery/power/terminal(T)
+	terminal.setDir(get_dir(T,src))
+	terminal.master = src
+	stat &= ~BROKEN
+
+/obj/machinery/power/smes/disconnect_terminal()
+	if(terminal)
+		terminal.master = null
+		terminal = null
+		stat |= BROKEN
+
+
+/obj/machinery/power/smes/update_icon()
+	cut_overlays()
+	if(stat & BROKEN)
+		return
+
+	if(panel_open)
+		return
+
+	if(outputting)
+		add_overlay("smes-op1")
+	else
+		add_overlay("smes-op0")
+
+	if(inputting)
+		add_overlay("smes-oc1")
+	else
+		if(input_attempt)
+			add_overlay("smes-oc0")
+
+	var/clevel = chargedisplay()
+	if(clevel>0)
+		add_overlay("smes-og[clevel]")
+
+
+/obj/machinery/power/smes/proc/chargedisplay()
+	return CLAMP(round(5.5*charge/capacity),0,5)
+
+/obj/machinery/power/smes/process()
+	if(stat & BROKEN)
+		return
+
+	//store machine state to see if we need to update the icon overlays
+	var/last_disp = chargedisplay()
+	var/last_chrg = inputting
+	var/last_onln = outputting
+
+	//inputting
+	if(terminal && input_attempt)
+		input_available = terminal.surplus()
+
+		if(inputting)
+			if(input_available > 0)		// if there's power available, try to charge
+
+				var/load = min(min((capacity-charge)/SMESRATE, input_level), input_available)		// charge at set rate, limited to spare capacity
+
+				charge += load * SMESRATE	// increase the charge
+
+				terminal.add_load(load) // add the load to the terminal side network
+
+			else					// if not enough capcity
+				inputting = FALSE		// stop inputting
+
+		else
+			if(input_attempt && input_available > 0)
+				inputting = TRUE
+	else
+		inputting = FALSE
+
+	//outputting
+	if(output_attempt)
+		if(outputting)
+			output_used = min( charge/SMESRATE, output_level)		//limit output to that stored
+
+			if (add_avail(output_used))				// add output to powernet if it exists (smes side)
+				charge -= output_used*SMESRATE		// reduce the storage (may be recovered in /restore() if excessive)
+			else
+				outputting = FALSE
+
+			if(output_used < 0.0001)		// either from no charge or set to 0
+				outputting = FALSE
+				investigate_log("lost power and turned <font color='red'>off</font>", INVESTIGATE_SINGULO)
+		else if(output_attempt && charge > output_level && output_level > 0)
+			outputting = TRUE
+		else
+			output_used = 0
+	else
+		outputting = FALSE
+
+	// only update icon if state changed
+	if(last_disp != chargedisplay() || last_chrg != inputting || last_onln != outputting)
+		update_icon()
+
+
+
+// called after all power processes are finished
+// restores charge level to smes if there was excess this ptick
+/obj/machinery/power/smes/proc/restore()
+	if(stat & BROKEN)
+		return
+
+	if(!outputting)
+		output_used = 0
+		return
+
+	var/excess = powernet.netexcess		// this was how much wasn't used on the network last ptick, minus any removed by other SMESes
+
+	excess = min(output_used, excess)				// clamp it to how much was actually output by this SMES last ptick
+
+	excess = min((capacity-charge)/SMESRATE, excess)	// for safety, also limit recharge by space capacity of SMES (shouldn't happen)
+
+	// now recharge this amount
+
+	var/clev = chargedisplay()
+
+	charge += excess * SMESRATE			// restore unused power
+	powernet.netexcess -= excess		// remove the excess from the powernet, so later SMESes don't try to use it
+
+	output_used -= excess
+
+	if(clev != chargedisplay() ) //if needed updates the icons overlay
+		update_icon()
+	return
+
+
+/obj/machinery/power/smes/ui_interact(mob/user, ui_key = "main", datum/tgui/ui = null, force_open = FALSE, \
+										datum/tgui/master_ui = null, datum/ui_state/state = GLOB.default_state)
+	ui = SStgui.try_update_ui(user, src, ui_key, ui, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "smes", name, 340, 440, master_ui, state)
+		ui.open()
+
+/obj/machinery/power/smes/ui_data()
+	var/list/data = list(
+		"capacityPercent" = round(100*charge/capacity, 0.1),
+		"capacity" = capacity,
+		"charge" = charge,
+
+		"inputAttempt" = input_attempt,
+		"inputting" = inputting,
+		"inputLevel" = input_level,
+		"inputLevel_text" = DisplayPower(input_level),
+		"inputLevelMax" = input_level_max,
+		"inputAvailable" = DisplayPower(input_available),
+
+		"outputAttempt" = output_attempt,
+		"outputting" = outputting,
+		"outputLevel" = output_level,
+		"outputLevel_text" = DisplayPower(output_level),
+		"outputLevelMax" = output_level_max,
+		"outputUsed" = DisplayPower(output_used)
+	)
+	return data
+
+/obj/machinery/power/smes/ui_act(action, params)
+	if(..())
+		return
+	switch(action)
+		if("tryinput")
+			input_attempt = !input_attempt
+			log_smes(usr)
+			update_icon()
+			. = TRUE
+		if("tryoutput")
+			output_attempt = !output_attempt
+			log_smes(usr)
+			update_icon()
+			. = TRUE
+		if("input")
+			var/target = params["target"]
+			var/adjust = text2num(params["adjust"])
+			if(target == "input")
+				target = input("New input target (0-[input_level_max]):", name, input_level) as num|null
+				if(!isnull(target) && !..())
+					. = TRUE
+			else if(target == "min")
+				target = 0
+				. = TRUE
+			else if(target == "max")
+				target = input_level_max
+				. = TRUE
+			else if(adjust)
+				target = input_level + adjust
+				. = TRUE
+			else if(text2num(target) != null)
+				target = text2num(target)
+				. = TRUE
+			if(.)
+				input_level = CLAMP(target, 0, input_level_max)
+				log_smes(usr)
+		if("output")
+			var/target = params["target"]
+			var/adjust = text2num(params["adjust"])
+			if(target == "input")
+				target = input("New output target (0-[output_level_max]):", name, output_level) as num|null
+				if(!isnull(target) && !..())
+					. = TRUE
+			else if(target == "min")
+				target = 0
+				. = TRUE
+			else if(target == "max")
+				target = output_level_max
+				. = TRUE
+			else if(adjust)
+				target = output_level + adjust
+				. = TRUE
+			else if(text2num(target) != null)
+				target = text2num(target)
+				. = TRUE
+			if(.)
+				output_level = CLAMP(target, 0, output_level_max)
+				log_smes(usr)
+
+/obj/machinery/power/smes/proc/log_smes(mob/user)
+	investigate_log("input/output; [input_level>output_level?"<font color='green'>":"<font color='red'>"][input_level]/[output_level]</font> | Charge: [charge] | Output-mode: [output_attempt?"<font color='green'>on</font>":"<font color='red'>off</font>"] | Input-mode: [input_attempt?"<font color='green'>auto</font>":"<font color='red'>off</font>"] by [user ? key_name(user) : "outside forces"]", INVESTIGATE_SINGULO)
+
+
+/obj/machinery/power/smes/emp_act(severity)
+	. = ..()
+	if(. & EMP_PROTECT_SELF)
+		return
+	input_attempt = rand(0,1)
+	inputting = input_attempt
+	output_attempt = rand(0,1)
+	outputting = output_attempt
+	output_level = rand(0, output_level_max)
+	input_level = rand(0, input_level_max)
+	charge -= 1e6/severity
+	if (charge < 0)
+		charge = 0
+	update_icon()
+	log_smes()
+
+/obj/machinery/power/smes/engineering
+	charge = 1.5e6 // Engineering starts with some charge for singulo
+
+/obj/machinery/power/smes/magical
+	name = "magical power storage unit"
+	desc = "A high-capacity superconducting magnetic energy storage (SMES) unit. Magically produces power."
+
+/obj/machinery/power/smes/magical/process()
+	capacity = INFINITY
+	charge = INFINITY
+	..()
+
+
+#undef SMESRATE
+
+#undef SMES_CLEVEL_1
+#undef SMES_CLEVEL_2
+#undef SMES_CLEVEL_3
+#undef SMES_CLEVEL_4
+#undef SMES_CLEVEL_5
+#undef SMES_OUTPUTTING
+#undef SMES_NOT_OUTPUTTING
+#undef SMES_INPUTTING
+#undef SMES_INPUT_ATTEMPT

code/modules/power/solar.dm

@@ -0,0 +1,487 @@
+#define SOLAR_MAX_DIST 40
+#define SOLARGENRATE 1500
+
+/obj/machinery/power/solar
+	name = "solar panel"
+	desc = "A solar panel. Generates electricity when in contact with sunlight."
+	icon = 'goon/icons/obj/power.dmi'
+	icon_state = "sp_base"
+	density = TRUE
+	use_power = NO_POWER_USE
+	idle_power_usage = 0
+	active_power_usage = 0
+	var/id = 0
+	max_integrity = 150
+	integrity_failure = 50
+	var/obscured = 0
+	var/sunfrac = 0
+	var/adir = SOUTH // actual dir
+	var/ndir = SOUTH // target dir
+	var/turn_angle = 0
+	var/obj/machinery/power/solar_control/control = null
+
+/obj/machinery/power/solar/Initialize(mapload, obj/item/solar_assembly/S)
+	. = ..()
+	Make(S)
+	connect_to_network()
+
+/obj/machinery/power/solar/Destroy()
+	unset_control() //remove from control computer
+	return ..()
+
+//set the control of the panel to a given computer if closer than SOLAR_MAX_DIST
+/obj/machinery/power/solar/proc/set_control(obj/machinery/power/solar_control/SC)
+	if(!SC || (get_dist(src, SC) > SOLAR_MAX_DIST))
+		return 0
+	control = SC
+	SC.connected_panels |= src
+	return 1
+
+//set the control of the panel to null and removes it from the control list of the previous control computer if needed
+/obj/machinery/power/solar/proc/unset_control()
+	if(control)
+		control.connected_panels.Remove(src)
+	control = null
+
+/obj/machinery/power/solar/proc/Make(obj/item/solar_assembly/S)
+	if(!S)
+		S = new /obj/item/solar_assembly(src)
+		S.glass_type = /obj/item/stack/sheet/glass
+		S.anchored = TRUE
+	else
+		S.forceMove(src)
+	if(S.glass_type == /obj/item/stack/sheet/rglass) //if the panel is in reinforced glass
+		max_integrity *= 2 								 //this need to be placed here, because panels already on the map don't have an assembly linked to
+		obj_integrity = max_integrity
+	update_icon()
+
+/obj/machinery/power/solar/crowbar_act(mob/user, obj/item/I)
+	playsound(src.loc, 'sound/machines/click.ogg', 50, 1)
+	user.visible_message("[user] begins to take the glass off [src].", "<span class='notice'>You begin to take the glass off [src]...</span>")
+	if(I.use_tool(src, user, 50))
+		playsound(src.loc, 'sound/items/deconstruct.ogg', 50, 1)
+		user.visible_message("[user] takes the glass off [src].", "<span class='notice'>You take the glass off [src].</span>")
+		deconstruct(TRUE)
+	return TRUE
+
+/obj/machinery/power/solar/play_attack_sound(damage_amount, damage_type = BRUTE, damage_flag = 0)
+	switch(damage_type)
+		if(BRUTE)
+			if(stat & BROKEN)
+				playsound(loc, 'sound/effects/hit_on_shattered_glass.ogg', 60, 1)
+			else
+				playsound(loc, 'sound/effects/glasshit.ogg', 90, 1)
+		if(BURN)
+			playsound(loc, 'sound/items/welder.ogg', 100, 1)
+
+
+/obj/machinery/power/solar/obj_break(damage_flag)
+	if(!(stat & BROKEN) && !(flags_1 & NODECONSTRUCT_1))
+		playsound(loc, 'sound/effects/glassbr3.ogg', 100, 1)
+		stat |= BROKEN
+		unset_control()
+		update_icon()
+
+/obj/machinery/power/solar/deconstruct(disassembled = TRUE)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		if(disassembled)
+			var/obj/item/solar_assembly/S = locate() in src
+			if(S)
+				S.forceMove(loc)
+				S.give_glass(stat & BROKEN)
+		else
+			playsound(src, "shatter", 70, 1)
+			new /obj/item/shard(src.loc)
+			new /obj/item/shard(src.loc)
+	qdel(src)
+
+
+/obj/machinery/power/solar/update_icon()
+	..()
+	cut_overlays()
+	if(stat & BROKEN)
+		add_overlay(mutable_appearance(icon, "solar_panel-b", FLY_LAYER))
+	else
+		add_overlay(mutable_appearance(icon, "solar_panel", FLY_LAYER))
+		src.setDir(angle2dir(adir))
+
+//calculates the fraction of the sunlight that the panel receives
+/obj/machinery/power/solar/proc/update_solar_exposure()
+	if(obscured)
+		sunfrac = 0
+		return
+
+	//find the smaller angle between the direction the panel is facing and the direction of the sun (the sign is not important here)
+	var/p_angle = min(abs(adir - SSsun.angle), 360 - abs(adir - SSsun.angle))
+
+	if(p_angle > 90)			// if facing more than 90deg from sun, zero output
+		sunfrac = 0
+		return
+
+	sunfrac = cos(p_angle) ** 2
+	//isn't the power received from the incoming light proportionnal to cos(p_angle) (Lambert's cosine law) rather than cos(p_angle)^2 ?
+
+/obj/machinery/power/solar/process()//TODO: remove/add this from machines to save on processing as needed ~Carn PRIORITY
+	if(stat & BROKEN)
+		return
+	if(!control) //if there's no sun or the panel is not linked to a solar control computer, no need to proceed
+		return
+
+	if(powernet)
+		if(powernet == control.powernet)//check if the panel is still connected to the computer
+			if(obscured) //get no light from the sun, so don't generate power
+				return
+			var/sgen = SOLARGENRATE * sunfrac
+			add_avail(sgen)
+			control.gen += sgen
+		else //if we're no longer on the same powernet, remove from control computer
+			unset_control()
+
+
+/obj/machinery/power/solar/fake/New(var/turf/loc, var/obj/item/solar_assembly/S)
+	..(loc, S, 0)
+
+/obj/machinery/power/solar/fake/process()
+	. = PROCESS_KILL
+	return
+
+//trace towards sun to see if we're in shadow
+/obj/machinery/power/solar/proc/occlusion()
+
+	var/ax = x		// start at the solar panel
+	var/ay = y
+	var/turf/T = null
+	var/dx = SSsun.dx
+	var/dy = SSsun.dy
+
+	for(var/i = 1 to 20)		// 20 steps is enough
+		ax += dx	// do step
+		ay += dy
+
+		T = locate( round(ax,0.5),round(ay,0.5),z)
+
+		if(T.x == 1 || T.x==world.maxx || T.y==1 || T.y==world.maxy)		// not obscured if we reach the edge
+			break
+
+		if(T.density)			// if we hit a solid turf, panel is obscured
+			obscured = 1
+			return
+
+	obscured = 0		// if hit the edge or stepped 20 times, not obscured
+	update_solar_exposure()
+
+
+//
+// Solar Assembly - For construction of solar arrays.
+//
+
+/obj/item/solar_assembly
+	name = "solar panel assembly"
+	desc = "A solar panel assembly kit, allows constructions of a solar panel, or with a tracking circuit board, a solar tracker."
+	icon = 'goon/icons/obj/power.dmi'
+	icon_state = "sp_base"
+	item_state = "electropack"
+	lefthand_file = 'icons/mob/inhands/misc/devices_lefthand.dmi'
+	righthand_file = 'icons/mob/inhands/misc/devices_righthand.dmi'
+	w_class = WEIGHT_CLASS_BULKY // Pretty big!
+	anchored = FALSE
+	var/tracker = 0
+	var/glass_type = null
+
+// Give back the glass type we were supplied with
+/obj/item/solar_assembly/proc/give_glass(device_broken)
+	var/atom/Tsec = drop_location()
+	if(device_broken)
+		new /obj/item/shard(Tsec)
+		new /obj/item/shard(Tsec)
+	else if(glass_type)
+		new glass_type(Tsec, 2)
+	glass_type = null
+
+
+/obj/item/solar_assembly/attackby(obj/item/W, mob/user, params)
+	if(istype(W, /obj/item/wrench) && isturf(loc))
+		if(isinspace())
+			to_chat(user, "<span class='warning'>You can't secure [src] here.</span>")
+			return
+		anchored = !anchored
+		if(anchored)
+			user.visible_message("[user] wrenches the solar assembly into place.", "<span class='notice'>You wrench the solar assembly into place.</span>")
+			W.play_tool_sound(src, 75)
+		else
+			user.visible_message("[user] unwrenches the solar assembly from its place.", "<span class='notice'>You unwrench the solar assembly from its place.</span>")
+			W.play_tool_sound(src, 75)
+		return 1
+
+	if(istype(W, /obj/item/stack/sheet/glass) || istype(W, /obj/item/stack/sheet/rglass))
+		if(!anchored)
+			to_chat(user, "<span class='warning'>You need to secure the assembly before you can add glass.</span>")
+			return
+		var/obj/item/stack/sheet/S = W
+		if(S.use(2))
+			glass_type = W.type
+			playsound(src.loc, 'sound/machines/click.ogg', 50, 1)
+			user.visible_message("[user] places the glass on the solar assembly.", "<span class='notice'>You place the glass on the solar assembly.</span>")
+			if(tracker)
+				new /obj/machinery/power/tracker(get_turf(src), src)
+			else
+				new /obj/machinery/power/solar(get_turf(src), src)
+		else
+			to_chat(user, "<span class='warning'>You need two sheets of glass to put them into a solar panel!</span>")
+			return
+		return 1
+
+	if(!tracker)
+		if(istype(W, /obj/item/electronics/tracker))
+			if(!user.temporarilyRemoveItemFromInventory(W))
+				return
+			tracker = 1
+			qdel(W)
+			user.visible_message("[user] inserts the electronics into the solar assembly.", "<span class='notice'>You insert the electronics into the solar assembly.</span>")
+			return 1
+	else
+		if(istype(W, /obj/item/crowbar))
+			new /obj/item/electronics/tracker(src.loc)
+			tracker = 0
+			user.visible_message("[user] takes out the electronics from the solar assembly.", "<span class='notice'>You take out the electronics from the solar assembly.</span>")
+			return 1
+	return ..()
+
+//
+// Solar Control Computer
+//
+
+/obj/machinery/power/solar_control
+	name = "solar panel control"
+	desc = "A controller for solar panel arrays."
+	icon = 'icons/obj/computer.dmi'
+	icon_state = "computer"
+	density = TRUE
+	use_power = IDLE_POWER_USE
+	idle_power_usage = 250
+	max_integrity = 200
+	integrity_failure = 100
+	var/icon_screen = "solar"
+	var/icon_keyboard = "power_key"
+	var/id = 0
+	var/currentdir = 0
+	var/targetdir = 0		// target angle in manual tracking (since it updates every game minute)
+	var/gen = 0
+	var/lastgen = 0
+	var/track = 0			// 0= off  1=timed  2=auto (tracker)
+	var/trackrate = 600		// 300-900 seconds
+	var/nexttime = 0		// time for a panel to rotate of 1 degree in manual tracking
+	var/obj/machinery/power/tracker/connected_tracker = null
+	var/list/connected_panels = list()
+
+/obj/machinery/power/solar_control/Initialize()
+	. = ..()
+	if(powernet)
+		set_panels(currentdir)
+	connect_to_network()
+
+/obj/machinery/power/solar_control/Destroy()
+	for(var/obj/machinery/power/solar/M in connected_panels)
+		M.unset_control()
+	if(connected_tracker)
+		connected_tracker.unset_control()
+	return ..()
+
+/obj/machinery/power/solar_control/disconnect_from_network()
+	..()
+	SSsun.solars.Remove(src)
+
+/obj/machinery/power/solar_control/connect_to_network()
+	var/to_return = ..()
+	if(powernet) //if connected and not already in solar_list...
+		SSsun.solars |= src //... add it
+	return to_return
+
+//search for unconnected panels and trackers in the computer powernet and connect them
+/obj/machinery/power/solar_control/proc/search_for_connected()
+	if(powernet)
+		for(var/obj/machinery/power/M in powernet.nodes)
+			if(istype(M, /obj/machinery/power/solar))
+				var/obj/machinery/power/solar/S = M
+				if(!S.control) //i.e unconnected
+					S.set_control(src)
+			else if(istype(M, /obj/machinery/power/tracker))
+				if(!connected_tracker) //if there's already a tracker connected to the computer don't add another
+					var/obj/machinery/power/tracker/T = M
+					if(!T.control) //i.e unconnected
+						T.set_control(src)
+
+//called by the sun controller, update the facing angle (either manually or via tracking) and rotates the panels accordingly
+/obj/machinery/power/solar_control/proc/update()
+	if(stat & (NOPOWER | BROKEN))
+		return
+
+	switch(track)
+		if(1)
+			if(trackrate) //we're manual tracking. If we set a rotation speed...
+				currentdir = targetdir //...the current direction is the targetted one (and rotates panels to it)
+		if(2) // auto-tracking
+			if(connected_tracker)
+				connected_tracker.set_angle(SSsun.angle)
+
+	set_panels(currentdir)
+	updateDialog()
+
+/obj/machinery/power/solar_control/update_icon()
+	cut_overlays()
+	if(stat & NOPOWER)
+		add_overlay("[icon_keyboard]_off")
+		return
+	add_overlay(icon_keyboard)
+	if(stat & BROKEN)
+		add_overlay("[icon_state]_broken")
+	else
+		add_overlay(icon_screen)
+
+/obj/machinery/power/solar_control/ui_interact(mob/user, ui_key = "main", datum/tgui/ui = null, force_open = FALSE, \
+												datum/tgui/master_ui = null, datum/ui_state/state = GLOB.default_state)
+	ui = SStgui.try_update_ui(user, src, ui_key, ui, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "solar_control", name, 500, 400, master_ui, state)
+		ui.open()
+
+/obj/machinery/power/solar_control/ui_data()
+	var/data = list()
+
+	data["generated"] = round(lastgen)
+	data["angle"] = currentdir
+	data["direction"] = angle2text(currentdir)
+
+	data["tracking_state"] = track
+	data["tracking_rate"] = trackrate
+	data["rotating_way"] = (trackrate<0 ? "CCW" : "CW")
+
+	data["connected_panels"] = connected_panels.len
+	data["connected_tracker"] = (connected_tracker ? 1 : 0)
+	return data
+
+/obj/machinery/power/solar_control/ui_act(action, params)
+	if(..())
+		return
+	switch(action)
+		if("angle")
+			var/adjust = text2num(params["adjust"])
+			if(adjust)
+				currentdir = CLAMP((360 + adjust + currentdir) % 360, 0, 359)
+				targetdir = currentdir
+				set_panels(currentdir)
+				. = TRUE
+		if("rate")
+			var/adjust = text2num(params["adjust"])
+			if(adjust)
+				trackrate = CLAMP(trackrate + adjust, -7200, 7200)
+				if(trackrate)
+					nexttime = world.time + 36000 / abs(trackrate)
+				. = TRUE
+		if("tracking")
+			var/mode = text2num(params["mode"])
+			track = mode
+			if(mode == 2 && connected_tracker)
+				connected_tracker.set_angle(SSsun.angle)
+				set_panels(currentdir)
+			else if(mode == 1)
+				targetdir = currentdir
+				if(trackrate)
+					nexttime = world.time + 36000 / abs(trackrate)
+				set_panels(targetdir)
+			. = TRUE
+		if("refresh")
+			search_for_connected()
+			if(connected_tracker && track == 2)
+				connected_tracker.set_angle(SSsun.angle)
+			set_panels(currentdir)
+			. = TRUE
+
+/obj/machinery/power/solar_control/attackby(obj/item/I, mob/user, params)
+	if(istype(I, /obj/item/screwdriver))
+		if(I.use_tool(src, user, 20, volume=50))
+			if (src.stat & BROKEN)
+				to_chat(user, "<span class='notice'>The broken glass falls out.</span>")
+				var/obj/structure/frame/computer/A = new /obj/structure/frame/computer( src.loc )
+				new /obj/item/shard( src.loc )
+				var/obj/item/circuitboard/computer/solar_control/M = new /obj/item/circuitboard/computer/solar_control( A )
+				for (var/obj/C in src)
+					C.forceMove(drop_location())
+				A.circuit = M
+				A.state = 3
+				A.icon_state = "3"
+				A.anchored = TRUE
+				qdel(src)
+			else
+				to_chat(user, "<span class='notice'>You disconnect the monitor.</span>")
+				var/obj/structure/frame/computer/A = new /obj/structure/frame/computer( src.loc )
+				var/obj/item/circuitboard/computer/solar_control/M = new /obj/item/circuitboard/computer/solar_control( A )
+				for (var/obj/C in src)
+					C.forceMove(drop_location())
+				A.circuit = M
+				A.state = 4
+				A.icon_state = "4"
+				A.anchored = TRUE
+				qdel(src)
+	else if(user.a_intent != INTENT_HARM && !(I.item_flags & NOBLUDGEON))
+		attack_hand(user)
+	else
+		return ..()
+
+/obj/machinery/power/solar_control/play_attack_sound(damage_amount, damage_type = BRUTE, damage_flag = 0)
+	switch(damage_type)
+		if(BRUTE)
+			if(stat & BROKEN)
+				playsound(src.loc, 'sound/effects/hit_on_shattered_glass.ogg', 70, 1)
+			else
+				playsound(src.loc, 'sound/effects/glasshit.ogg', 75, 1)
+		if(BURN)
+			playsound(src.loc, 'sound/items/welder.ogg', 100, 1)
+
+/obj/machinery/power/solar_control/obj_break(damage_flag)
+	if(!(stat & BROKEN) && !(flags_1 & NODECONSTRUCT_1))
+		playsound(loc, 'sound/effects/glassbr3.ogg', 100, 1)
+		stat |= BROKEN
+		update_icon()
+
+/obj/machinery/power/solar_control/process()
+	lastgen = gen
+	gen = 0
+
+	if(stat & (NOPOWER | BROKEN))
+		return
+
+	if(connected_tracker) //NOTE : handled here so that we don't add trackers to the processing list
+		if(connected_tracker.powernet != powernet)
+			connected_tracker.unset_control()
+
+	if(track==1 && trackrate) //manual tracking and set a rotation speed
+		if(nexttime <= world.time) //every time we need to increase/decrease the angle by 1�...
+			targetdir = (targetdir + trackrate/abs(trackrate) + 360) % 360 	//... do it
+			nexttime += 36000/abs(trackrate) //reset the counter for the next 1�
+
+//rotates the panel to the passed angle
+/obj/machinery/power/solar_control/proc/set_panels(currentdir)
+
+	for(var/obj/machinery/power/solar/S in connected_panels)
+		S.adir = currentdir //instantly rotates the panel
+		S.occlusion()//and
+		S.update_icon() //update it
+
+	update_icon()
+
+
+/obj/machinery/power/solar_control/power_change()
+	..()
+	update_icon()
+
+
+
+
+//
+// MISC
+//
+
+/obj/item/paper/guides/jobs/engi/solars
+	name = "paper- 'Going green! Setup your own solar array instructions.'"
+	info = "<h1>Welcome</h1><p>At greencorps we love the environment, and space. With this package you are able to help mother nature and produce energy without any usage of fossil fuel or plasma! Singularity energy is dangerous while solar energy is safe, which is why it's better. Now here is how you setup your own solar array.</p><p>You can make a solar panel by wrenching the solar assembly onto a cable node. Adding a glass panel, reinforced or regular glass will do, will finish the construction of your solar panel. It is that easy!</p><p>Now after setting up 19 more of these solar panels you will want to create a solar tracker to keep track of our mother nature's gift, the sun. These are the same steps as before except you insert the tracker equipment circuit into the assembly before performing the final step of adding the glass. You now have a tracker! Now the last step is to add a computer to calculate the sun's movements and to send commands to the solar panels to change direction with the sun. Setting up the solar computer is the same as setting up any computer, so you should have no trouble in doing that. You do need to put a wire node under the computer, and the wire needs to be connected to the tracker.</p><p>Congratulations, you should have a working solar array. If you are having trouble, here are some tips. Make sure all solar equipment are on a cable node, even the computer. You can always deconstruct your creations if you make a mistake.</p><p>That's all to it, be safe, be green!</p>"

code/modules/power/supermatter/supermatter.dm

@@ -0,0 +1,790 @@
+//Ported from /vg/station13, which was in turn forked from baystation12;
+//Please do not bother them with bugs from this port, however, as it has been modified quite a bit.
+//Modifications include removing the world-ending full supermatter variation, and leaving only the shard.
+
+#define PLASMA_HEAT_PENALTY 15     // Higher == Bigger heat and waste penalty from having the crystal surrounded by this gas. Negative numbers reduce penalty.
+#define OXYGEN_HEAT_PENALTY 1
+#define CO2_HEAT_PENALTY 0.1
+#define NITROGEN_HEAT_MODIFIER -1.5
+
+#define OXYGEN_TRANSMIT_MODIFIER 1.5   //Higher == Bigger bonus to power generation.
+#define PLASMA_TRANSMIT_MODIFIER 4
+
+#define N2O_HEAT_RESISTANCE 6          //Higher == Gas makes the crystal more resistant against heat damage.
+
+#define POWERLOSS_INHIBITION_GAS_THRESHOLD 0.20         //Higher == Higher percentage of inhibitor gas needed before the charge inertia chain reaction effect starts.
+#define POWERLOSS_INHIBITION_MOLE_THRESHOLD 20        //Higher == More moles of the gas are needed before the charge inertia chain reaction effect starts.        //Scales powerloss inhibition down until this amount of moles is reached
+#define POWERLOSS_INHIBITION_MOLE_BOOST_THRESHOLD 500  //bonus powerloss inhibition boost if this amount of moles is reached
+
+#define MOLE_PENALTY_THRESHOLD 1800           //Higher == Shard can absorb more moles before triggering the high mole penalties.
+#define MOLE_HEAT_PENALTY 350                 //Heat damage scales around this. Too hot setups with this amount of moles do regular damage, anything above and below is scaled
+#define POWER_PENALTY_THRESHOLD 5000          //Higher == Engine can generate more power before triggering the high power penalties.
+#define SEVERE_POWER_PENALTY_THRESHOLD 7000   //Same as above, but causes more dangerous effects
+#define CRITICAL_POWER_PENALTY_THRESHOLD 9000 //Even more dangerous effects, threshold for tesla delamination
+#define HEAT_PENALTY_THRESHOLD 40             //Higher == Crystal safe operational temperature is higher.
+#define DAMAGE_HARDCAP 0.002
+#define DAMAGE_INCREASE_MULTIPLIER 0.25
+
+
+#define THERMAL_RELEASE_MODIFIER 5         //Higher == less heat released during reaction, not to be confused with the above values
+#define PLASMA_RELEASE_MODIFIER 750        //Higher == less plasma released by reaction
+#define OXYGEN_RELEASE_MODIFIER 325        //Higher == less oxygen released at high temperature/power
+
+#define REACTION_POWER_MODIFIER 0.55       //Higher == more overall power
+
+#define MATTER_POWER_CONVERSION 10         //Crystal converts 1/this value of stored matter into energy.
+
+//These would be what you would get at point blank, decreases with distance
+#define DETONATION_RADS 200
+#define DETONATION_HALLUCINATION 600
+
+
+#define WARNING_DELAY 60
+
+#define HALLUCINATION_RANGE(P) (min(7, round(P ** 0.25)))
+
+
+#define GRAVITATIONAL_ANOMALY "gravitational_anomaly"
+#define FLUX_ANOMALY "flux_anomaly"
+#define PYRO_ANOMALY "pyro_anomaly"
+
+//If integrity percent remaining is less than these values, the monitor sets off the relevant alarm.
+#define SUPERMATTER_DELAM_PERCENT 5
+#define SUPERMATTER_EMERGENCY_PERCENT 25
+#define SUPERMATTER_DANGER_PERCENT 50
+#define SUPERMATTER_WARNING_PERCENT 100
+
+#define SUPERMATTER_COUNTDOWN_TIME 30 SECONDS
+
+GLOBAL_DATUM(main_supermatter_engine, /obj/machinery/power/supermatter_crystal)
+
+/obj/machinery/power/supermatter_crystal
+	name = "supermatter crystal"
+	desc = "A strangely translucent and iridescent crystal."
+	icon = 'icons/obj/supermatter.dmi'
+	icon_state = "darkmatter"
+	density = TRUE
+	anchored = TRUE
+	var/uid = 1
+	var/static/gl_uid = 1
+	light_range = 4
+	resistance_flags = INDESTRUCTIBLE | LAVA_PROOF | FIRE_PROOF | UNACIDABLE | ACID_PROOF | FREEZE_PROOF
+
+	critical_machine = TRUE
+
+	var/gasefficency = 0.15
+
+	var/base_icon_state = "darkmatter"
+
+	var/final_countdown = FALSE
+
+	var/damage = 0
+	var/damage_archived = 0
+	var/safe_alert = "Crystalline hyperstructure returning to safe operating parameters."
+	var/warning_point = 50
+	var/warning_alert = "Danger! Crystal hyperstructure integrity faltering!"
+	var/damage_penalty_point = 550
+	var/emergency_point = 700
+	var/emergency_alert = "CRYSTAL DELAMINATION IMMINENT."
+	var/explosion_point = 900
+
+	var/emergency_issued = FALSE
+
+	var/explosion_power = 35
+	var/temp_factor = 30
+
+	var/lastwarning = 0				// Time in 1/10th of seconds since the last sent warning
+	var/power = 0
+
+	var/n2comp = 0					// raw composition of each gas in the chamber, ranges from 0 to 1
+
+	var/plasmacomp = 0
+	var/o2comp = 0
+	var/co2comp = 0
+	var/n2ocomp = 0
+
+	var/combined_gas = 0
+	var/gasmix_power_ratio = 0
+	var/dynamic_heat_modifier = 1
+	var/dynamic_heat_resistance = 1
+	var/powerloss_inhibitor = 1
+	var/powerloss_dynamic_scaling= 0
+	var/power_transmission_bonus = 0
+	var/mole_heat_penalty = 0
+
+
+	var/matter_power = 0
+
+	//Temporary values so that we can optimize this
+	//How much the bullets damage should be multiplied by when it is added to the internal variables
+	var/config_bullet_energy = 2
+	//How much of the power is left after processing is finished?
+//	var/config_power_reduction_per_tick = 0.5
+	//How much hallucination should it produce per unit of power?
+	var/config_hallucination_power = 0.1
+
+	var/obj/item/radio/radio
+	var/radio_key = /obj/item/encryptionkey/headset_eng
+	var/engineering_channel = "Engineering"
+	var/common_channel = null
+
+	//for logging
+	var/has_been_powered = FALSE
+	var/has_reached_emergency = FALSE
+
+	// For making hugbox supermatter
+	var/takes_damage = TRUE
+	var/produces_gas = TRUE
+	var/obj/effect/countdown/supermatter/countdown
+
+	var/is_main_engine = FALSE
+
+	var/datum/looping_sound/supermatter/soundloop
+
+	var/moveable = FALSE
+
+/obj/machinery/power/supermatter_crystal/Initialize()
+	. = ..()
+	uid = gl_uid++
+	SSair.atmos_machinery += src
+	countdown = new(src)
+	countdown.start()
+	GLOB.poi_list |= src
+	radio = new(src)
+	radio.keyslot = new radio_key
+	radio.listening = 0
+	radio.recalculateChannels()
+	investigate_log("has been created.", INVESTIGATE_SUPERMATTER)
+	if(is_main_engine)
+		GLOB.main_supermatter_engine = src
+
+	soundloop = new(list(src), TRUE)
+
+/obj/machinery/power/supermatter_crystal/Destroy()
+	investigate_log("has been destroyed.", INVESTIGATE_SUPERMATTER)
+	SSair.atmos_machinery -= src
+	QDEL_NULL(radio)
+	GLOB.poi_list -= src
+	QDEL_NULL(countdown)
+	if(is_main_engine && GLOB.main_supermatter_engine == src)
+		GLOB.main_supermatter_engine = null
+	QDEL_NULL(soundloop)
+	return ..()
+
+/obj/machinery/power/supermatter_crystal/examine(mob/user)
+	..()
+	if(!ishuman(user))
+		return
+
+	var/range = HALLUCINATION_RANGE(power)
+	for(var/mob/living/carbon/human/H in viewers(range, src))
+		if(H != user)
+			continue
+		if(!istype(H.glasses, /obj/item/clothing/glasses/meson))
+			to_chat(H, "<span class='danger'>You get headaches just from looking at it.</span>")
+		return
+
+#define CRITICAL_TEMPERATURE 10000
+
+/obj/machinery/power/supermatter_crystal/proc/get_status()
+	var/turf/T = get_turf(src)
+	if(!T)
+		return SUPERMATTER_ERROR
+	var/datum/gas_mixture/air = T.return_air()
+	if(!air)
+		return SUPERMATTER_ERROR
+
+	if(get_integrity() < SUPERMATTER_DELAM_PERCENT)
+		return SUPERMATTER_DELAMINATING
+
+	if(get_integrity() < SUPERMATTER_EMERGENCY_PERCENT)
+		return SUPERMATTER_EMERGENCY
+
+	if(get_integrity() < SUPERMATTER_DANGER_PERCENT)
+		return SUPERMATTER_DANGER
+
+	if((get_integrity() < SUPERMATTER_WARNING_PERCENT) || (air.temperature > CRITICAL_TEMPERATURE))
+		return SUPERMATTER_WARNING
+
+	if(air.temperature > (CRITICAL_TEMPERATURE * 0.8))
+		return SUPERMATTER_NOTIFY
+
+	if(power > 5)
+		return SUPERMATTER_NORMAL
+	return SUPERMATTER_INACTIVE
+
+/obj/machinery/power/supermatter_crystal/proc/alarm()
+	switch(get_status())
+		if(SUPERMATTER_DELAMINATING)
+			playsound(src, 'sound/misc/bloblarm.ogg', 100)
+		if(SUPERMATTER_EMERGENCY)
+			playsound(src, 'sound/machines/engine_alert1.ogg', 100)
+		if(SUPERMATTER_DANGER)
+			playsound(src, 'sound/machines/engine_alert2.ogg', 100)
+		if(SUPERMATTER_WARNING)
+			playsound(src, 'sound/machines/terminal_alert.ogg', 75)
+
+/obj/machinery/power/supermatter_crystal/proc/get_integrity()
+	var/integrity = damage / explosion_point
+	integrity = round(100 - integrity * 100, 0.01)
+	integrity = integrity < 0 ? 0 : integrity
+	return integrity
+
+/obj/machinery/power/supermatter_crystal/proc/countdown()
+	set waitfor = FALSE
+
+	if(final_countdown) // We're already doing it go away
+		return
+	final_countdown = TRUE
+
+	var/image/causality_field = image(icon, null, "causality_field")
+	add_overlay(causality_field, TRUE)
+
+	var/speaking = "[emergency_alert] The supermatter has reached critical integrity failure. Emergency causality destabilization field has been activated."
+	radio.talk_into(src, speaking, common_channel, language = get_default_language())
+	for(var/i in SUPERMATTER_COUNTDOWN_TIME to 0 step -10)
+		if(damage < explosion_point) // Cutting it a bit close there engineers
+			radio.talk_into(src, "[safe_alert] Failsafe has been disengaged.", common_channel)
+			cut_overlay(causality_field, TRUE)
+			final_countdown = FALSE
+			return
+		else if((i % 50) != 0 && i > 50) // A message once every 5 seconds until the final 5 seconds which count down individualy
+			sleep(10)
+			continue
+		else if(i > 50)
+			speaking = "[DisplayTimeText(i, TRUE)] remain before causality stabilization."
+		else
+			speaking = "[i*0.1]..."
+		radio.talk_into(src, speaking, common_channel)
+		sleep(10)
+
+	explode()
+
+/obj/machinery/power/supermatter_crystal/proc/explode()
+	for(var/mob in GLOB.alive_mob_list)
+		var/mob/living/L = mob
+		if(istype(L) && L.z == z)
+			if(ishuman(mob))
+				//Hilariously enough, running into a closet should make you get hit the hardest.
+				var/mob/living/carbon/human/H = mob
+				H.hallucination += max(50, min(300, DETONATION_HALLUCINATION * sqrt(1 / (get_dist(mob, src) + 1)) ) )
+			var/rads = DETONATION_RADS * sqrt( 1 / (get_dist(L, src) + 1) )
+			L.rad_act(rads)
+
+	var/turf/T = get_turf(src)
+	for(var/mob/M in GLOB.player_list)
+		if(M.z == z)
+			SEND_SOUND(M, 'sound/magic/charge.ogg')
+			to_chat(M, "<span class='boldannounce'>You feel reality distort for a moment...</span>")
+			SEND_SIGNAL(M, COMSIG_ADD_MOOD_EVENT, "delam", /datum/mood_event/delam)
+	if(combined_gas > MOLE_PENALTY_THRESHOLD)
+		investigate_log("has collapsed into a singularity.", INVESTIGATE_SUPERMATTER)
+		if(T)
+			var/obj/singularity/S = new(T)
+			S.energy = 800
+			S.consume(src)
+	else
+		investigate_log("has exploded.", INVESTIGATE_SUPERMATTER)
+		explosion(get_turf(T), explosion_power * max(gasmix_power_ratio, 0.205) * 0.5 , explosion_power * max(gasmix_power_ratio, 0.205) + 2, explosion_power * max(gasmix_power_ratio, 0.205) + 4 , explosion_power * max(gasmix_power_ratio, 0.205) + 6, 1, 1)
+		if(power > POWER_PENALTY_THRESHOLD)
+			investigate_log("has spawned additional energy balls.", INVESTIGATE_SUPERMATTER)
+			var/obj/singularity/energy_ball/E = new(T)
+			E.energy = power
+		qdel(src)
+
+/obj/machinery/power/supermatter_crystal/proc/consume_turf(turf/T)
+	var/oldtype = T.type
+	var/turf/newT = T.ScrapeAway()
+	if(newT.type == oldtype)
+		return
+	playsound(T, 'sound/effects/supermatter.ogg', 50, 1)
+	T.visible_message("<span class='danger'>[T] smacks into [src] and rapidly flashes to ash.</span>",\
+	"<span class='italics'>You hear a loud crack as you are washed with a wave of heat.</span>")
+	T.CalculateAdjacentTurfs()
+
+/obj/machinery/power/supermatter_crystal/process_atmos()
+	var/turf/T = loc
+
+	if(isnull(T))		// We have a null turf...something is wrong, stop processing this entity.
+		return PROCESS_KILL
+
+	if(!istype(T)) 	//We are in a crate or somewhere that isn't turf, if we return to turf resume processing but for now.
+		return  //Yeah just stop.
+	if(istype(T, /turf/closed))
+		consume_turf(T)
+
+	if(power)
+		soundloop.volume = min(40, (round(power/100)/50)+1) // 5 +1 volume per 20 power. 2500 power is max
+
+	//Ok, get the air from the turf
+	var/datum/gas_mixture/env = T.return_air()
+
+	var/datum/gas_mixture/removed
+
+	if(produces_gas)
+		//Remove gas from surrounding area
+		removed = env.remove(gasefficency * env.total_moles())
+	else
+		// Pass all the gas related code an empty gas container
+		removed = new()
+
+	damage_archived = damage
+	if(!removed || !removed.total_moles() || isspaceturf(T)) //we're in space or there is no gas to process
+		if(takes_damage)
+			damage += max((power / 1000) * DAMAGE_INCREASE_MULTIPLIER, 0.1) // always does at least some damage
+	else
+		if(takes_damage)
+			//causing damage
+			damage = max(damage + (max(CLAMP(removed.total_moles() / 200, 0.5, 1) * removed.temperature - ((T0C + HEAT_PENALTY_THRESHOLD)*dynamic_heat_resistance), 0) * mole_heat_penalty / 150 ) * DAMAGE_INCREASE_MULTIPLIER, 0)
+			damage = max(damage + (max(power - POWER_PENALTY_THRESHOLD, 0)/500) * DAMAGE_INCREASE_MULTIPLIER, 0)
+			damage = max(damage + (max(combined_gas - MOLE_PENALTY_THRESHOLD, 0)/80) * DAMAGE_INCREASE_MULTIPLIER, 0)
+
+			//healing damage
+			if(combined_gas < MOLE_PENALTY_THRESHOLD)
+				damage = max(damage + (min(removed.temperature - (T0C + HEAT_PENALTY_THRESHOLD), 0) / 150 ), 0)
+
+			//capping damage
+			damage = min(damage_archived + (DAMAGE_HARDCAP * explosion_point),damage)
+			if(damage > damage_archived && prob(10))
+				playsound(get_turf(src), 'sound/effects/empulse.ogg', 50, 1)
+
+		//calculating gas related values
+		combined_gas = max(removed.total_moles(), 0)
+
+		plasmacomp = max(removed.gases[/datum/gas/plasma]/combined_gas, 0)
+		o2comp = max(removed.gases[/datum/gas/oxygen]/combined_gas, 0)
+		co2comp = max(removed.gases[/datum/gas/carbon_dioxide]/combined_gas, 0)
+
+		n2ocomp = max(removed.gases[/datum/gas/nitrous_oxide]/combined_gas, 0)
+		n2comp = max(removed.gases[/datum/gas/nitrogen]/combined_gas, 0)
+
+		gasmix_power_ratio = min(max(plasmacomp + o2comp + co2comp - n2comp, 0), 1)
+
+		dynamic_heat_modifier = max((plasmacomp * PLASMA_HEAT_PENALTY)+(o2comp * OXYGEN_HEAT_PENALTY)+(co2comp * CO2_HEAT_PENALTY)+(n2comp * NITROGEN_HEAT_MODIFIER), 0.5)
+		dynamic_heat_resistance = max(n2ocomp * N2O_HEAT_RESISTANCE, 1)
+
+		power_transmission_bonus = max((plasmacomp * PLASMA_TRANSMIT_MODIFIER) + (o2comp * OXYGEN_TRANSMIT_MODIFIER), 0)
+
+		//more moles of gases are harder to heat than fewer, so let's scale heat damage around them
+		mole_heat_penalty = max(combined_gas / MOLE_HEAT_PENALTY, 0.25)
+
+		if (combined_gas > POWERLOSS_INHIBITION_MOLE_THRESHOLD && co2comp > POWERLOSS_INHIBITION_GAS_THRESHOLD)
+			powerloss_dynamic_scaling = CLAMP(powerloss_dynamic_scaling + CLAMP(co2comp - powerloss_dynamic_scaling, -0.02, 0.02), 0, 1)
+		else
+			powerloss_dynamic_scaling = CLAMP(powerloss_dynamic_scaling - 0.05,0, 1)
+		powerloss_inhibitor = CLAMP(1-(powerloss_dynamic_scaling * CLAMP(combined_gas/POWERLOSS_INHIBITION_MOLE_BOOST_THRESHOLD,1 ,1.5)),0 ,1)
+
+		if(matter_power)
+			var/removed_matter = max(matter_power/MATTER_POWER_CONVERSION, 40)
+			power = max(power + removed_matter, 0)
+			matter_power = max(matter_power - removed_matter, 0)
+
+		var/temp_factor = 50
+
+		if(gasmix_power_ratio > 0.8)
+			// with a perfect gas mix, make the power less based on heat
+			icon_state = "[base_icon_state]_glow"
+		else
+			// in normal mode, base the produced energy around the heat
+			temp_factor = 30
+			icon_state = base_icon_state
+
+		power = max( (removed.temperature * temp_factor / T0C) * gasmix_power_ratio + power, 0) //Total laser power plus an overload
+
+		if(prob(50))
+			radiation_pulse(src, power * (1 + power_transmission_bonus/10))
+
+		var/device_energy = power * REACTION_POWER_MODIFIER
+
+		//To figure out how much temperature to add each tick, consider that at one atmosphere's worth
+		//of pure oxygen, with all four lasers firing at standard energy and no N2 present, at room temperature
+		//that the device energy is around 2140. At that stage, we don't want too much heat to be put out
+		//Since the core is effectively "cold"
+
+		//Also keep in mind we are only adding this temperature to (efficiency)% of the one tile the rock
+		//is on. An increase of 4*C @ 25% efficiency here results in an increase of 1*C / (#tilesincore) overall.
+		removed.temperature += ((device_energy * dynamic_heat_modifier) / THERMAL_RELEASE_MODIFIER)
+
+		removed.temperature = max(0, min(removed.temperature, 2500 * dynamic_heat_modifier))
+
+		//Calculate how much gas to release
+		removed.gases[/datum/gas/plasma] += max((device_energy * dynamic_heat_modifier) / PLASMA_RELEASE_MODIFIER, 0)
+
+		removed.gases[/datum/gas/oxygen] += max(((device_energy + removed.temperature * dynamic_heat_modifier) - T0C) / OXYGEN_RELEASE_MODIFIER, 0)
+
+		if(produces_gas)
+			env.merge(removed)
+			air_update_turf()
+
+	for(var/mob/living/carbon/human/l in view(src, HALLUCINATION_RANGE(power))) // If they can see it without mesons on.  Bad on them.
+		if(!istype(l.glasses, /obj/item/clothing/glasses/meson))
+			var/D = sqrt(1 / max(1, get_dist(l, src)))
+			l.hallucination += power * config_hallucination_power * D
+			l.hallucination = CLAMP(0, 200, l.hallucination)
+
+	for(var/mob/living/l in range(src, round((power / 100) ** 0.25)))
+		var/rads = (power / 10) * sqrt( 1 / max(get_dist(l, src),1) )
+		l.rad_act(rads)
+
+	power -= ((power/500)**3) * powerloss_inhibitor
+
+	if(power > POWER_PENALTY_THRESHOLD || damage > damage_penalty_point)
+
+		if(power > POWER_PENALTY_THRESHOLD)
+			playsound(src.loc, 'sound/weapons/emitter2.ogg', 100, 1, extrarange = 10)
+			supermatter_zap(src, 5, min(power*2, 20000))
+			supermatter_zap(src, 5, min(power*2, 20000))
+			if(power > SEVERE_POWER_PENALTY_THRESHOLD)
+				supermatter_zap(src, 5, min(power*2, 20000))
+				if(power > CRITICAL_POWER_PENALTY_THRESHOLD)
+					supermatter_zap(src, 5, min(power*2, 20000))
+		else if (damage > damage_penalty_point && prob(20))
+			playsound(src.loc, 'sound/weapons/emitter2.ogg', 100, 1, extrarange = 10)
+			supermatter_zap(src, 5, CLAMP(power*2, 4000, 20000))
+
+		if(prob(15) && power > POWER_PENALTY_THRESHOLD)
+			supermatter_pull(src, power/750)
+		if(prob(5))
+			supermatter_anomaly_gen(src, FLUX_ANOMALY, rand(5, 10))
+		if(power > SEVERE_POWER_PENALTY_THRESHOLD && prob(5) || prob(1))
+			supermatter_anomaly_gen(src, GRAVITATIONAL_ANOMALY, rand(5, 10))
+		if(power > SEVERE_POWER_PENALTY_THRESHOLD && prob(2) || prob(0.3) && power > POWER_PENALTY_THRESHOLD)
+			supermatter_anomaly_gen(src, PYRO_ANOMALY, rand(5, 10))
+
+	if(damage > warning_point) // while the core is still damaged and it's still worth noting its status
+		if((REALTIMEOFDAY - lastwarning) / 10 >= WARNING_DELAY)
+			alarm()
+
+			if(damage > emergency_point)
+				radio.talk_into(src, "[emergency_alert] Integrity: [get_integrity()]%", common_channel)
+				lastwarning = REALTIMEOFDAY
+				if(!has_reached_emergency)
+					investigate_log("has reached the emergency point for the first time.", INVESTIGATE_SUPERMATTER)
+					message_admins("[src] has reached the emergency point [ADMIN_JMP(src)].")
+					has_reached_emergency = TRUE
+			else if(damage >= damage_archived) // The damage is still going up
+				radio.talk_into(src, "[warning_alert] Integrity: [get_integrity()]%", engineering_channel)
+				lastwarning = REALTIMEOFDAY - (WARNING_DELAY * 5)
+
+			else                                                 // Phew, we're safe
+				radio.talk_into(src, "[safe_alert] Integrity: [get_integrity()]%", engineering_channel)
+				lastwarning = REALTIMEOFDAY
+
+			if(power > POWER_PENALTY_THRESHOLD)
+				radio.talk_into(src, "Warning: Hyperstructure has reached dangerous power level.", engineering_channel)
+				if(powerloss_inhibitor < 0.5)
+					radio.talk_into(src, "DANGER: CHARGE INERTIA CHAIN REACTION IN PROGRESS.", engineering_channel)
+
+			if(combined_gas > MOLE_PENALTY_THRESHOLD)
+				radio.talk_into(src, "Warning: Critical coolant mass reached.", engineering_channel)
+
+		if(damage > explosion_point)
+			countdown()
+
+	return 1
+
+/obj/machinery/power/supermatter_crystal/bullet_act(obj/item/projectile/Proj)
+	var/turf/L = loc
+	if(!istype(L))
+		return FALSE
+	if(!istype(Proj.firer, /obj/machinery/power/emitter))
+		investigate_log("has been hit by [Proj] fired by [key_name(Proj.firer)]", INVESTIGATE_SUPERMATTER)
+	if(Proj.flag != "bullet")
+		power += Proj.damage * config_bullet_energy
+		if(!has_been_powered)
+			investigate_log("has been powered for the first time.", INVESTIGATE_SUPERMATTER)
+			message_admins("[src] has been powered for the first time [ADMIN_JMP(src)].")
+			has_been_powered = TRUE
+	else if(takes_damage)
+		damage += Proj.damage * config_bullet_energy
+	return FALSE
+
+/obj/machinery/power/supermatter_crystal/singularity_act()
+	var/gain = 100
+	investigate_log("Supermatter shard consumed by singularity.", INVESTIGATE_SINGULO)
+	message_admins("Singularity has consumed a supermatter shard and can now become stage six.")
+	visible_message("<span class='userdanger'>[src] is consumed by the singularity!</span>")
+	for(var/mob/M in GLOB.player_list)
+		if(M.z == z)
+			SEND_SOUND(M, 'sound/effects/supermatter.ogg') //everyone goan know bout this
+			to_chat(M, "<span class='boldannounce'>A horrible screeching fills your ears, and a wave of dread washes over you...</span>")
+	qdel(src)
+	return gain
+
+/obj/machinery/power/supermatter_crystal/blob_act(obj/structure/blob/B)
+	if(B && !isspaceturf(loc)) //does nothing in space
+		playsound(get_turf(src), 'sound/effects/supermatter.ogg', 50, 1)
+		damage += B.obj_integrity * 0.5 //take damage equal to 50% of remaining blob health before it tried to eat us
+		if(B.obj_integrity > 100)
+			B.visible_message("<span class='danger'>\The [B] strikes at \the [src] and flinches away!</span>",\
+			"<span class='italics'>You hear a loud crack as you are washed with a wave of heat.</span>")
+			B.take_damage(100, BURN)
+		else
+			B.visible_message("<span class='danger'>\The [B] strikes at \the [src] and rapidly flashes to ash.</span>",\
+			"<span class='italics'>You hear a loud crack as you are washed with a wave of heat.</span>")
+			Consume(B)
+
+/obj/machinery/power/supermatter_crystal/attack_tk(mob/user)
+	if(iscarbon(user))
+		var/mob/living/carbon/C = user
+		to_chat(C, "<span class='userdanger'>That was a really dense idea.</span>")
+		C.ghostize()
+		var/obj/item/organ/brain/rip_u = locate(/obj/item/organ/brain) in C.internal_organs
+		rip_u.Remove(C)
+		qdel(rip_u)
+
+/obj/machinery/power/supermatter_crystal/attack_paw(mob/user)
+	dust_mob(user, cause = "monkey attack")
+
+/obj/machinery/power/supermatter_crystal/attack_alien(mob/user)
+	dust_mob(user, cause = "alien attack")
+
+/obj/machinery/power/supermatter_crystal/attack_animal(mob/living/simple_animal/S)
+	var/murder
+	if(!S.melee_damage_upper && !S.melee_damage_lower)
+		murder = S.friendly
+	else
+		murder = S.attacktext
+	dust_mob(S, \
+	"<span class='danger'>[S] unwisely [murder] [src], and [S.p_their()] body burns brilliantly before flashing into ash!</span>", \
+	"<span class='userdanger'>You unwisely touch [src], and your vision glows brightly as your body crumbles to dust. Oops.</span>", \
+	"simple animal attack")
+
+/obj/machinery/power/supermatter_crystal/attack_robot(mob/user)
+	if(Adjacent(user))
+		dust_mob(user, cause = "cyborg attack")
+
+/obj/machinery/power/supermatter_crystal/attack_ai(mob/user)
+	return
+
+/obj/machinery/power/supermatter_crystal/attack_hand(mob/living/user)
+	. = ..()
+	if(.)
+		return
+	dust_mob(user, cause = "hand")
+
+/obj/machinery/power/supermatter_crystal/proc/dust_mob(mob/living/nom, vis_msg, mob_msg, cause)
+	if(nom.incorporeal_move || nom.status_flags & GODMODE)
+		return
+	if(!vis_msg)
+		vis_msg = "<span class='danger'>[nom] reaches out and touches [src], inducing a resonance... [nom.p_their()] body starts to glow and bursts into flames before flashing into ash"
+	if(!mob_msg)
+		mob_msg = "<span class='userdanger'>You reach out and touch [src]. Everything starts burning and all you can hear is ringing. Your last thought is \"That was not a wise decision.\"</span>"
+	if(!cause)
+		cause = "contact"
+	nom.visible_message(vis_msg, mob_msg, "<span class='italics'>You hear an unearthly noise as a wave of heat washes over you.</span>")
+	investigate_log("has been attacked ([cause]) by [key_name(nom)]", INVESTIGATE_SUPERMATTER)
+	playsound(get_turf(src), 'sound/effects/supermatter.ogg', 50, 1)
+	Consume(nom)
+
+/obj/machinery/power/supermatter_crystal/attackby(obj/item/W, mob/living/user, params)
+	if(!istype(W) || (W.item_flags & ABSTRACT) || !istype(user))
+		return
+	if (istype(W, /obj/item/melee/roastingstick))
+		return ..()
+	if(istype(W, /obj/item/scalpel/supermatter))
+		to_chat(user, "<span class='notice'>You carefully begin to scrape \the [src] with \the [W]...</span>")
+		if(W.use_tool(src, user, 60, volume=100))
+			to_chat(user, "<span class='notice'>You extract a sliver from \the [src]. \The [src] begins to react violently!</span>")
+			new /obj/item/nuke_core/supermatter_sliver(drop_location())
+			matter_power += 200
+	else if(user.dropItemToGround(W))
+		user.visible_message("<span class='danger'>As [user] touches \the [src] with \a [W], silence fills the room...</span>",\
+			"<span class='userdanger'>You touch \the [src] with \the [W], and everything suddenly goes silent.</span>\n<span class='notice'>\The [W] flashes into dust as you flinch away from \the [src].</span>",\
+			"<span class='italics'>Everything suddenly goes silent.</span>")
+		investigate_log("has been attacked ([W]) by [key_name(user)]", INVESTIGATE_SUPERMATTER)
+		Consume(W)
+		playsound(get_turf(src), 'sound/effects/supermatter.ogg', 50, 1)
+
+		radiation_pulse(src, 150, 4)
+
+/obj/machinery/power/supermatter_crystal/wrench_act(mob/user, obj/item/tool)
+	if (moveable)
+		default_unfasten_wrench(user, tool, time = 20)
+	return TRUE
+
+/obj/machinery/power/supermatter_crystal/Bumped(atom/movable/AM)
+	if(isliving(AM))
+		AM.visible_message("<span class='danger'>\The [AM] slams into \the [src] inducing a resonance... [AM.p_their()] body starts to glow and catch flame before flashing into ash.</span>",\
+		"<span class='userdanger'>You slam into \the [src] as your ears are filled with unearthly ringing. Your last thought is \"Oh, fuck.\"</span>",\
+		"<span class='italics'>You hear an unearthly noise as a wave of heat washes over you.</span>")
+	else if(isobj(AM) && !iseffect(AM))
+		AM.visible_message("<span class='danger'>\The [AM] smacks into \the [src] and rapidly flashes to ash.</span>", null,\
+		"<span class='italics'>You hear a loud crack as you are washed with a wave of heat.</span>")
+	else
+		return
+
+	playsound(get_turf(src), 'sound/effects/supermatter.ogg', 50, 1)
+
+	Consume(AM)
+
+/obj/machinery/power/supermatter_crystal/proc/Consume(atom/movable/AM)
+	if(isliving(AM))
+		var/mob/living/user = AM
+		if(user.status_flags & GODMODE)
+			return
+		message_admins("[src] has consumed [key_name_admin(user)] [ADMIN_JMP(src)].")
+		investigate_log("has consumed [key_name(user)].", INVESTIGATE_SUPERMATTER)
+		user.dust(force = TRUE)
+		matter_power += 200
+	else if(istype(AM, /obj/singularity))
+		return
+	else if(isobj(AM))
+		if(!iseffect(AM))
+			var/suspicion = ""
+			if(AM.fingerprintslast)
+				suspicion = "last touched by [AM.fingerprintslast]"
+				message_admins("[src] has consumed [AM], [suspicion] [ADMIN_JMP(src)].")
+			investigate_log("has consumed [AM] - [suspicion].", INVESTIGATE_SUPERMATTER)
+		qdel(AM)
+	if(!iseffect(AM))
+		matter_power += 200
+
+	//Some poor sod got eaten, go ahead and irradiate people nearby.
+	radiation_pulse(src, 3000, 2, TRUE)
+	for(var/mob/living/L in range(10))
+		investigate_log("has irradiated [key_name(L)] after consuming [AM].", INVESTIGATE_SUPERMATTER)
+		if(L in view())
+			L.show_message("<span class='danger'>As \the [src] slowly stops resonating, you find your skin covered in new radiation burns.</span>", 1,\
+				"<span class='danger'>The unearthly ringing subsides and you notice you have new radiation burns.</span>", 2)
+		else
+			L.show_message("<span class='italics'>You hear an unearthly ringing and notice your skin is covered in fresh radiation burns.</span>", 2)
+
+//Do not blow up our internal radio
+/obj/machinery/power/supermatter_crystal/contents_explosion(severity, target)
+	return
+
+/obj/machinery/power/supermatter_crystal/prevent_content_explosion()
+	return TRUE
+
+/obj/machinery/power/supermatter_crystal/engine
+	is_main_engine = TRUE
+
+/obj/machinery/power/supermatter_crystal/shard
+	name = "supermatter shard"
+	desc = "A strangely translucent and iridescent crystal that looks like it used to be part of a larger structure."
+	base_icon_state = "darkmatter_shard"
+	icon_state = "darkmatter_shard"
+	anchored = FALSE
+	gasefficency = 0.125
+	explosion_power = 12
+	moveable = TRUE
+
+/obj/machinery/power/supermatter_crystal/shard/engine
+	name = "anchored supermatter shard"
+	is_main_engine = TRUE
+	anchored = TRUE
+	moveable = FALSE
+
+// When you wanna make a supermatter shard for the dramatic effect, but
+// don't want it exploding suddenly
+/obj/machinery/power/supermatter_crystal/shard/hugbox
+	name = "anchored supermatter shard"
+	takes_damage = FALSE
+	produces_gas = FALSE
+	moveable = FALSE
+	anchored = TRUE
+
+/obj/machinery/power/supermatter_crystal/shard/hugbox/fakecrystal //Hugbox shard with crystal visuals, used in the Supermatter/Hyperfractal shuttle
+	name = "supermatter crystal"
+	base_icon_state = "darkmatter"
+	icon_state = "darkmatter"
+
+/obj/machinery/power/supermatter_crystal/proc/supermatter_pull(turf/center, pull_range = 10)
+	playsound(src.loc, 'sound/weapons/marauder.ogg', 100, 1, extrarange = 7)
+	for(var/atom/P in orange(pull_range,center))
+		if(ismovableatom(P))
+			var/atom/movable/pulled_object = P
+			if(ishuman(P))
+				var/mob/living/carbon/human/H = P
+				H.apply_effect(40, EFFECT_KNOCKDOWN, 0)
+			if(pulled_object && !pulled_object.anchored && !ishuman(P))
+				step_towards(pulled_object,center)
+				step_towards(pulled_object,center)
+				step_towards(pulled_object,center)
+				step_towards(pulled_object,center)
+
+/obj/machinery/power/supermatter_crystal/proc/supermatter_anomaly_gen(turf/anomalycenter, type = FLUX_ANOMALY, anomalyrange = 5)
+	var/turf/L = pick(orange(anomalyrange, anomalycenter))
+	if(L)
+		switch(type)
+			if(FLUX_ANOMALY)
+				var/obj/effect/anomaly/flux/A = new(L, 300)
+				A.explosive = FALSE
+			if(GRAVITATIONAL_ANOMALY)
+				new /obj/effect/anomaly/grav(L, 250)
+			if(PYRO_ANOMALY)
+				new /obj/effect/anomaly/pyro(L, 200)
+
+/obj/machinery/power/supermatter_crystal/proc/supermatter_zap(atom/zapstart, range = 3, power)
+	. = zapstart.dir
+	if(power < 1000)
+		return
+
+	var/target_atom
+	var/mob/living/target_mob
+	var/obj/machinery/target_machine
+	var/obj/structure/target_structure
+	var/list/arctargetsmob = list()
+	var/list/arctargetsmachine = list()
+	var/list/arctargetsstructure = list()
+
+	if(prob(20)) //let's not hit all the engineers with every beam and/or segment of the arc
+		for(var/mob/living/Z in oview(zapstart, range+2))
+			arctargetsmob += Z
+	if(arctargetsmob.len)
+		var/mob/living/H = pick(arctargetsmob)
+		var/atom/A = H
+		target_mob = H
+		target_atom = A
+
+	else
+		for(var/obj/machinery/X in oview(zapstart, range+2))
+			arctargetsmachine += X
+		if(arctargetsmachine.len)
+			var/obj/machinery/M = pick(arctargetsmachine)
+			var/atom/A = M
+			target_machine = M
+			target_atom = A
+
+		else
+			for(var/obj/structure/Y in oview(zapstart, range+2))
+				arctargetsstructure += Y
+			if(arctargetsstructure.len)
+				var/obj/structure/O = pick(arctargetsstructure)
+				var/atom/A = O
+				target_structure = O
+				target_atom = A
+
+	if(target_atom)
+		zapstart.Beam(target_atom, icon_state="nzcrentrs_power", time=5)
+		var/zapdir = get_dir(zapstart, target_atom)
+		if(zapdir)
+			. = zapdir
+
+	if(target_mob)
+		target_mob.electrocute_act(rand(5,10), "Supermatter Discharge Bolt", 1, stun = 0)
+		if(prob(15))
+			supermatter_zap(target_mob, 5, power / 2)
+			supermatter_zap(target_mob, 5, power / 2)
+		else
+			supermatter_zap(target_mob, 5, power / 1.5)
+
+	else if(target_machine)
+		if(prob(15))
+			supermatter_zap(target_machine, 5, power / 2)
+			supermatter_zap(target_machine, 5, power / 2)
+		else
+			supermatter_zap(target_machine, 5, power / 1.5)
+
+	else if(target_structure)
+		if(prob(15))
+			supermatter_zap(target_structure, 5, power / 2)
+			supermatter_zap(target_structure, 5, power / 2)
+		else
+			supermatter_zap(target_structure, 5, power / 1.5)
+
+#undef HALLUCINATION_RANGE
+#undef GRAVITATIONAL_ANOMALY
+#undef FLUX_ANOMALY
+#undef PYRO_ANOMALY

code/modules/power/terminal.dm

@@ -0,0 +1,78 @@
+// the underfloor wiring terminal for the APC
+// autogenerated when an APC is placed
+// all conduit connects go to this object instead of the APC
+// using this solves the problem of having the APC in a wall yet also inside an area
+
+/obj/machinery/power/terminal
+	name = "terminal"
+	icon_state = "term"
+	desc = "It's an underfloor wiring terminal for power equipment."
+	level = 1
+	layer = WIRE_TERMINAL_LAYER //a bit above wires
+	var/obj/machinery/power/master = null
+
+
+/obj/machinery/power/terminal/Initialize()
+	. = ..()
+	var/turf/T = get_turf(src)
+	if(level == 1)
+		hide(T.intact)
+
+/obj/machinery/power/terminal/Destroy()
+	if(master)
+		master.disconnect_terminal()
+		master = null
+	return ..()
+
+/obj/machinery/power/terminal/hide(i)
+	if(i)
+		invisibility = INVISIBILITY_MAXIMUM
+		icon_state = "term-f"
+	else
+		invisibility = 0
+		icon_state = "term"
+
+
+/obj/machinery/power/proc/can_terminal_dismantle()
+	. = 0
+
+/obj/machinery/power/apc/can_terminal_dismantle()
+	. = 0
+	if(opened)
+		. = 1
+
+/obj/machinery/power/smes/can_terminal_dismantle()
+	. = 0
+	if(panel_open)
+		. = 1
+
+
+/obj/machinery/power/terminal/proc/dismantle(mob/living/user, obj/item/I)
+	if(isturf(loc))
+		var/turf/T = loc
+		if(T.intact)
+			to_chat(user, "<span class='warning'>You must first expose the power terminal!</span>")
+			return
+
+	if(master && !master.can_terminal_dismantle())
+		return
+
+	user.visible_message("[user.name] dismantles the power terminal from [master].",
+		"<span class='notice'>You begin to cut the cables...</span>")
+
+	playsound(src.loc, 'sound/items/deconstruct.ogg', 50, 1)
+	if(I.use_tool(src, user, 50))
+		if(master && !master.can_terminal_dismantle())
+			return
+
+		if(prob(50) && electrocute_mob(user, powernet, src, 1, TRUE))
+			do_sparks(5, TRUE, master)
+			return
+
+		new /obj/item/stack/cable_coil(drop_location(), 10)
+		to_chat(user, "<span class='notice'>You cut the cables and dismantle the power terminal.</span>")
+		qdel(src)
+
+/obj/machinery/power/terminal/wirecutter_act(mob/living/user, obj/item/I)
+	dismantle(user, I)
+	return TRUE

code/modules/power/tesla/coil.dm

@@ -0,0 +1,177 @@
+/obj/machinery/power/tesla_coil
+	name = "tesla coil"
+	desc = "For the union!"
+	icon = 'icons/obj/tesla_engine/tesla_coil.dmi'
+	icon_state = "coil0"
+	anchored = FALSE
+	density = TRUE
+
+	// Executing a traitor caught releasing tesla was never this fun!
+	can_buckle = TRUE
+	buckle_lying = FALSE
+	buckle_requires_restraints = TRUE
+
+	circuit = /obj/item/circuitboard/machine/tesla_coil
+
+	var/power_loss = 2
+	var/input_power_multiplier = 1
+	var/zap_cooldown = 100
+	var/last_zap = 0
+
+	var/datum/techweb/linked_techweb
+
+/obj/machinery/power/tesla_coil/power
+	circuit = /obj/item/circuitboard/machine/tesla_coil/power
+
+/obj/machinery/power/tesla_coil/Initialize()
+	. = ..()
+	wires = new /datum/wires/tesla_coil(src)
+	linked_techweb = SSresearch.science_tech
+
+/obj/machinery/power/tesla_coil/RefreshParts()
+	var/power_multiplier = 0
+	zap_cooldown = 100
+	for(var/obj/item/stock_parts/capacitor/C in component_parts)
+		power_multiplier += C.rating
+		zap_cooldown -= (C.rating * 20)
+	input_power_multiplier = power_multiplier
+
+/obj/machinery/power/tesla_coil/on_construction()
+	if(anchored)
+		connect_to_network()
+
+/obj/machinery/power/tesla_coil/default_unfasten_wrench(mob/user, obj/item/I, time = 20)
+	. = ..()
+	if(. == SUCCESSFUL_UNFASTEN)
+		if(panel_open)
+			icon_state = "coil_open[anchored]"
+		else
+			icon_state = "coil[anchored]"
+		if(anchored)
+			connect_to_network()
+		else
+			disconnect_from_network()
+
+/obj/machinery/power/tesla_coil/attackby(obj/item/W, mob/user, params)
+	if(default_deconstruction_screwdriver(user, "coil_open[anchored]", "coil[anchored]", W))
+		return
+
+	if(default_unfasten_wrench(user, W))
+		return
+
+	if(default_deconstruction_crowbar(W))
+		return
+
+	if(is_wire_tool(W) && panel_open)
+		wires.interact(user)
+		return
+
+	return ..()
+
+/obj/machinery/power/tesla_coil/tesla_act(power, tesla_flags, shocked_targets)
+	if(anchored && !panel_open)
+		obj_flags |= BEING_SHOCKED
+		//don't lose arc power when it's not connected to anything
+		//please place tesla coils all around the station to maximize effectiveness
+		var/power_produced = powernet ? power / power_loss : power
+		add_avail(power_produced*input_power_multiplier)
+		flick("coilhit", src)
+		playsound(src.loc, 'sound/magic/lightningshock.ogg', 100, 1, extrarange = 5)
+		tesla_zap(src, 5, power_produced, tesla_flags, shocked_targets)
+		if(istype(linked_techweb))
+			linked_techweb.add_point_type(TECHWEB_POINT_TYPE_DEFAULT, min(power_produced, 1)) // x4 coils = ~240/m point bonus for R&D
+		addtimer(CALLBACK(src, .proc/reset_shocked), 10)
+		tesla_buckle_check(power)
+	else
+		..()
+
+/obj/machinery/power/tesla_coil/proc/zap()
+	if((last_zap + zap_cooldown) > world.time || !powernet)
+		return FALSE
+	last_zap = world.time
+	var/coeff = (20 - ((input_power_multiplier - 1) * 3))
+	coeff = max(coeff, 10)
+	var/power = (powernet.avail/2)
+	add_load(power)
+	playsound(src.loc, 'sound/magic/lightningshock.ogg', 100, 1, extrarange = 5)
+	tesla_zap(src, 10, power/(coeff/2), TESLA_FUSION_FLAGS)
+	tesla_buckle_check(power/(coeff/2))
+
+// Tesla R&D researcher
+/obj/machinery/power/tesla_coil/research
+	name = "Tesla Corona Analyzer"
+	desc = "A modified Tesla Coil used to study the effects of Edison's Bane for research."
+	icon_state = "rpcoil0"
+	circuit = /obj/item/circuitboard/machine/tesla_coil/research
+	power_loss = 20 // something something, high voltage + resistance
+
+/obj/machinery/power/tesla_coil/research/tesla_act(power, tesla_flags, shocked_things)
+	if(anchored && !panel_open)
+		obj_flags |= BEING_SHOCKED
+		var/power_produced = powernet ? power / power_loss : power
+		add_avail(power_produced*input_power_multiplier)
+		flick("rpcoilhit", src)
+		playsound(src.loc, 'sound/magic/lightningshock.ogg', 100, 1, extrarange = 5)
+		tesla_zap(src, 5, power_produced, tesla_flags, shocked_things)
+		if(istype(linked_techweb))
+			linked_techweb.add_point_type(TECHWEB_POINT_TYPE_DEFAULT, min(power_produced, 3)) // x4 coils with a pulse per second or so = ~720/m point bonus for R&D
+		addtimer(CALLBACK(src, .proc/reset_shocked), 10)
+		tesla_buckle_check(power)
+	else
+		..()
+
+/obj/machinery/power/tesla_coil/research/default_unfasten_wrench(mob/user, obj/item/wrench/W, time = 20)
+	. = ..()
+	if(. == SUCCESSFUL_UNFASTEN)
+		if(panel_open)
+			icon_state = "rpcoil_open[anchored]"
+		else
+			icon_state = "rpcoil[anchored]"
+
+/obj/machinery/power/tesla_coil/research/attackby(obj/item/W, mob/user, params)
+	if(default_deconstruction_screwdriver(user, "rpcoil_open[anchored]", "rpcoil[anchored]", W))
+		return
+	return ..()
+
+/obj/machinery/power/tesla_coil/research/on_construction()
+	if(anchored)
+		connect_to_network()
+
+/obj/machinery/power/grounding_rod
+	name = "grounding rod"
+	desc = "Keep an area from being fried from Edison's Bane."
+	icon = 'icons/obj/tesla_engine/tesla_coil.dmi'
+	icon_state = "grounding_rod0"
+	anchored = FALSE
+	density = TRUE
+
+	can_buckle = TRUE
+	buckle_lying = FALSE
+	buckle_requires_restraints = TRUE
+
+/obj/machinery/power/grounding_rod/default_unfasten_wrench(mob/user, obj/item/I, time = 20)
+	. = ..()
+	if(. == SUCCESSFUL_UNFASTEN)
+		if(panel_open)
+			icon_state = "grounding_rod_open[anchored]"
+		else
+			icon_state = "grounding_rod[anchored]"
+
+/obj/machinery/power/grounding_rod/attackby(obj/item/W, mob/user, params)
+	if(default_deconstruction_screwdriver(user, "grounding_rod_open[anchored]", "grounding_rod[anchored]", W))
+		return
+
+	if(default_unfasten_wrench(user, W))
+		return
+
+	if(default_deconstruction_crowbar(W))
+		return
+
+	return ..()
+
+/obj/machinery/power/grounding_rod/tesla_act(var/power)
+	if(anchored && !panel_open)
+		flick("grounding_rodhit", src)
+		tesla_buckle_check(power)
+	else
+		..()

code/modules/power/tesla/energy_ball.dm

@@ -0,0 +1,313 @@
+#define TESLA_DEFAULT_POWER 1738260
+#define TESLA_MINI_POWER 869130
+
+/obj/singularity/energy_ball
+	name = "energy ball"
+	desc = "An energy ball."
+	icon = 'icons/obj/tesla_engine/energy_ball.dmi'
+	icon_state = "energy_ball"
+	pixel_x = -32
+	pixel_y = -32
+	current_size = STAGE_TWO
+	move_self = 1
+	grav_pull = 0
+	contained = 0
+	density = TRUE
+	energy = 0
+	dissipate = 1
+	dissipate_delay = 5
+	dissipate_strength = 1
+	var/list/orbiting_balls = list()
+	var/miniball = FALSE
+	var/produced_power
+	var/energy_to_raise = 32
+	var/energy_to_lower = -20
+
+/obj/singularity/energy_ball/Initialize(mapload, starting_energy = 50, is_miniball = FALSE)
+	miniball = is_miniball
+	. = ..()
+	if(!is_miniball)
+		set_light(10, 7, "#EEEEFF")
+
+/obj/singularity/energy_ball/ex_act(severity, target)
+	return
+
+/obj/singularity/energy_ball/Destroy()
+	if(orbiting && istype(orbiting.parent, /obj/singularity/energy_ball))
+		var/obj/singularity/energy_ball/EB = orbiting.parent
+		EB.orbiting_balls -= src
+
+	for(var/ball in orbiting_balls)
+		var/obj/singularity/energy_ball/EB = ball
+		qdel(EB)
+
+	. = ..()
+
+/obj/singularity/energy_ball/admin_investigate_setup()
+	if(miniball)
+		return //don't annnounce miniballs
+	..()
+
+
+/obj/singularity/energy_ball/process()
+	if(!orbiting)
+		handle_energy()
+
+		move_the_basket_ball(4 + orbiting_balls.len * 1.5)
+
+		playsound(src.loc, 'sound/magic/lightningbolt.ogg', 100, 1, extrarange = 30)
+
+		pixel_x = 0
+		pixel_y = 0
+
+		tesla_zap(src, 7, TESLA_DEFAULT_POWER, TRUE)
+
+		pixel_x = -32
+		pixel_y = -32
+		for (var/ball in orbiting_balls)
+			var/range = rand(1, CLAMP(orbiting_balls.len, 3, 7))
+			tesla_zap(ball, range, TESLA_MINI_POWER/7*range)
+	else
+		energy = 0 // ensure we dont have miniballs of miniballs
+
+/obj/singularity/energy_ball/examine(mob/user)
+	..()
+	if(orbiting_balls.len)
+		to_chat(user, "The amount of orbiting mini-balls is [orbiting_balls.len].")
+
+
+/obj/singularity/energy_ball/proc/move_the_basket_ball(var/move_amount)
+	//we face the last thing we zapped, so this lets us favor that direction a bit
+	var/move_bias = pick(GLOB.alldirs)
+	for(var/i in 0 to move_amount)
+		var/move_dir = pick(GLOB.alldirs + move_bias) //ensures large-ball teslas don't just sit around
+		if(target && prob(10))
+			move_dir = get_dir(src,target)
+		var/turf/T = get_step(src, move_dir)
+		if(can_move(T))
+			forceMove(T)
+			setDir(move_dir)
+			for(var/mob/living/carbon/C in loc)
+				dust_mobs(C)
+
+
+/obj/singularity/energy_ball/proc/handle_energy()
+	if(energy >= energy_to_raise)
+		energy_to_lower = energy_to_raise - 20
+		energy_to_raise = energy_to_raise * 1.25
+
+		playsound(src.loc, 'sound/magic/lightning_chargeup.ogg', 100, 1, extrarange = 30)
+		addtimer(CALLBACK(src, .proc/new_mini_ball), 100)
+
+	else if(energy < energy_to_lower && orbiting_balls.len)
+		energy_to_raise = energy_to_raise / 1.25
+		energy_to_lower = (energy_to_raise / 1.25) - 20
+
+		var/Orchiectomy_target = pick(orbiting_balls)
+		qdel(Orchiectomy_target)
+
+	else if(orbiting_balls.len)
+		dissipate() //sing code has a much better system.
+
+/obj/singularity/energy_ball/proc/new_mini_ball()
+	if(!loc)
+		return
+	var/obj/singularity/energy_ball/EB = new(loc, 0, TRUE)
+
+	EB.transform *= pick(0.3, 0.4, 0.5, 0.6, 0.7)
+	var/icon/I = icon(icon,icon_state,dir)
+
+	var/orbitsize = (I.Width() + I.Height()) * pick(0.4, 0.5, 0.6, 0.7, 0.8)
+	orbitsize -= (orbitsize / world.icon_size) * (world.icon_size * 0.25)
+
+	EB.orbit(src, orbitsize, pick(FALSE, TRUE), rand(10, 25), pick(3, 4, 5, 6, 36))
+
+
+/obj/singularity/energy_ball/Bump(atom/A)
+	dust_mobs(A)
+
+/obj/singularity/energy_ball/Bumped(atom/movable/AM)
+	dust_mobs(AM)
+
+/obj/singularity/energy_ball/attack_tk(mob/user)
+	if(iscarbon(user))
+		var/mob/living/carbon/C = user
+		to_chat(C, "<span class='userdanger'>That was a shockingly dumb idea.</span>")
+		var/obj/item/organ/brain/rip_u = locate(/obj/item/organ/brain) in C.internal_organs
+		C.ghostize(0)
+		qdel(rip_u)
+		C.death()
+
+/obj/singularity/energy_ball/orbit(obj/singularity/energy_ball/target)
+	if (istype(target))
+		target.orbiting_balls += src
+		GLOB.poi_list -= src
+		target.dissipate_strength = target.orbiting_balls.len
+
+	. = ..()
+/obj/singularity/energy_ball/stop_orbit()
+	if (orbiting && istype(orbiting.parent, /obj/singularity/energy_ball))
+		var/obj/singularity/energy_ball/orbitingball = orbiting.parent
+		orbitingball.orbiting_balls -= src
+		orbitingball.dissipate_strength = orbitingball.orbiting_balls.len
+	. = ..()
+	if (!QDELETED(src))
+		qdel(src)
+
+
+/obj/singularity/energy_ball/proc/dust_mobs(atom/A)
+	if(isliving(A))
+		var/mob/living/L = A
+		if(L.incorporeal_move || L.status_flags & GODMODE)
+			return
+	if(!iscarbon(A))
+		return
+	for(var/obj/machinery/power/grounding_rod/GR in orange(src, 2))
+		if(GR.anchored)
+			return
+	var/mob/living/carbon/C = A
+	C.dust()
+
+/proc/tesla_zap(atom/source, zap_range = 3, power, tesla_flags = TESLA_DEFAULT_FLAGS, list/shocked_targets)
+	. = source.dir
+	if(power < 1000)
+		return
+
+	var/closest_dist = 0
+	var/closest_atom
+	var/obj/machinery/power/tesla_coil/closest_tesla_coil
+	var/obj/machinery/power/grounding_rod/closest_grounding_rod
+	var/mob/living/closest_mob
+	var/obj/machinery/closest_machine
+	var/obj/structure/closest_structure
+	var/obj/structure/blob/closest_blob
+	var/static/things_to_shock = typecacheof(list(/obj/machinery, /mob/living, /obj/structure))
+	var/static/blacklisted_tesla_types = typecacheof(list(/obj/machinery/atmospherics,
+										/obj/machinery/power/emitter,
+										/obj/machinery/field/generator,
+										/mob/living/simple_animal,
+										/obj/machinery/particle_accelerator/control_box,
+										/obj/structure/particle_accelerator/fuel_chamber,
+										/obj/structure/particle_accelerator/particle_emitter/center,
+										/obj/structure/particle_accelerator/particle_emitter/left,
+										/obj/structure/particle_accelerator/particle_emitter/right,
+										/obj/structure/particle_accelerator/power_box,
+										/obj/structure/particle_accelerator/end_cap,
+										/obj/machinery/field/containment,
+										/obj/structure/disposalpipe,
+										/obj/structure/disposaloutlet,
+										/obj/machinery/disposal/deliveryChute,
+										/obj/machinery/camera,
+										/obj/structure/sign,
+										/obj/machinery/gateway,
+										/obj/structure/lattice,
+										/obj/structure/grille,
+										/obj/machinery/the_singularitygen/tesla,
+										/obj/structure/frame/machine))
+
+	for(var/A in typecache_filter_multi_list_exclusion(oview(source, zap_range+2), things_to_shock, blacklisted_tesla_types))
+		if(!(tesla_flags & TESLA_ALLOW_DUPLICATES) && LAZYACCESS(shocked_targets, A))
+			continue
+
+		if(istype(A, /obj/machinery/power/tesla_coil))
+			var/dist = get_dist(source, A)
+			var/obj/machinery/power/tesla_coil/C = A
+			if(dist <= zap_range && (dist < closest_dist || !closest_tesla_coil) && !(C.obj_flags & BEING_SHOCKED))
+				closest_dist = dist
+
+				//we use both of these to save on istype and typecasting overhead later on
+				//while still allowing common code to run before hand
+				closest_tesla_coil = C
+				closest_atom = C
+
+
+		else if(closest_tesla_coil)
+			continue //no need checking these other things
+
+		else if(istype(A, /obj/machinery/power/grounding_rod))
+			var/dist = get_dist(source, A)-2
+			if(dist <= zap_range && (dist < closest_dist || !closest_grounding_rod))
+				closest_grounding_rod = A
+				closest_atom = A
+				closest_dist = dist
+
+		else if(closest_grounding_rod)
+			continue
+
+		else if(isliving(A))
+			var/dist = get_dist(source, A)
+			var/mob/living/L = A
+			if(dist <= zap_range && (dist < closest_dist || !closest_mob) && L.stat != DEAD && !(L.flags_1 & TESLA_IGNORE_1))
+				closest_mob = L
+				closest_atom = A
+				closest_dist = dist
+
+		else if(closest_mob)
+			continue
+
+		else if(ismachinery(A))
+			var/obj/machinery/M = A
+			var/dist = get_dist(source, A)
+			if(dist <= zap_range && (dist < closest_dist || !closest_machine) && !(M.obj_flags & BEING_SHOCKED))
+				closest_machine = M
+				closest_atom = A
+				closest_dist = dist
+
+		else if(closest_mob)
+			continue
+
+		else if(istype(A, /obj/structure/blob))
+			var/obj/structure/blob/B = A
+			var/dist = get_dist(source, A)
+			if(dist <= zap_range && (dist < closest_dist || !closest_tesla_coil) && !(B.obj_flags & BEING_SHOCKED))
+				closest_blob = B
+				closest_atom = A
+				closest_dist = dist
+
+		else if(closest_blob)
+			continue
+
+		else if(isstructure(A))
+			var/obj/structure/S = A
+			var/dist = get_dist(source, A)
+			if(dist <= zap_range && (dist < closest_dist || !closest_tesla_coil) && !(S.obj_flags & BEING_SHOCKED))
+				closest_structure = S
+				closest_atom = A
+				closest_dist = dist
+
+	//Alright, we've done our loop, now lets see if was anything interesting in range
+	if(closest_atom)
+		//common stuff
+		source.Beam(closest_atom, icon_state="lightning[rand(1,12)]", time=5, maxdistance = INFINITY)
+		if(!(tesla_flags & TESLA_ALLOW_DUPLICATES))
+			LAZYSET(shocked_targets, closest_atom, TRUE)
+		var/zapdir = get_dir(source, closest_atom)
+		if(zapdir)
+			. = zapdir
+
+	//per type stuff:
+	if(closest_tesla_coil)
+		closest_tesla_coil.tesla_act(power, tesla_flags, shocked_targets)
+
+	else if(closest_grounding_rod)
+		closest_grounding_rod.tesla_act(power, tesla_flags, shocked_targets)
+
+	else if(closest_mob)
+		var/shock_damage = (tesla_flags & TESLA_MOB_DAMAGE)? (min(round(power/600), 90) + rand(-5, 5)) : 0
+		closest_mob.electrocute_act(shock_damage, source, 1, tesla_shock = 1, stun = (tesla_flags & TESLA_MOB_STUN))
+		if(issilicon(closest_mob))
+			var/mob/living/silicon/S = closest_mob
+			if((tesla_flags & TESLA_MOB_STUN) && (tesla_flags & TESLA_MOB_DAMAGE))
+				S.emp_act(EMP_LIGHT)
+			tesla_zap(S, 7, power / 1.5, tesla_flags, shocked_targets) // metallic folks bounce it further
+		else
+			tesla_zap(closest_mob, 5, power / 1.5, tesla_flags, shocked_targets)
+
+	else if(closest_machine)
+		closest_machine.tesla_act(power, tesla_flags, shocked_targets)
+
+	else if(closest_blob)
+		closest_blob.tesla_act(power, tesla_flags, shocked_targets)
+
+	else if(closest_structure)
+		closest_structure.tesla_act(power, tesla_flags, shocked_targets)

code/modules/power/tesla/generator.dm

@@ -0,0 +1,10 @@
+/obj/machinery/the_singularitygen/tesla
+	name = "energy ball generator"
+	desc = "Makes the wardenclyffe look like a child's plaything when shot with a particle accelerator."
+	icon = 'icons/obj/tesla_engine/tesla_generator.dmi'
+	icon_state = "TheSingGen"
+	creation_type = /obj/singularity/energy_ball
+
+/obj/machinery/the_singularitygen/tesla/tesla_act(power, tesla_flags)
+	if(tesla_flags & TESLA_MACHINE_EXPLOSIVE)
+		energy += power

code/modules/power/tracker.dm

@@ -0,0 +1,93 @@
+//Solar tracker
+
+//Machine that tracks the sun and reports it's direction to the solar controllers
+//As long as this is working, solar panels on same powernet will track automatically
+
+/obj/machinery/power/tracker
+	name = "solar tracker"
+	desc = "A solar directional tracker."
+	icon = 'goon/icons/obj/power.dmi'
+	icon_state = "tracker"
+	density = TRUE
+	use_power = NO_POWER_USE
+	max_integrity = 250
+	integrity_failure = 50
+
+	var/id = 0
+	var/sun_angle = 0		// sun angle as set by sun datum
+	var/obj/machinery/power/solar_control/control = null
+
+/obj/machinery/power/tracker/Initialize(mapload, obj/item/solar_assembly/S)
+	. = ..()
+	Make(S)
+	connect_to_network()
+
+/obj/machinery/power/tracker/Destroy()
+	unset_control() //remove from control computer
+	return ..()
+
+//set the control of the tracker to a given computer if closer than SOLAR_MAX_DIST
+/obj/machinery/power/tracker/proc/set_control(obj/machinery/power/solar_control/SC)
+	if(!SC || (get_dist(src, SC) > SOLAR_MAX_DIST))
+		return 0
+	control = SC
+	SC.connected_tracker = src
+	return 1
+
+//set the control of the tracker to null and removes it from the previous control computer if needed
+/obj/machinery/power/tracker/proc/unset_control()
+	if(control)
+		control.connected_tracker = null
+	control = null
+
+/obj/machinery/power/tracker/proc/Make(obj/item/solar_assembly/S)
+	if(!S)
+		S = new /obj/item/solar_assembly(src)
+		S.glass_type = /obj/item/stack/sheet/glass
+		S.tracker = 1
+		S.anchored = TRUE
+	S.forceMove(src)
+	update_icon()
+
+//updates the tracker icon and the facing angle for the control computer
+/obj/machinery/power/tracker/proc/set_angle(angle)
+	sun_angle = angle
+
+	//set icon dir to show sun illumination
+	setDir(turn(NORTH, -angle - 22.5)	)// 22.5 deg bias ensures, e.g. 67.5-112.5 is EAST
+
+	if(powernet && (powernet == control.powernet)) //update if we're still in the same powernet
+		control.currentdir = angle
+
+/obj/machinery/power/tracker/crowbar_act(mob/user, obj/item/I)
+	playsound(src.loc, 'sound/machines/click.ogg', 50, 1)
+	user.visible_message("[user] begins to take the glass off [src].", "<span class='notice'>You begin to take the glass off [src]...</span>")
+	if(I.use_tool(src, user, 50))
+		playsound(src.loc, 'sound/items/deconstruct.ogg', 50, 1)
+		user.visible_message("[user] takes the glass off [src].", "<span class='notice'>You take the glass off [src].</span>")
+		deconstruct(TRUE)
+	return TRUE
+
+/obj/machinery/power/tracker/obj_break(damage_flag)
+	if(!(stat & BROKEN) && !(flags_1 & NODECONSTRUCT_1))
+		playsound(loc, 'sound/effects/glassbr3.ogg', 100, 1)
+		stat |= BROKEN
+		unset_control()
+
+/obj/machinery/power/solar/deconstruct(disassembled = TRUE)
+	if(!(flags_1 & NODECONSTRUCT_1))
+		if(disassembled)
+			var/obj/item/solar_assembly/S = locate() in src
+			if(S)
+				S.forceMove(loc)
+				S.give_glass(stat & BROKEN)
+		else
+			playsound(src, "shatter", 70, 1)
+			new /obj/item/shard(src.loc)
+			new /obj/item/shard(src.loc)
+	qdel(src)
+
+// Tracker Electronic
+
+/obj/item/electronics/tracker
+	name = "tracker electronics"

code/modules/power/turbine.dm

@@ -0,0 +1,349 @@
+// TURBINE v2 AKA rev4407 Engine reborn!
+
+// How to use it? - Mappers
+//
+// This is a very good power generating mechanism. All you need is a blast furnace with soaring flames and output.
+// Not everything is included yet so the turbine can run out of fuel quiet quickly. The best thing about the turbine is that even
+// though something is on fire that passes through it, it won't be on fire as it passes out of it. So the exhaust fumes can still
+// containt unreacted fuel - plasma and oxygen that needs to be filtered out and re-routed back. This of course requires smart piping
+// For a computer to work with the turbine the compressor requires a comp_id matching with the turbine computer's id. This will be
+// subjected to a change in the near future mind you. Right now this method of generating power is a good backup but don't expect it
+// become a main power source unless some work is done. Have fun. At 50k RPM it generates 60k power. So more than one turbine is needed!
+//
+// - Numbers
+//
+// Example setup	 S - sparker
+//					 B - Blast doors into space for venting
+// *BBB****BBB*		 C - Compressor
+// S    CT    *		 T - Turbine
+// * ^ *  * V *		 D - Doors with firedoor
+// **|***D**|**      ^ - Fuel feed (Not vent, but a gas outlet)
+//   |      |        V - Suction vent (Like the ones in atmos
+//
+
+
+/obj/machinery/power/compressor
+	name = "compressor"
+	desc = "The compressor stage of a gas turbine generator."
+	icon = 'icons/obj/atmospherics/pipes/simple.dmi'
+	icon_state = "compressor"
+	density = TRUE
+	resistance_flags = FIRE_PROOF
+	CanAtmosPass = ATMOS_PASS_DENSITY
+	circuit = /obj/item/circuitboard/machine/power_compressor
+	var/obj/machinery/power/turbine/turbine
+	var/datum/gas_mixture/gas_contained
+	var/turf/inturf
+	var/starter = 0
+	var/rpm = 0
+	var/rpmtarget = 0
+	var/capacity = 1e6
+	var/comp_id = 0
+	var/efficiency
+
+
+/obj/machinery/power/turbine
+	name = "gas turbine generator"
+	desc = "A gas turbine used for backup power generation."
+	icon = 'icons/obj/atmospherics/pipes/simple.dmi'
+	icon_state = "turbine"
+	density = TRUE
+	resistance_flags = FIRE_PROOF
+	CanAtmosPass = ATMOS_PASS_DENSITY
+	circuit = /obj/item/circuitboard/machine/power_turbine
+	var/opened = 0
+	var/obj/machinery/power/compressor/compressor
+	var/turf/outturf
+	var/lastgen
+	var/productivity = 1
+
+/obj/machinery/computer/turbine_computer
+	name = "gas turbine control computer"
+	desc = "A computer to remotely control a gas turbine."
+	icon_screen = "turbinecomp"
+	icon_keyboard = "tech_key"
+	circuit = /obj/item/circuitboard/computer/turbine_computer
+	var/obj/machinery/power/compressor/compressor
+	var/id = 0
+
+// the inlet stage of the gas turbine electricity generator
+
+/obj/machinery/power/compressor/Initialize()
+	. = ..()
+	// The inlet of the compressor is the direction it faces
+	gas_contained = new
+	inturf = get_step(src, dir)
+	locate_machinery()
+	if(!turbine)
+		stat |= BROKEN
+
+
+#define COMPFRICTION 5e5
+
+
+/obj/machinery/power/compressor/locate_machinery()
+	if(turbine)
+		return
+	turbine = locate() in get_step(src, get_dir(inturf, src))
+	if(turbine)
+		turbine.locate_machinery()
+
+/obj/machinery/power/compressor/RefreshParts()
+	var/E = 0
+	for(var/obj/item/stock_parts/manipulator/M in component_parts)
+		E += M.rating
+	efficiency = E / 6
+
+/obj/machinery/power/compressor/attackby(obj/item/I, mob/user, params)
+	if(default_deconstruction_screwdriver(user, initial(icon_state), initial(icon_state), I))
+		return
+
+	if(default_change_direction_wrench(user, I))
+		turbine = null
+		inturf = get_step(src, dir)
+		locate_machinery()
+		if(turbine)
+			to_chat(user, "<span class='notice'>Turbine connected.</span>")
+			stat &= ~BROKEN
+		else
+			to_chat(user, "<span class='alert'>Turbine not connected.</span>")
+			stat |= BROKEN
+		return
+
+	default_deconstruction_crowbar(I)
+
+/obj/machinery/power/compressor/process()
+	if(!turbine)
+		stat = BROKEN
+	if(stat & BROKEN || panel_open)
+		return
+	if(!starter)
+		return
+	cut_overlays()
+
+	rpm = 0.9* rpm + 0.1 * rpmtarget
+	var/datum/gas_mixture/environment = inturf.return_air()
+
+	// It's a simplified version taking only 1/10 of the moles from the turf nearby. It should be later changed into a better version
+
+	var/transfer_moles = environment.total_moles()/10
+	var/datum/gas_mixture/removed = inturf.remove_air(transfer_moles)
+	gas_contained.merge(removed)
+
+// RPM function to include compression friction - be advised that too low/high of a compfriction value can make things screwy
+
+	rpm = max(0, rpm - (rpm*rpm)/(COMPFRICTION*efficiency))
+
+
+	if(starter && !(stat & NOPOWER))
+		use_power(2800)
+		if(rpm<1000)
+			rpmtarget = 1000
+	else
+		if(rpm<1000)
+			rpmtarget = 0
+
+
+
+	if(rpm>50000)
+		add_overlay(mutable_appearance(icon, "comp-o4", FLY_LAYER))
+	else if(rpm>10000)
+		add_overlay(mutable_appearance(icon, "comp-o3", FLY_LAYER))
+	else if(rpm>2000)
+		add_overlay(mutable_appearance(icon, "comp-o2", FLY_LAYER))
+	else if(rpm>500)
+		add_overlay(mutable_appearance(icon, "comp-o1", FLY_LAYER))
+	 //TODO: DEFERRED
+
+// These are crucial to working of a turbine - the stats modify the power output. TurbGenQ modifies how much raw energy can you get from
+// rpms, TurbGenG modifies the shape of the curve - the lower the value the less straight the curve is.
+
+#define TURBGENQ 100000
+#define TURBGENG 0.5
+
+/obj/machinery/power/turbine/Initialize()
+	. = ..()
+// The outlet is pointed at the direction of the turbine component
+	outturf = get_step(src, dir)
+	locate_machinery()
+	if(!compressor)
+		stat |= BROKEN
+	connect_to_network()
+
+/obj/machinery/power/turbine/RefreshParts()
+	var/P = 0
+	for(var/obj/item/stock_parts/capacitor/C in component_parts)
+		P += C.rating
+	productivity = P / 6
+
+/obj/machinery/power/turbine/locate_machinery()
+	if(compressor)
+		return
+	compressor = locate() in get_step(src, get_dir(outturf, src))
+	if(compressor)
+		compressor.locate_machinery()
+
+/obj/machinery/power/turbine/process()
+
+	if(!compressor)
+		stat = BROKEN
+
+	if((stat & BROKEN) || panel_open)
+		return
+	if(!compressor.starter)
+		return
+	cut_overlays()
+
+	// This is the power generation function. If anything is needed it's good to plot it in EXCEL before modifying
+	// the TURBGENQ and TURBGENG values
+
+	lastgen = ((compressor.rpm / TURBGENQ)**TURBGENG) * TURBGENQ * productivity
+
+	add_avail(lastgen)
+
+	// Weird function but it works. Should be something else...
+
+	var/newrpm = ((compressor.gas_contained.temperature) * compressor.gas_contained.total_moles())/4
+
+	newrpm = max(0, newrpm)
+
+	if(!compressor.starter || newrpm > 1000)
+		compressor.rpmtarget = newrpm
+
+	if(compressor.gas_contained.total_moles()>0)
+		var/oamount = min(compressor.gas_contained.total_moles(), (compressor.rpm+100)/35000*compressor.capacity)
+		var/datum/gas_mixture/removed = compressor.gas_contained.remove(oamount)
+		outturf.assume_air(removed)
+
+// If it works, put an overlay that it works!
+
+	if(lastgen > 100)
+		add_overlay(mutable_appearance(icon, "turb-o", FLY_LAYER))
+
+	updateDialog()
+
+/obj/machinery/power/turbine/attackby(obj/item/I, mob/user, params)
+	if(default_deconstruction_screwdriver(user, initial(icon_state), initial(icon_state), I))
+		return
+
+	if(default_change_direction_wrench(user, I))
+		compressor = null
+		outturf = get_step(src, dir)
+		locate_machinery()
+		if(compressor)
+			to_chat(user, "<span class='notice'>Compressor connected.</span>")
+			stat &= ~BROKEN
+		else
+			to_chat(user, "<span class='alert'>Compressor not connected.</span>")
+			stat |= BROKEN
+		return
+
+	default_deconstruction_crowbar(I)
+
+/obj/machinery/power/turbine/ui_interact(mob/user)
+
+	if(!Adjacent(user)  || (stat & (NOPOWER|BROKEN)) && !issilicon(user))
+		user.unset_machine(src)
+		user << browse(null, "window=turbine")
+		return
+
+	var/t = "<TT><B>Gas Turbine Generator</B><HR><PRE>"
+
+	t += "Generated power : [DisplayPower(lastgen)]<BR><BR>"
+
+	t += "Turbine: [round(compressor.rpm)] RPM<BR>"
+
+	t += "Starter: [ compressor.starter ? "<A href='?src=[REF(src)];str=1'>Off</A> <B>On</B>" : "<B>Off</B> <A href='?src=[REF(src)];str=1'>On</A>"]"
+
+	t += "</PRE><HR><A href='?src=[REF(src)];close=1'>Close</A>"
+
+	t += "</TT>"
+	var/datum/browser/popup = new(user, "turbine", name)
+	popup.set_content(t)
+	popup.open()
+
+	return
+
+/obj/machinery/power/turbine/Topic(href, href_list)
+	if(..())
+		return
+
+	if( href_list["close"] )
+		usr << browse(null, "window=turbine")
+		usr.unset_machine(src)
+		return
+
+	else if( href_list["str"] )
+		if(compressor)
+			compressor.starter = !compressor.starter
+
+	updateDialog()
+
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// COMPUTER NEEDS A SERIOUS REWRITE.
+
+
+
+/obj/machinery/computer/turbine_computer/Initialize()
+	. = ..()
+	return INITIALIZE_HINT_LATELOAD
+
+/obj/machinery/computer/turbine_computer/LateInitialize()
+	locate_machinery()
+
+/obj/machinery/computer/turbine_computer/locate_machinery()
+	if(id)
+		for(var/obj/machinery/power/compressor/C in GLOB.machines)
+			if(C.comp_id == id)
+				compressor = C
+				return
+	else
+		compressor = locate(/obj/machinery/power/compressor) in range(5, src)
+
+/obj/machinery/computer/turbine_computer/ui_interact(mob/user, ui_key = "main", datum/tgui/ui = null, force_open = FALSE, \
+									datum/tgui/master_ui = null, datum/ui_state/state = GLOB.default_state)
+	ui = SStgui.try_update_ui(user, src, ui_key, ui, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "turbine_computer", name, 350, 280, master_ui, state)
+		ui.open()
+
+/obj/machinery/computer/turbine_computer/ui_data(mob/user)
+	var/list/data = list()
+
+	data["connected"] = (compressor && compressor.turbine) ? TRUE : FALSE
+	data["compressor_broke"] = (!compressor || (compressor.stat & BROKEN)) ? TRUE : FALSE
+	data["turbine_broke"] = (!compressor || !compressor.turbine || (compressor.turbine.stat & BROKEN)) ? TRUE : FALSE
+	data["broken"] = (data["compressor_broke"] || data["turbine_broke"])
+	data["online"] = compressor.starter
+
+	data["power"] = DisplayPower(compressor.turbine.lastgen)
+	data["rpm"] = compressor.rpm
+	data["temp"] = compressor.gas_contained.temperature
+
+	return data
+
+/obj/machinery/computer/turbine_computer/ui_act(action, params)
+	if(..())
+		return
+	switch(action)
+		if("power-on")
+			if(compressor && compressor.turbine)
+				compressor.starter = TRUE
+				. = TRUE
+		if("power-off")
+			if(compressor && compressor.turbine)
+				compressor.starter = FALSE
+				. = TRUE
+		if("reconnect")
+			locate_machinery()
+			. = TRUE
+
+#undef COMPFRICTION
+#undef TURBGENQ
+#undef TURBGENG