cyberpresidentvanellope/Bubberstation
1
0
Fork 0
mirror of https://github.com/Bubberstation/Bubberstation.git synced 2026-02-04 21:39:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
efdcd78046fb7d985cf6f92ab407fc42e80731bb
Bubberstation/code/modules/power/power.dm
SkyratBot 43e821c474 [MIRROR] Cell chargers now respect the law of conservation of energy. (#1668) 
* Cell chargers now respect the law of conservation of energy. (#54886)

## About The Pull Request

Hopefully I can make this PR as knowledge filled as possible, so sit down and buckle up, because we're about to talk about POWER USE.

So, machines use power. The station uses power. Without power, key, critical aspects of the game don't function, and keeping the station's lifeblood pumped with electricity is the primary goal of the engineering department. Cool. So there's currently 2 methods of "power use" that machines can use, that is, through the passive use of power (Assigned by the `idle_power_usage` and `active_power_usage` variables), or through the `use_power()` proc. What's interesting, is that neither proc actually draws directly from the cell of the APC, which is sort of assumed by a proc called `use_power()`, after all. Where the passive power draw aspect of an APC is done automatically as machines are processed, and then applied to the APC seperately, taking power per cycle, use_power just applies a temporary blip of power usage to one of the APC's power tracks (Equipment, Lighting, or Enviroment). One would assume then that this temporary power drain would apply for long enough that it would apply the intended cost to the cell, and then turn off.

But I'm making this PR, right?

So the most egregious issue this brings is in terms of the cell recharger. If you place a power cell into a cell recharger, the recharger calls use_power every processing tick in order to reduce the APC cell by an equivalent amount to what the cell is intending to gain in charge. After all, you're just moving the charge from the APC to the power cell, plus the processing charge required by the cell_charger. However, lets look a bit closer at how use_power actually works. For this example we'll use a default, unupgraded cell recharger attempting to put it's default 250 watts into an empty bluespace cell.
Because power is heavily linked to the area that the machinery is placed in, we snag the area, determine the power channel, and call a use power proc on the area. The area use power proc simply adds that 250 watts, or rather joules into the equipment power channel of the APC, a part of power usage. All of this is parroted over to the APC's processing side, where the actual cost to the power cell is calcualted as follows:
`var/cellused = min(cell.charge, GLOB.CELLRATE * lastused_total)	// clamp deduction to a max, amount left in cell
		cell.use(cellused)`
So that number, the 250 joules of power we're calling to the cell, is actually being multiplied by a global cellrate, which is applied to every power drain on the station, actually charging the APC cell a total of 0.5 kj.
Based on some rumentary math and some experimentation, I filled a full bluespace power cell with 40Mj of power using 351 Kj of power from a standard, stock APC cell with no other drain except the 5 joules of power draw from the cell recharger.

So: What does this mean?

- Power draw is completely fucking busted (We knew this).
- Using two power cells, an APC, and an inducer, you can create infinite energy, anywhere, at zero cost to the station.
- We really need to make cell recharging a direct power draw.

Thankfully, that last one actually fits the portfolio of being a fix!
This adds a new proc to machines called `directly_use_power`. It does what it says on the tin, directly charges the APC for instances where power is going 1-1 from a power cell to another cell, in order to prevent infinite energy exploits.

## Why It's Good For The Game

Power is all kinds of unbalanced. Attempting to enforce the concept that a single unit of power is equal to itself is probably a good step in the right direction and in all likelyhood appears to have been the original intent with cell chargers in the first place.

I'm self-aware enough to see that this has ramifications beyond just fixing an issue within the cell charger alone, so if maintainers want to close this until december that's perfectly fine, but this is one of those things that could really easily snap basic station balance in twain.

* Cell chargers now respect the law of conservation of energy.

Co-authored-by: ArcaneMusic <41715314+ArcaneMusic@users.noreply.github.com>
2020-11-11 02:51:11 +00:00

399 lines
12 KiB
Plaintext
Raw Blame History

//////////////////////////////
// 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
var/machinery_layer = MACHINERY_LAYER_1 //cable layer to which the machine is connected
/obj/machinery/power/Destroy()
disconnect_from_network()
addtimer(CALLBACK(GLOBAL_PROC, .proc/update_cable_icons_on_turf, get_turf(src)), 3)
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()
//override this if the machine needs special functionality for making wire nodes appear, ie emitters, generators, etc.
/obj/machinery/power/proc/should_have_node()
return FALSE
/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(amount)
if(powernet)
return amount ? powernet.avail >= amount : 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(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)
/**
* An alternative to 'use_power', this proc directly costs the APC in direct charge, as opposed to being calculated periodically.
* - Amount: How much power the APC's cell is to be costed.
*/
/obj/machinery/proc/directly_use_power(amount)
var/area/A = get_area(src)
var/obj/machinery/power/apc/local_apc
if(!A)
return FALSE
local_apc = A.get_apc()
if(!local_apc)
return FALSE
if(!local_apc.cell)
return FALSE
local_apc.cell.use(amount)
return TRUE
/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)
/**
* Called whenever the power settings of the containing area change
*
* by default, check equipment channel & set flag, can override if needed
*
* Returns TRUE if the NOPOWER flag was toggled
*/
/obj/machinery/proc/power_change()
SIGNAL_HANDLER
SHOULD_CALL_PARENT(TRUE)
if(machine_stat & BROKEN)
return
if(powered(power_channel))
if(machine_stat & NOPOWER)
SEND_SIGNAL(src, COMSIG_MACHINERY_POWER_RESTORED)
. = TRUE
set_machine_stat(machine_stat & ~NOPOWER)
else
if(!(machine_stat & NOPOWER))
SEND_SIGNAL(src, COMSIG_MACHINERY_POWER_LOST)
. = TRUE
set_machine_stat(machine_stat | NOPOWER)
update_icon()
// connect the machine to a powernet if a node cable or a terminal 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(machinery_layer) //check if we have a node cable on the machine turf, the first found is picked
if(!C || !C.powernet)
var/obj/machinery/power/terminal/term = locate(/obj/machinery/power/terminal) in T
if(!term || !term.powernet)
return FALSE
else
term.powernet.add_machine(src)
return TRUE
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/turf/T
for(var/card in GLOB.cardinals)
T = get_step(loc,card)
for(var/obj/structure/cable/C in T)
if(C.powernet)
continue
. += 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/turf/T
for(var/card in GLOB.cardinals)
T = get_step(loc,card)
for(var/obj/structure/cable/C in T)
. += 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
. += C
return .
/proc/update_cable_icons_on_turf(turf/T)
for(var/obj/structure/cable/C in T.contents)
C.update_icon()
///////////////////////////////////////////
// GLOBAL PROCS for powernets handling
//////////////////////////////////////////
///remove the old powernet and replace it with a new one throughout the network.
/proc/propagate_network(obj/structure/cable/C, datum/powernet/PN, skip_assigned_powernets = FALSE)
var/list/found_machines = list()
var/list/cables = list()
var/index = 1
var/obj/structure/cable/working_cable
cables[C] = TRUE //associated list for performance reasons
while(index <= length(cables))
working_cable = cables[index]
index++
var/list/connections = working_cable.get_cable_connections(skip_assigned_powernets)
for(var/obj/structure/cable/cable_entry in connections)
if(!cables[cable_entry]) //Since it's an associated list, we can just do an access and check it's null before adding; prevents duplicate entries
cables[cable_entry] = TRUE
for(var/obj/structure/cable/cable_entry in cables)
PN.add_cable(cable_entry)
found_machines += cable_entry.get_machine_connections(skip_assigned_powernets)
//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
/// Extracts the powernet and cell of the provided power source
/proc/get_powernet_info_from_source(power_source)
var/area/source_area
if (isarea(power_source))
source_area = power_source
power_source = source_area.get_apc()
else 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
return FALSE
if (!cell && !PN)
return
return list("powernet" = PN, "cell" = cell)
//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 power cell, 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/victim, power_source, obj/source, siemens_coeff = 1, dist_check = FALSE)
if(!istype(victim) || ismecha(victim.loc))
return FALSE //feckin mechs are dumb
if(dist_check)
if(!in_range(source, victim))
return FALSE
if(victim.wearing_shock_proof_gloves())
SEND_SIGNAL(victim, COMSIG_LIVING_SHOCK_PREVENTED, power_source, source, siemens_coeff, dist_check)
return FALSE //to avoid spamming with insulated gloves on
var/list/powernet_info = get_powernet_info_from_source(power_source)
if (!powernet_info)
return FALSE
var/datum/powernet/PN = powernet_info["powernet"]
var/obj/item/stock_parts/cell/cell = powernet_info["cell"]
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 = victim.electrocute_act(shock_damage, source, siemens_coeff) //zzzzzzap!
log_combat(source, victim, "electrocuted")
var/drained_energy = drained_hp*20
if (isarea(power_source))
var/area/source_area = power_source
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 cable able connect to machinery on layer if there's one on the turf, null if there isn't one
/turf/proc/get_cable_node(machinery_layer = MACHINERY_LAYER_1)
if(!can_have_cabling())
return null
for(var/obj/structure/cable/C in src)
if(C.machinery_layer & machinery_layer)
C.update_icon()
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
Reference in New Issue View Git Blame Copy Permalink