diff --git a/code/__defines/machinery.dm b/code/__defines/machinery.dm index 3c561cc291d..718a94118d3 100644 --- a/code/__defines/machinery.dm +++ b/code/__defines/machinery.dm @@ -17,6 +17,7 @@ var/global/defer_powernet_rebuild = 0 // True if net rebuild will be called #define USE_POWER_ACTIVE 2 // Machine is using power at its active power level // Channel numbers for power. +#define CURRENT_CHANNEL -1 // Passed as an argument this means "use whatever current channel is" #define EQUIP 1 #define LIGHT 2 #define ENVIRON 3 diff --git a/code/controllers/subsystems/machines.dm b/code/controllers/subsystems/machines.dm index 7f35bfd9719..29d6ecce564 100644 --- a/code/controllers/subsystems/machines.dm +++ b/code/controllers/subsystems/machines.dm @@ -121,10 +121,8 @@ SUBSYSTEM_DEF(machines) while(current_run.len) var/obj/machinery/M = current_run[current_run.len] current_run.len-- - if(istype(M) && !QDELETED(M) && !(M.process(wait) == PROCESS_KILL)) - if(M.use_power) - M.auto_use_power() - else + + if(!istype(M) || QDELETED(M) || (M.process(wait) == PROCESS_KILL)) global.processing_machines.Remove(M) if(!QDELETED(M)) DISABLE_BITFIELD(M.datum_flags, DF_ISPROCESSING) diff --git a/code/game/area/areas.dm b/code/game/area/areas.dm index 6c7cb1597b3..35f5d829976 100644 --- a/code/game/area/areas.dm +++ b/code/game/area/areas.dm @@ -21,14 +21,22 @@ var/requires_power = 1 var/always_unpowered = 0 //this gets overriden to 1 for space in area/New() - var/power_equip = 1 - var/power_light = 1 - var/power_environ = 1 - var/music = null - var/used_equip = 0 - var/used_light = 0 - var/used_environ = 0 + // Power channel status - Is it currently energized? + var/power_equip = TRUE + var/power_light = TRUE + var/power_environ = TRUE + // Oneoff power usage - Used once and cleared each power cycle + var/oneoff_equip = 0 + var/oneoff_light = 0 + var/oneoff_environ = 0 + + // Continuous "static" power usage - Do not update these directly! + var/static_equip = 0 + var/static_light = 0 + var/static_environ = 0 + + var/music = null var/has_gravity = 1 var/secret_name = FALSE // This tells certain things that display areas' names that they shouldn't display this area's name. var/obj/machinery/power/apc/apc = null @@ -81,7 +89,7 @@ for(var/atom/movable/AM in T) A.Entered(AM, old_area) for(var/obj/machinery/M in T) - M.power_change() + M.area_changed(old_area, A) /area/proc/get_contents() return contents @@ -251,32 +259,66 @@ if (fire || eject || party) updateicon() -/area/proc/usage(var/chan) +/area/proc/usage(var/chan, var/include_static = TRUE) var/used = 0 switch(chan) if(LIGHT) - used += used_light + used += oneoff_light + (include_static * static_light) if(EQUIP) - used += used_equip + used += oneoff_equip + (include_static * static_equip) if(ENVIRON) - used += used_environ + used += oneoff_environ + (include_static * static_environ) if(TOTAL) - used += used_light + used_equip + used_environ + used += oneoff_light + (include_static * static_light) + used += oneoff_equip + (include_static * static_equip) + used += oneoff_environ + (include_static * static_environ) return used +// Helper for APCs; will generally be called every tick. /area/proc/clear_usage() - used_equip = 0 - used_light = 0 - used_environ = 0 + oneoff_equip = 0 + oneoff_light = 0 + oneoff_environ = 0 -/area/proc/use_power(var/amount, var/chan) +// Use this for a one-time power draw from the area, typically for non-machines. +/area/proc/use_power_oneoff(var/amount, var/chan) switch(chan) if(EQUIP) - used_equip += amount + oneoff_equip += amount if(LIGHT) - used_light += amount + oneoff_light += amount if(ENVIRON) - used_environ += amount + oneoff_environ += amount + +// This is used by machines to properly update the area of power changes. +/area/proc/power_use_change(old_amount, new_amount, chan) + use_power_static(new_amount - old_amount, chan) // Simultaneously subtract old_amount and add new_amount. + +// Not a proc you want to use directly unless you know what you are doing; see use_power_oneoff below instead. +/area/proc/use_power_static(var/amount, var/chan) + switch(chan) + if(EQUIP) + static_equip += amount + if(LIGHT) + static_light += amount + if(ENVIRON) + static_environ += amount + +// This recomputes the continued power usage; can be used for testing or error recovery, but is not called every tick. +/area/proc/retally_power() + static_equip = 0 + static_light = 0 + static_environ = 0 + for(var/obj/machinery/M in src) + switch(M.power_channel) + if(EQUIP) + static_equip += M.get_power_usage() + if(LIGHT) + static_light += M.get_power_usage() + if(ENVIRON) + static_environ += M.get_power_usage() + +////////////////////////////////////////////////////////////////// var/list/mob/living/forced_ambiance_list = new diff --git a/code/game/machinery/machinery.dm b/code/game/machinery/machinery.dm index 31505f3a298..b5f719b258d 100644 --- a/code/game/machinery/machinery.dm +++ b/code/game/machinery/machinery.dm @@ -5,12 +5,16 @@ Overview: of 'Del' removes reference to src machine in global 'machines list'. Class Variables: + + power_init_complete (boolean) + Indicates that we have have registered our static power usage with the area. + use_power (num) current state of auto power use. Possible Values: - 0 -- no auto power use - 1 -- machine is using power at its idle power level - 2 -- machine is using power at its active power level + USE_POWER_OFF:0 -- no auto power use + USE_POWER_IDLE:1 -- machine is using power at its idle power level + USE_POWER_ACTIVE:2 -- machine is using power at its active power level active_power_usage (num) Value for the amount of power to use when in active power mode @@ -51,28 +55,20 @@ Class Procs: Destroy() 'game/machinery/machine.dm' - auto_use_power() 'game/machinery/machine.dm' - This proc determines how power mode power is deducted by the machine. - 'auto_use_power()' is called by the 'master_controller' game_controller every - tick. + get_power_usage() 'game/machinery/machinery_power.dm' + Returns the amount of power this machine uses every SSmachines cycle. + Default definition uses 'use_power', 'active_power_usage', 'idle_power_usage' - Return Value: - return:1 -- if object is powered - return:0 -- if object is not powered. - - Default definition uses 'use_power', 'power_channel', 'active_power_usage', - 'idle_power_usage', 'powered()', and 'use_power()' implement behavior. - - powered(chan = EQUIP) 'modules/power/power.dm' + powered(chan = CURRENT_CHANNEL) 'game/machinery/machinery_power.dm' Checks to see if area that contains the object has power available for power channel given in 'chan'. - use_power(amount, chan=EQUIP, autocalled) 'modules/power/power.dm' + use_power_oneoff(amount, chan=CURRENT_CHANNEL) 'game/machinery/machinery_power.dm' Deducts 'amount' from the power channel 'chan' of the area that contains the object. If it's autocalled then everything is normal, if something else calls use_power we are going to need to recalculate the power two ticks in a row. - power_change() 'modules/power/power.dm' + power_change() 'game/machinery/machinery_power.dm' Called by the area that contains the object when ever that area under goes a power state change (area runs out of power, or area channel is turned off). @@ -108,6 +104,7 @@ Class Procs: var/idle_power_usage = 0 var/active_power_usage = 0 var/power_channel = EQUIP //EQUIP, ENVIRON or LIGHT + var/power_init_complete = FALSE var/list/component_parts = null //list of all the parts used to build it, if made from certain kinds of frames. var/uid var/panel_open = 0 @@ -145,7 +142,9 @@ Class Procs: if(A.loc == src) // If the components are inside the machine, delete them. qdel(A) else // Otherwise we assume they were dropped to the ground during deconstruction, and were not removed from the component_parts list by deconstruction code. - component_parts -= A + warning("[A] was still in [src]'s component_parts when it was Destroy()'d") + component_parts.Cut() + component_parts = null if(contents) // The same for contents. for(var/atom/A in contents) if(ishuman(A)) @@ -157,9 +156,8 @@ Class Procs: qdel(A) return ..() -/obj/machinery/process()//If you dont use process or power why are you here - if(!(use_power || idle_power_usage || active_power_usage)) - return PROCESS_KILL +/obj/machinery/process() // Steady power usage is handled separately. If you dont use process why are you here? + return PROCESS_KILL /obj/machinery/emp_act(severity) if(use_power && stat == 0) @@ -192,31 +190,6 @@ Class Procs: else return -//sets the use_power var and then forces an area power update -/obj/machinery/proc/update_use_power(var/new_use_power) - use_power = new_use_power - -// Sets the power_channel var -/obj/machinery/proc/update_power_channel(var/new_channel) - power_channel = new_channel - -// Sets the idle_power_usage var -/obj/machinery/proc/update_idle_power_usage(var/new_power_usage) - idle_power_usage = new_power_usage - -// Sets the active_power_usage var -/obj/machinery/proc/update_active_power_usage(var/new_power_usage) - active_power_usage = new_power_usage - -/obj/machinery/proc/auto_use_power() - if(!powered(power_channel)) - return 0 - if(use_power == USE_POWER_IDLE) - use_power(idle_power_usage, power_channel, 1) - else if(use_power >= USE_POWER_ACTIVE) - use_power(active_power_usage, power_channel, 1) - return 1 - /obj/machinery/proc/operable(var/additional_flags = 0) return !inoperable(additional_flags) diff --git a/code/game/machinery/machinery_power.dm b/code/game/machinery/machinery_power.dm new file mode 100644 index 00000000000..85c9fe2c1c7 --- /dev/null +++ b/code/game/machinery/machinery_power.dm @@ -0,0 +1,183 @@ +// +// /obj/machinery POWER USAGE CODE HERE! GO GO GADGET STATIC POWER! +// Note: You can dinf /obj/machinery/power power usage code in power.dm +// +// The following four machinery variables determine the "static" amount of power used every power cycle: +// - use_power, idle_power_usage, active_power_usage, power_channel +// +// Please never change any of these variables! Use the procs that update them instead! +// + +// Note that we update the area even if the area is unpowered. +#define REPORT_POWER_CONSUMPTION_CHANGE(old_power, new_power)\ + if(old_power != new_power){\ + var/area/A = get_area(src);\ + if(A) A.power_use_change(old_power, new_power, power_channel)} + +// Current power consumption right now. +#define POWER_CONSUMPTION (use_power == USE_POWER_IDLE ? idle_power_usage : (use_power >= USE_POWER_ACTIVE ? active_power_usage : 0)) + +// 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 = CURRENT_CHANNEL) // defaults to power_channel + + if(!src.loc) + return 0 + + //Don't do this. It allows machines that set use_power to 0 when off (many machines) to + //be turned on again and used after a power failure because they never gain the NOPOWER flag. + //if(!use_power) + // return 1 + + var/area/A = src.loc.loc // make sure it's in an area + if(!A || !isarea(A)) + return 0 // if not, then not powered + if(chan == CURRENT_CHANNEL) + chan = power_channel + return A.powered(chan) // return power status of the area + +// called whenever the power settings of the containing area change +// by default, check equipment channel & set/clear NOPOWER flag +// Returns TRUE if NOPOWER stat flag changed. +// can override if needed +/obj/machinery/proc/power_change() + var/oldstat = stat + if(powered(power_channel)) + stat &= ~NOPOWER + else + stat |= NOPOWER + . = (stat != oldstat) + return + +// Get the amount of power this machine will consume each cycle. Override by experts only! +/obj/machinery/proc/get_power_usage() + return POWER_CONSUMPTION + +// DEPRECATED! - USE use_power_oneoff() instead! +/obj/machinery/proc/use_power(var/amount, var/chan = -1) // defaults to power_channel + return src.use_power_oneoff(amount, chan); + +// This will have this machine have its area eat this much power next tick, and not afterwards. Do not use for continued power draw. +// Returns actual amount drawn (In theory this could be less than the amount asked for. In pratice it won't be FOR NOW) +/obj/machinery/proc/use_power_oneoff(var/amount, var/chan = CURRENT_CHANNEL) + var/area/A = get_area(src) // make sure it's in an area + if(!A || !isarea(A)) + return + if(chan == CURRENT_CHANNEL) + chan = power_channel + A.use_power_oneoff(amount, chan) + return amount // TODO - Return A.use_power_oneoff()'s retval once it returns something. + +// Check if we CAN use a given amount of extra power as a one off. Returns amount we could use without actually using it. +// For backwards compatibilty this returns true if the channel is powered. This is consistant with pre-static-power +// behavior of APC powerd machines, but at some point we might want to make this a bit cooler. +/obj/machinery/proc/can_use_power_oneoff(var/amount, var/chan = CURRENT_CHANNEL) + if(powered(chan)) + return amount // If channel is powered then you can do it. + return 0 + +// Do not do power stuff in New/Initialize until after ..() +/obj/machinery/Initialize() + . = ..() + var/power = POWER_CONSUMPTION + REPORT_POWER_CONSUMPTION_CHANGE(0, power) + power_init_complete = TRUE + +// Or in Destroy at all, but especially after the ..(). +/obj/machinery/Destroy() + if(ismovable(loc)) + GLOB.moved_event.unregister(loc, src, .proc/update_power_on_move) // Unregister just in case + var/power = POWER_CONSUMPTION + REPORT_POWER_CONSUMPTION_CHANGE(power, 0) + . = ..() + +// Registering moved_event observers for all machines is too expensive. Instead we do it ourselves. +// 99% of machines are always on a turf anyway, very few need recursive move handling. +/obj/machinery/Move() + var/old_loc = loc + if((. = ..())) + update_power_on_move(src, old_loc, loc) + if(ismovable(loc)) // Register for recursive movement (if the thing we're inside moves) + GLOB.moved_event.register(loc, src, .proc/update_power_on_move) + if(ismovable(old_loc)) // Unregister recursive movement. + GLOB.moved_event.unregister(old_loc, src, .proc/update_power_on_move) + +/obj/machinery/forceMove(atom/destination) + var/old_loc = loc + if((. = ..())) + update_power_on_move(src, old_loc, loc) + if(ismovable(loc)) // Register for recursive movement (if the thing we're inside moves) + GLOB.moved_event.register(loc, src, .proc/update_power_on_move) + if(ismovable(old_loc)) // Unregister recursive movement. + GLOB.moved_event.unregister(old_loc, src, .proc/update_power_on_move) + +/obj/machinery/proc/update_power_on_move(atom/movable/mover, atom/old_loc, atom/new_loc) + var/area/old_area = get_area(old_loc) + var/area/new_area = get_area(new_loc) + if(old_area != new_area) + area_changed(old_area, new_area) + +/obj/machinery/proc/area_changed(area/old_area, area/new_area) + if(old_area == new_area || !power_init_complete) + return + var/power = POWER_CONSUMPTION + if(!power) + return // This is the most likely case anyway. + + if(old_area) + old_area.power_use_change(power, 0, power_channel) // Remove our usage from old area + if(new_area) + new_area.power_use_change(0, power, power_channel) // Add our usage to new area + power_change() // Force check in case the old area was powered and the new one isn't or vice versa. + +// +// Usage Update Procs - These procs are the only allowed way to modify these four variables: +// - use_power, idle_power_usage, active_power_usage, power_channel +// + +// Sets the use_power var and then forces an area power update +/obj/machinery/proc/update_use_power(var/new_use_power) + if(use_power == new_use_power) + return + if(!power_init_complete) + use_power = new_use_power + return TRUE // We'll be retallying anyway. + var/old_power = POWER_CONSUMPTION + use_power = new_use_power + var/new_power = POWER_CONSUMPTION + REPORT_POWER_CONSUMPTION_CHANGE(old_power, new_power) + return TRUE + +// Sets the power_channel var and then forces an area power update. +/obj/machinery/proc/update_power_channel(var/new_channel) + if(power_channel == new_channel) + return + if(!power_init_complete) + power_channel = new_channel + return TRUE // We'll be retallying anyway. + var/power = POWER_CONSUMPTION + REPORT_POWER_CONSUMPTION_CHANGE(power, 0) // Subtract from old channel + power_channel = new_channel + REPORT_POWER_CONSUMPTION_CHANGE(0, power) // Add to new channel + return TRUE + +// Sets the idle_power_usage var and then forces an area power update if use_power was USE_POWER_IDLE +/obj/machinery/proc/update_idle_power_usage(var/new_power_usage) + if(idle_power_usage == new_power_usage) + return + var/old_power = idle_power_usage + idle_power_usage = new_power_usage + if(power_init_complete && use_power == USE_POWER_IDLE) // If this is the channel in use + REPORT_POWER_CONSUMPTION_CHANGE(old_power, new_power_usage) + +// Sets the active_power_usage var and then forces an area power update if use_power was USE_POWER_ACTIVE +/obj/machinery/proc/update_active_power_usage(var/new_power_usage) + if(active_power_usage == new_power_usage) + return + var/old_power = active_power_usage + active_power_usage = new_power_usage + if(power_init_complete && use_power == USE_POWER_ACTIVE) // If this is the channel in use + REPORT_POWER_CONSUMPTION_CHANGE(old_power, new_power_usage) + +#undef REPORT_POWER_CONSUMPTION_CHANGE +#undef POWER_CONSUMPTION diff --git a/code/game/machinery/rechargestation.dm b/code/game/machinery/rechargestation.dm index 3f60e0ae070..0761c0c7aeb 100644 --- a/code/game/machinery/rechargestation.dm +++ b/code/game/machinery/rechargestation.dm @@ -62,6 +62,9 @@ recharge_amount = cell.give(recharge_amount) use_power(recharge_amount / CELLRATE) + else + // Since external power is offline, draw operating current from the internal cell + cell.use(get_power_usage() * CELLRATE) if(icon_update_tick >= 10) icon_update_tick = 0 @@ -71,19 +74,6 @@ if(occupant || recharge_amount) update_icon() -//since the recharge station can still be on even with NOPOWER. Instead it draws from the internal cell. -/obj/machinery/recharge_station/auto_use_power() - if(!(stat & NOPOWER)) - return ..() - - if(!has_cell_power()) - return 0 - if(use_power == USE_POWER_IDLE) - cell.use(idle_power_usage * CELLRATE) - else if(use_power >= USE_POWER_ACTIVE) - cell.use(active_power_usage * CELLRATE) - return 1 - //Processes the occupant, drawing from the internal power cell if needed. /obj/machinery/recharge_station/proc/process_occupant() if(isrobot(occupant)) diff --git a/code/game/mecha/equipment/tools/energy_relay.dm b/code/game/mecha/equipment/tools/energy_relay.dm index d6917a0de1c..0e02f927e41 100644 --- a/code/game/mecha/equipment/tools/energy_relay.dm +++ b/code/game/mecha/equipment/tools/energy_relay.dm @@ -111,5 +111,5 @@ if(pow_chan) var/delta = min(12, ER.chassis.cell.maxcharge-cur_charge) ER.chassis.give_power(delta) - A.use_power(delta*ER.coeff, pow_chan) + A.use_power_oneoff(delta*ER.coeff, pow_chan) return \ No newline at end of file diff --git a/code/game/objects/structures/electricchair.dm b/code/game/objects/structures/electricchair.dm index ae5cba7cf09..b3f174e25a5 100644 --- a/code/game/objects/structures/electricchair.dm +++ b/code/game/objects/structures/electricchair.dm @@ -56,7 +56,7 @@ return if(!A.powered(EQUIP)) return - A.use_power(EQUIP, 5000) + A.use_power_oneoff(5000, EQUIP) var/light = A.power_light A.updateicon() diff --git a/code/modules/integrated_electronics/passive/power.dm b/code/modules/integrated_electronics/passive/power.dm index f26bc693bc3..631365c5e95 100644 --- a/code/modules/integrated_electronics/passive/power.dm +++ b/code/modules/integrated_electronics/passive/power.dm @@ -160,7 +160,7 @@ var/area/A = get_area(src) if(A) if(A.powered(EQUIP) && assembly.give_power(power_amount)) - A.use_power(power_amount, EQUIP) + A.use_power_oneoff(power_amount, EQUIP) // give_power() handles CELLRATE on its own. // Interacts with the powernet. diff --git a/code/modules/modular_computers/computers/modular_computer/power.dm b/code/modules/modular_computers/computers/modular_computer/power.dm index b3746d55d44..5d12d2e174e 100644 --- a/code/modules/modular_computers/computers/modular_computer/power.dm +++ b/code/modules/modular_computers/computers/modular_computer/power.dm @@ -38,7 +38,7 @@ power_usage += tesla_link.passive_charging_rate battery_module.battery.give(tesla_link.passive_charging_rate * CELLRATE) - A.use_power(power_usage, EQUIP) + A.use_power_oneoff(power_usage, EQUIP) return TRUE // Handles power-related things, such as battery interaction, recharging, shutdown when it's discharged diff --git a/code/modules/overmap/ships/computers/computer_shims.dm b/code/modules/overmap/ships/computers/computer_shims.dm index 110ffb55930..ea781909272 100644 --- a/code/modules/overmap/ships/computers/computer_shims.dm +++ b/code/modules/overmap/ships/computers/computer_shims.dm @@ -12,10 +12,6 @@ // Power // -// This will have this machine have its area eat this much power next tick, and not afterwards. Do not use for continued power draw. -/obj/machinery/proc/use_power_oneoff(var/amount, var/chan = -1) - return use_power(amount, chan) - // Change one of the power consumption vars /obj/machinery/proc/change_power_consumption(new_power_consumption, use_power_mode = USE_POWER_IDLE) switch(use_power_mode) @@ -95,7 +91,7 @@ /obj/machinery/computer/ship/attack_ghost(mob/user) interface_interact(user) -// If you don't call parent in this proc, you must make all appropriate checks yourself. +// If you don't call parent in this proc, you must make all appropriate checks yourself. // If you do, you must respect the return value. /obj/machinery/computer/ship/attack_hand(mob/user) if((. = ..())) diff --git a/code/modules/power/apc.dm b/code/modules/power/apc.dm index 05525265f46..0a5e2132c37 100644 --- a/code/modules/power/apc.dm +++ b/code/modules/power/apc.dm @@ -34,10 +34,10 @@ // controls power to devices in that area // may be opened to change power cell // three different channels (lighting/equipment/environ) - may each be set to on, off, or auto -#define POWERCHAN_OFF 0 -#define POWERCHAN_OFF_AUTO 1 -#define POWERCHAN_ON 2 -#define POWERCHAN_ON_AUTO 3 +#define POWERCHAN_OFF 0 // Power channel is off and will stay that way dammit +#define POWERCHAN_OFF_AUTO 1 // Power channel is off until power rises above a threshold +#define POWERCHAN_ON 2 // Power channel is on until there is no power +#define POWERCHAN_ON_AUTO 3 // Power channel is on until power drops below a threshold //NOTE: STUFF STOLEN FROM AIRLOCK.DM thx @@ -1037,10 +1037,9 @@ return 0 /obj/machinery/power/apc/process() - - if(stat & (BROKEN|MAINT)) - return if(!area.requires_power) + return PROCESS_KILL + if(stat & (BROKEN|MAINT)) return if(failure_timer) update() @@ -1049,9 +1048,9 @@ force_update = 1 return - lastused_light = area.usage(LIGHT) - lastused_equip = area.usage(EQUIP) - lastused_environ = area.usage(ENVIRON) + lastused_light = area.usage(LIGHT, lighting >= POWERCHAN_ON) + lastused_equip = area.usage(EQUIP, equipment >= POWERCHAN_ON) + lastused_environ = area.usage(ENVIRON, environ >= POWERCHAN_ON) area.clear_usage() lastused_total = lastused_light + lastused_equip + lastused_environ diff --git a/code/modules/power/power.dm b/code/modules/power/power.dm index a88d0dafdc3..25720561bc0 100644 --- a/code/modules/power/power.dm +++ b/code/modules/power/power.dm @@ -64,44 +64,6 @@ /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(!src.loc) - return 0 - - //Don't do this. It allows machines that set use_power to 0 when off (many machines) to - //be turned on again and used after a power failure because they never gain the NOPOWER flag. - //if(!use_power) - // return 1 - - var/area/A = src.loc.loc // make sure it's in an area - if(!A || !isarea(A)) - return 0 // 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(var/amount, var/chan = -1) // defaults to power_channel - var/area/A = get_area(src) // make sure it's in an area - if(!A || !isarea(A)) - return - if(chan == -1) - chan = power_channel - A.use_power(amount, chan) - -/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 @@ -372,7 +334,7 @@ var/drained_energy = drained_hp*20 if (source_area) - source_area.use_power(drained_energy/CELLRATE) + source_area.use_power_oneoff(drained_energy/CELLRATE, EQUIP) else if (istype(power_source,/datum/powernet)) var/drained_power = drained_energy/CELLRATE drained_power = PN.draw_power(drained_power) diff --git a/code/modules/reagents/distilling/distilling.dm b/code/modules/reagents/distilling/distilling.dm index 78780a35433..40a1e7e6b22 100644 --- a/code/modules/reagents/distilling/distilling.dm +++ b/code/modules/reagents/distilling/distilling.dm @@ -267,7 +267,7 @@ return if(chan == -1) chan = power_channel - A.use_power(amount, chan) + A.use_power_oneoff(amount, chan) /obj/machinery/portable_atmospherics/powered/reagent_distillery/process() ..() diff --git a/vorestation.dme b/vorestation.dme index 7a1b7c71fe1..ab0462c30a9 100644 --- a/vorestation.dme +++ b/vorestation.dme @@ -772,6 +772,7 @@ #include "code\game\machinery\jukebox.dm" #include "code\game\machinery\lightswitch.dm" #include "code\game\machinery\machinery.dm" +#include "code\game\machinery\machinery_power.dm" #include "code\game\machinery\magnet.dm" #include "code\game\machinery\mass_driver.dm" #include "code\game\machinery\navbeacon.dm"