mirror of
https://github.com/goonstation/goonstation-2016.git
synced 2026-03-20 08:22:37 +00:00
716 lines
20 KiB
Plaintext
716 lines
20 KiB
Plaintext
datum/computer/file/embedded_program
|
|
var/list/memory = list()
|
|
var/state
|
|
var/obj/machinery/embedded_controller/master
|
|
|
|
proc
|
|
post_signal(datum/signal/signal, comm_line)
|
|
if(master)
|
|
master.post_signal(signal, comm_line)
|
|
//else
|
|
// qdel(signal)
|
|
|
|
receive_user_command(command)
|
|
|
|
receive_signal(datum/signal/signal, receive_method, receive_param)
|
|
return null
|
|
|
|
process()
|
|
return 0
|
|
|
|
|
|
datum/computer/file/embedded_program/access_controller
|
|
var/id_tag
|
|
var/exterior_door_tag
|
|
var/interior_door_tag
|
|
|
|
state = ACCESS_STATE_LOCKED
|
|
var/target_state = ACCESS_STATE_LOCKED
|
|
|
|
receive_signal(datum/signal/signal, receive_method, receive_param)
|
|
var/receive_tag = signal.data["tag"]
|
|
if(!receive_tag) return
|
|
|
|
if(receive_tag==exterior_door_tag)
|
|
if(signal.data["door_status"] == "closed")
|
|
if(signal.data["lock_status"] == "locked")
|
|
memory["exterior_status"] = "locked"
|
|
else
|
|
memory["exterior_status"] = "closed"
|
|
else
|
|
memory["exterior_status"] = "open"
|
|
|
|
else if(receive_tag==interior_door_tag)
|
|
if(signal.data["door_status"] == "closed")
|
|
if(signal.data["lock_status"] == "locked")
|
|
memory["interior_status"] = "locked"
|
|
else
|
|
memory["interior_status"] = "closed"
|
|
else
|
|
memory["interior_status"] = "open"
|
|
|
|
else if(receive_tag==id_tag)
|
|
switch(signal.data["command"])
|
|
if("cycle_interior")
|
|
target_state = ACCESS_STATE_INTERNAL
|
|
if("cycle_exterior")
|
|
target_state = ACCESS_STATE_EXTERNAL
|
|
if("cycle")
|
|
if(state < ACCESS_STATE_LOCKED)
|
|
target_state = ACCESS_STATE_EXTERNAL
|
|
else
|
|
target_state = ACCESS_STATE_INTERNAL
|
|
|
|
receive_user_command(command)
|
|
switch(command)
|
|
if("cycle_closed")
|
|
target_state = ACCESS_STATE_LOCKED
|
|
if("cycle_exterior")
|
|
target_state = ACCESS_STATE_EXTERNAL
|
|
if("cycle_interior")
|
|
target_state = ACCESS_STATE_INTERNAL
|
|
|
|
process()
|
|
switch(state)
|
|
if(ACCESS_STATE_INTERNAL) // state -1
|
|
if(target_state > state)
|
|
if(memory["interior_status"] == "locked")
|
|
state = ACCESS_STATE_LOCKED
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
if(memory["interior_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
|
|
if(ACCESS_STATE_LOCKED)
|
|
if(target_state < state)
|
|
if(memory["exterior_status"] != "locked")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
if(memory["exterior_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
else
|
|
if(memory["interior_status"] == "closed" || memory["interior_status"] == "open")
|
|
state = ACCESS_STATE_INTERNAL
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
signal.data["command"] = "unlock"
|
|
post_signal(signal)
|
|
else if(target_state > state)
|
|
if(memory["interior_status"] != "locked")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
if(memory["interior_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
else
|
|
if(memory["exterior_status"] == "closed" || memory["exterior_status"] == "open")
|
|
state = ACCESS_STATE_EXTERNAL
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
signal.data["command"] = "unlock"
|
|
post_signal(signal)
|
|
else
|
|
if(memory["interior_status"] != "locked")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
if(memory["interior_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
else if(memory["exterior_status"] != "locked")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
if(memory["exterior_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
|
|
if(ACCESS_STATE_EXTERNAL) //state 1
|
|
if(target_state < state)
|
|
if(memory["exterior_status"] == "locked")
|
|
state = ACCESS_STATE_LOCKED
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
if(memory["exterior_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
|
|
|
|
return 1
|
|
|
|
|
|
datum/computer/file/embedded_program/airlock_controller
|
|
var/id_tag
|
|
var/exterior_door_tag
|
|
var/interior_door_tag
|
|
var/airpump_tag
|
|
var/sensor_tag
|
|
var/sanitize_external
|
|
|
|
state = AIRLOCK_STATE_CLOSED
|
|
var/target_state = AIRLOCK_STATE_CLOSED
|
|
var/sensor_pressure = null
|
|
|
|
receive_signal(datum/signal/signal, receive_method, receive_param)
|
|
var/receive_tag = signal.data["tag"]
|
|
if(!receive_tag) return
|
|
|
|
if(receive_tag==sensor_tag)
|
|
if(signal.data["pressure"])
|
|
sensor_pressure = text2num(signal.data["pressure"])
|
|
|
|
else if(receive_tag==exterior_door_tag)
|
|
memory["exterior_status"] = signal.data["door_status"]
|
|
|
|
else if(receive_tag==interior_door_tag)
|
|
memory["interior_status"] = signal.data["door_status"]
|
|
|
|
else if(receive_tag==airpump_tag)
|
|
if(signal.data["power"]=="on")
|
|
memory["pump_status"] = signal.data["direction"]
|
|
else
|
|
memory["pump_status"] = "off"
|
|
|
|
else if(receive_tag==id_tag)
|
|
switch(signal.data["command"])
|
|
if("cycle")
|
|
if(state < AIRLOCK_STATE_CLOSED)
|
|
target_state = AIRLOCK_STATE_OUTOPEN
|
|
else
|
|
target_state = AIRLOCK_STATE_INOPEN
|
|
|
|
receive_user_command(command)
|
|
switch(command)
|
|
if("cycle_closed")
|
|
target_state = AIRLOCK_STATE_CLOSED
|
|
if("cycle_exterior")
|
|
target_state = AIRLOCK_STATE_OUTOPEN
|
|
if("cycle_interior")
|
|
target_state = AIRLOCK_STATE_INOPEN
|
|
if("abort")
|
|
target_state = AIRLOCK_STATE_CLOSED
|
|
|
|
process()
|
|
switch(state)
|
|
if(AIRLOCK_STATE_INOPEN) // state -2
|
|
if(target_state > state)
|
|
if(memory["interior_status"] == "closed")
|
|
state = AIRLOCK_STATE_CLOSED
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
else
|
|
if(memory["pump_status"] != "off")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = airpump_tag
|
|
signal.data["command"] = "power_off"
|
|
post_signal(signal)
|
|
|
|
if(AIRLOCK_STATE_PRESSURIZE)
|
|
if(target_state < state)
|
|
if(sensor_pressure >= ONE_ATMOSPHERE*0.95)
|
|
if(memory["interior_status"] == "open")
|
|
state = AIRLOCK_STATE_INOPEN
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
signal.data["command"] = "secure_open"
|
|
post_signal(signal)
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = airpump_tag
|
|
if(memory["pump_status"] == "siphon")
|
|
signal.data["command"] = "stabalize"
|
|
else if(memory["pump_status"] != "release")
|
|
signal.data["command"] = "power_on"
|
|
post_signal(signal)
|
|
else if(target_state > state)
|
|
state = AIRLOCK_STATE_CLOSED
|
|
|
|
if(AIRLOCK_STATE_CLOSED)
|
|
if(target_state > state)
|
|
if(memory["interior_status"] == "closed")
|
|
state = AIRLOCK_STATE_DEPRESSURIZE
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = interior_door_tag
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
else if(target_state < state)
|
|
if(memory["exterior_status"] == "closed")
|
|
state = AIRLOCK_STATE_PRESSURIZE
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
|
|
else
|
|
if(memory["pump_status"] != "off")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = airpump_tag
|
|
signal.data["command"] = "power_off"
|
|
post_signal(signal)
|
|
|
|
if(AIRLOCK_STATE_DEPRESSURIZE)
|
|
var/target_pressure = ONE_ATMOSPHERE*0.05
|
|
if(sanitize_external)
|
|
target_pressure = ONE_ATMOSPHERE*0.01
|
|
|
|
if(sensor_pressure <= target_pressure)
|
|
if(target_state > state)
|
|
if(memory["exterior_status"] == "open")
|
|
state = AIRLOCK_STATE_OUTOPEN
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
signal.data["command"] = "secure_open"
|
|
post_signal(signal)
|
|
else if(target_state < state)
|
|
state = AIRLOCK_STATE_CLOSED
|
|
else if((target_state < state) && !sanitize_external)
|
|
state = AIRLOCK_STATE_CLOSED
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.transmission_method = 1 //radio signal
|
|
signal.data["tag"] = airpump_tag
|
|
if(memory["pump_status"] == "release")
|
|
signal.data["command"] = "purge"
|
|
else if(memory["pump_status"] != "siphon")
|
|
signal.data["command"] = "power_on"
|
|
post_signal(signal)
|
|
|
|
if(AIRLOCK_STATE_OUTOPEN) //state 2
|
|
if(target_state < state)
|
|
if(memory["exterior_status"] == "closed")
|
|
if(sanitize_external)
|
|
state = AIRLOCK_STATE_DEPRESSURIZE
|
|
else
|
|
state = AIRLOCK_STATE_CLOSED
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = exterior_door_tag
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
else
|
|
if(memory["pump_status"] != "off")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = airpump_tag
|
|
signal.data["command"] = "power_off"
|
|
post_signal(signal)
|
|
|
|
memory["sensor_pressure"] = sensor_pressure
|
|
memory["processing"] = state != target_state
|
|
sensor_pressure = null
|
|
|
|
return 1
|
|
|
|
|
|
datum/computer/file/embedded_program/department_controller
|
|
var/id_tag
|
|
var/door_tag
|
|
|
|
state = ACCESS_STATE_LOCKED
|
|
var/target_state = ACCESS_STATE_EXTERNAL
|
|
|
|
receive_signal(datum/signal/signal, receive_method, receive_param)
|
|
var/receive_tag = signal.data["tag"]
|
|
if(!receive_tag) return
|
|
|
|
if(receive_tag==door_tag)
|
|
if(signal.data["door_status"] == "closed")
|
|
if(signal.data["lock_status"] == "locked")
|
|
memory["door_status"] = "locked"
|
|
else
|
|
memory["door_status"] = "closed"
|
|
else
|
|
memory["door_status"] = "open"
|
|
|
|
receive_user_command(command)
|
|
switch(command)
|
|
if("lock")
|
|
target_state = ACCESS_STATE_LOCKED
|
|
if("unlock")
|
|
target_state = ACCESS_STATE_EXTERNAL
|
|
|
|
process()
|
|
switch(state)
|
|
if(ACCESS_STATE_LOCKED)
|
|
if(target_state > state)
|
|
if(memory["door_status"] == "closed" || memory["door_status"] == "open")
|
|
state = ACCESS_STATE_EXTERNAL
|
|
return 1
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = door_tag
|
|
signal.data["command"] = "secure_open"
|
|
post_signal(signal)
|
|
else
|
|
if(memory["door_status"] != "locked")
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = door_tag
|
|
if(memory["door_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
|
|
|
|
if(ACCESS_STATE_EXTERNAL) //state 1
|
|
if(target_state < state)
|
|
if(memory["door_status"] == "locked")
|
|
state = ACCESS_STATE_LOCKED
|
|
return 1
|
|
else
|
|
var/datum/signal/signal = get_free_signal()
|
|
signal.data["tag"] = door_tag
|
|
if(memory["door_status"] == "closed")
|
|
signal.data["command"] = "lock"
|
|
else
|
|
signal.data["command"] = "secure_close"
|
|
post_signal(signal)
|
|
|
|
|
|
return 0
|
|
|
|
|
|
|
|
obj/machinery/embedded_controller
|
|
var/datum/computer/file/embedded_program/program
|
|
|
|
name = "Embedded Controller"
|
|
density = 0
|
|
anchored = 1
|
|
|
|
var/on = 1
|
|
|
|
attack_hand(mob/user)
|
|
user << browse(return_text(), "window=computer")
|
|
user.machine = src
|
|
onclose(user, "computer")
|
|
|
|
disposing()
|
|
if (program)
|
|
program.master = null
|
|
program.memory = null
|
|
program.dispose()
|
|
program = null
|
|
|
|
..()
|
|
|
|
proc/update_icon()
|
|
proc/return_text()
|
|
|
|
proc/post_signal(datum/signal/signal, comm_line)
|
|
return 0
|
|
|
|
receive_signal(datum/signal/signal, receive_method, receive_param)
|
|
if(!signal || signal.encryption) return
|
|
|
|
if(program)
|
|
return program.receive_signal(signal, receive_method, receive_param)
|
|
|
|
Topic(href, href_list)
|
|
if(..())
|
|
return 0
|
|
|
|
if(program)
|
|
program.receive_user_command(href_list["command"])
|
|
|
|
usr.machine = src
|
|
|
|
process()
|
|
if(program)
|
|
program.process()
|
|
|
|
update_icon()
|
|
src.updateDialog()
|
|
..()
|
|
|
|
radio
|
|
var/frequency
|
|
var/datum/radio_frequency/radio_connection
|
|
|
|
initialize()
|
|
set_frequency(frequency)
|
|
|
|
post_signal(datum/signal/signal)
|
|
signal.transmission_method = TRANSMISSION_RADIO
|
|
if(radio_connection)
|
|
return radio_connection.post_signal(src, signal)
|
|
//else
|
|
//qdel(signal)
|
|
|
|
proc
|
|
set_frequency(new_frequency)
|
|
radio_controller.remove_object(src, "[frequency]")
|
|
frequency = new_frequency
|
|
radio_connection = radio_controller.add_object(src, "[frequency]")
|
|
|
|
|
|
obj/machinery/embedded_controller/radio/access_controller
|
|
icon = 'icons/obj/airlock_machines.dmi'
|
|
icon_state = "access_control_standby"
|
|
|
|
name = "Access Console"
|
|
density = 0
|
|
|
|
frequency = 1449
|
|
|
|
// Setup parameters only
|
|
var/id_tag
|
|
var/exterior_door_tag
|
|
var/interior_door_tag
|
|
|
|
initialize()
|
|
..()
|
|
|
|
var/datum/computer/file/embedded_program/access_controller/new_prog = new
|
|
|
|
new_prog.id_tag = id_tag
|
|
new_prog.exterior_door_tag = exterior_door_tag
|
|
new_prog.interior_door_tag = interior_door_tag
|
|
|
|
new_prog.master = src
|
|
program = new_prog
|
|
|
|
update_icon()
|
|
if(on && program)
|
|
if(program.memory["processing"])
|
|
icon_state = "access_control_process"
|
|
else
|
|
icon_state = "access_control_standby"
|
|
else
|
|
icon_state = "access_control_off"
|
|
|
|
|
|
return_text()
|
|
var/state_options = null
|
|
|
|
var/state = 0
|
|
var/exterior_status = "----"
|
|
var/interior_status = "----"
|
|
if(program)
|
|
state = program.state
|
|
exterior_status = program.memory["exterior_status"]
|
|
interior_status = program.memory["interior_status"]
|
|
|
|
switch(state)
|
|
if(ACCESS_STATE_INTERNAL)
|
|
state_options = {"<A href='?src=\ref[src];command=cycle_closed'>Lock Interior Airlock</A><BR>
|
|
<A href='?src=\ref[src];command=cycle_exterior'>Cycle to Exterior Airlock</A><BR>"}
|
|
if(ACCESS_STATE_LOCKED)
|
|
state_options = {"<A href='?src=\ref[src];command=cycle_interior'>Unlock Interior Airlock</A><BR>
|
|
<A href='?src=\ref[src];command=cycle_exterior'>Unlock Exterior Airlock</A><BR>"}
|
|
if(ACCESS_STATE_EXTERNAL)
|
|
state_options = {"<A href='?src=\ref[src];command=cycle_interior'>Cycle to Interior Airlock</A><BR>
|
|
<A href='?src=\ref[src];command=cycle_closed'>Lock Exterior Airlock</A><BR>"}
|
|
|
|
var/output = {"<B>Access Control Console</B><HR>
|
|
[state_options]<HR>
|
|
<B>Exterior Door: </B> [exterior_status]<BR>
|
|
<B>Interior Door: </B> [interior_status]<BR>"}
|
|
|
|
return output
|
|
|
|
|
|
obj/machinery/embedded_controller/radio/airlock_controller
|
|
icon = 'icons/obj/airlock_machines.dmi'
|
|
icon_state = "airlock_control_standby"
|
|
|
|
name = "Airlock Console"
|
|
density = 0
|
|
|
|
frequency = 1449
|
|
|
|
// Setup parameters only
|
|
var/id_tag
|
|
var/exterior_door_tag
|
|
var/interior_door_tag
|
|
var/airpump_tag
|
|
var/sensor_tag
|
|
var/sanitize_external
|
|
|
|
initialize()
|
|
..()
|
|
|
|
var/datum/computer/file/embedded_program/airlock_controller/new_prog = new
|
|
|
|
new_prog.id_tag = id_tag
|
|
new_prog.exterior_door_tag = exterior_door_tag
|
|
new_prog.interior_door_tag = interior_door_tag
|
|
new_prog.airpump_tag = airpump_tag
|
|
new_prog.sensor_tag = sensor_tag
|
|
new_prog.sanitize_external = sanitize_external
|
|
|
|
new_prog.master = src
|
|
program = new_prog
|
|
|
|
update_icon()
|
|
if(on && program)
|
|
if(program.memory["processing"])
|
|
icon_state = "airlock_control_process"
|
|
else
|
|
icon_state = "airlock_control_standby"
|
|
else
|
|
icon_state = "airlock_control_off"
|
|
|
|
|
|
return_text()
|
|
var/state_options = null
|
|
|
|
var/state = 0
|
|
var/sensor_pressure = "----"
|
|
var/exterior_status = "----"
|
|
var/interior_status = "----"
|
|
var/pump_status = "----"
|
|
if(program)
|
|
state = program.state
|
|
sensor_pressure = program.memory["sensor_pressure"]
|
|
exterior_status = program.memory["exterior_status"]
|
|
interior_status = program.memory["interior_status"]
|
|
pump_status = program.memory["pump_status"]
|
|
|
|
switch(state)
|
|
if(AIRLOCK_STATE_INOPEN)
|
|
state_options = {"<A href='?src=\ref[src];command=cycle_closed'>Close Interior Airlock</A><BR>
|
|
<A href='?src=\ref[src];command=cycle_exterior'>Cycle to Exterior Airlock</A><BR>"}
|
|
if(AIRLOCK_STATE_PRESSURIZE)
|
|
state_options = "<A href='?src=\ref[src];command=abort'>Abort Cycling</A><BR>"
|
|
if(AIRLOCK_STATE_CLOSED)
|
|
state_options = {"<A href='?src=\ref[src];command=cycle_interior'>Open Interior Airlock</A><BR>
|
|
<A href='?src=\ref[src];command=cycle_exterior'>Open Exterior Airlock</A><BR>"}
|
|
if(AIRLOCK_STATE_DEPRESSURIZE)
|
|
state_options = "<A href='?src=\ref[src];command=abort'>Abort Cycling</A><BR>"
|
|
if(AIRLOCK_STATE_OUTOPEN)
|
|
state_options = {"<A href='?src=\ref[src];command=cycle_interior'>Cycle to Interior Airlock</A><BR>
|
|
<A href='?src=\ref[src];command=cycle_closed'>Close Exterior Airlock</A><BR>"}
|
|
|
|
var/output = {"<B>Airlock Control Console</B><HR>
|
|
[state_options]<HR>
|
|
<B>Chamber Pressure:</B> [sensor_pressure] kPa<BR>
|
|
<B>Exterior Door: </B> [exterior_status]<BR>
|
|
<B>Interior Door: </B> [interior_status]<BR>
|
|
<B>Control Pump: </B> [pump_status]<BR>"}
|
|
|
|
return output
|
|
|
|
|
|
obj/machinery/embedded_controller/radio/department_controller
|
|
icon = 'icons/obj/airlock_machines.dmi'
|
|
icon_state = "access_control_standby"
|
|
|
|
name = "Access Console"
|
|
density = 0
|
|
|
|
frequency = 1449
|
|
|
|
// Setup parameters only
|
|
var/id_tag
|
|
var/door_tag
|
|
var/locked = 1
|
|
|
|
initialize()
|
|
..()
|
|
|
|
var/datum/computer/file/embedded_program/department_controller/new_prog = new
|
|
|
|
new_prog.id_tag = id_tag
|
|
new_prog.door_tag = door_tag
|
|
|
|
new_prog.master = src
|
|
program = new_prog
|
|
|
|
update_icon()
|
|
if(!(stat & NOPOWER) && program)
|
|
if(program.memory["processing"])
|
|
icon_state = "access_control_process"
|
|
else
|
|
icon_state = "access_control_standby"
|
|
else
|
|
icon_state = "access_control_off"
|
|
|
|
Topic(href, href_list)
|
|
if (src.locked && !issilicon(usr))
|
|
return
|
|
|
|
if(program)
|
|
program.receive_user_command(href_list["command"])
|
|
|
|
usr.machine = src
|
|
|
|
process()
|
|
if(stat & NOPOWER)
|
|
return
|
|
if(program)
|
|
var/update = program.process()
|
|
if (update)
|
|
src.updateDialog()
|
|
|
|
update_icon()
|
|
|
|
attackby(var/obj/item/I as obj, mob/user as mob)
|
|
if (istype(I, /obj/item/device/pda2) && I:ID_card)
|
|
I = I:ID_card
|
|
if(istype(I, /obj/item/card/id))
|
|
if (src.allowed(user, req_only_one_required))
|
|
user.visible_message("[user] [src.locked ? "unlocks" : "locks"] the access panel.","You [src.locked ? "unlock" : "lock"] the access panel.")
|
|
src.locked = !src.locked
|
|
else
|
|
boutput(user, "<span style=\"color:red\">Access denied.</span>")
|
|
else
|
|
..()
|
|
|
|
return
|
|
|
|
attack_ai(mob/user)
|
|
return attack_hand(user)
|
|
|
|
attack_hand(mob/user)
|
|
if (src.stat & NOPOWER)
|
|
return
|
|
|
|
user.machine = src
|
|
|
|
var/state_options = null
|
|
|
|
var/state = 0
|
|
var/door_status = "----"
|
|
if(program)
|
|
state = program.state
|
|
door_status = program.memory["door_status"]
|
|
|
|
switch(state)
|
|
if(ACCESS_STATE_LOCKED)
|
|
state_options = "<A href='?src=\ref[src];command=unlock'>Unseal Airlocks</A>"
|
|
if(ACCESS_STATE_EXTERNAL)
|
|
state_options = "<A href='?src=\ref[src];command=lock'>Seal Airlocks</A>"
|
|
|
|
var/output = "<B>Department Airlock Control Console</B><HR>"
|
|
if (src.locked && !issilicon(user))
|
|
output += "<center><b>Console Locked</b><br><i>Please swipe ID</i></center>"
|
|
else
|
|
output += "[state_options]<hr><b>Airlock Status: </b> [door_status]"
|
|
|
|
user << browse(output, "window=dcontroller;size=245x302")
|
|
onclose(user, "dcontroller")
|
|
|