cyberpresidentvanellope/Paradise
1
0
Fork 0
mirror of https://github.com/ParadiseSS13/Paradise.git synced 2026-08-29 06:57:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Generalizes embedded program

Browse Source 
Conflicts:
	code/game/machinery/embedded_controller/embedded_controller_base.dm
This commit is contained in:
mwerezak
2014-06-14 03:51:17 -04:00
committed by ZomgPonies
parent ca65e48cdf
commit 64edd31d67
14 changed files with 856 additions and 1220 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/game/machinery/embedded_controller/access_controller.dm
-214
View File
@@ -1,214 +0,0 @@
//States for airlock_control
#define ACCESS_STATE_INTERNAL -1
#define ACCESS_STATE_LOCKED 0
#define ACCESS_STATE_EXTERNAL 1
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()
var/process_again = 1
while(process_again)
process_again = 0
switch(state)
if(ACCESS_STATE_INTERNAL) // state -1
if(target_state > state)
if(memory["interior_status"] == "locked")
state = ACCESS_STATE_LOCKED
process_again = 1
else
var/datum/signal/signal = new
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 = new
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
process_again = 1
else
var/datum/signal/signal = new
signal.data["tag"] = interior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
else if(target_state > state)
if(memory["interior_status"] != "locked")
var/datum/signal/signal = new
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
process_again = 1
else
var/datum/signal/signal = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
else
if(memory["interior_status"] != "locked")
var/datum/signal/signal = new
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 = new
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
process_again = 1
else
var/datum/signal/signal = new
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
obj/machinery/embedded_controller/radio/access_controller
icon = 'icons/obj/airlock_machines.dmi'
icon_state = "access_control_standby"
name = "Access Console"
density = 0
power_channel = ENVIRON
unacidable = 1
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
code/game/machinery/embedded_controller/airlock_controller.dm
-352
View File
@@ -1,352 +0,0 @@
//States for airlock_control
#define AIRLOCK_STATE_INOPEN -2
#define AIRLOCK_STATE_PRESSURIZE -1
#define AIRLOCK_STATE_CLOSED 0
#define AIRLOCK_STATE_DEPRESSURIZE 1
#define AIRLOCK_STATE_OUTOPEN 2
#define AIRLOCK_STATE_BOTHOPEN 3
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/sensor_tag_int
var/sanitize_external
state = AIRLOCK_STATE_CLOSED
var/target_state = AIRLOCK_STATE_CLOSED
var/sensor_pressure = null
var/int_sensor_pressure = ONE_ATMOSPHERE
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==sensor_tag_int)
if(signal.data["pressure"])
int_sensor_pressure = text2num(signal.data["pressure"])
else if(receive_tag==exterior_door_tag)
memory["exterior_status"] = signal.data["door_status"]
if(signal.data["bumped_with_access"])
target_state = AIRLOCK_STATE_OUTOPEN
else if(receive_tag==interior_door_tag)
memory["interior_status"] = signal.data["door_status"]
if(signal.data["bumped_with_access"])
target_state = AIRLOCK_STATE_INOPEN
else if(receive_tag==airpump_tag)
if(signal.data["power"])
memory["pump_status"] = signal.data["direction"]
else
memory["pump_status"] = "off"
else if(receive_tag==id_tag)
switch(signal.data["command"])
if("cycle_exterior")
target_state = AIRLOCK_STATE_OUTOPEN
if("cycle_interior")
target_state = AIRLOCK_STATE_INOPEN
if("cycle")
if(state < AIRLOCK_STATE_CLOSED)
target_state = AIRLOCK_STATE_OUTOPEN
else
target_state = AIRLOCK_STATE_INOPEN
if("cycle_interior")
target_state = AIRLOCK_STATE_INOPEN
if("cycle_exterior")
target_state = AIRLOCK_STATE_OUTOPEN
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
if("force_both")
target_state = AIRLOCK_STATE_BOTHOPEN
state = AIRLOCK_STATE_BOTHOPEN
var/datum/signal/signal = new
signal.data["tag"] = interior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
signal = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
if("force_exterior")
target_state = AIRLOCK_STATE_OUTOPEN
state = AIRLOCK_STATE_OUTOPEN
var/datum/signal/signal = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
if("force_interior")
target_state = AIRLOCK_STATE_INOPEN
state = AIRLOCK_STATE_INOPEN
var/datum/signal/signal = new
signal.data["tag"] = interior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
if("close")
target_state = AIRLOCK_STATE_CLOSED
state = AIRLOCK_STATE_CLOSED
var/datum/signal/signal = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_close"
post_signal(signal)
signal = new
signal.data["tag"] = interior_door_tag
signal.data["command"] = "secure_close"
post_signal(signal)
process()
var/process_again = 1
while(process_again)
process_again = 0
switch(state)
if(AIRLOCK_STATE_INOPEN) // state -2
if(target_state > state)
if(memory["interior_status"] == "closed")
state = AIRLOCK_STATE_CLOSED
process_again = 1
else
var/datum/signal/signal = new
signal.data["tag"] = interior_door_tag
signal.data["command"] = "secure_close"
post_signal(signal)
else
if(memory["pump_status"] != "off")
var/datum/signal/signal = new
signal.data = list(
"tag" = airpump_tag,
"power" = 0,
"sigtype"="command"
)
post_signal(signal)
if(AIRLOCK_STATE_PRESSURIZE)
if(target_state < state)
if(sensor_pressure >= int_sensor_pressure*0.95)
if(memory["interior_status"] == "open")
state = AIRLOCK_STATE_INOPEN
process_again = 1
else
var/datum/signal/signal = new
signal.data["tag"] = interior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
else
var/datum/signal/signal = new
signal.data = list(
"tag" = airpump_tag,
"sigtype"="command"
)
if(memory["pump_status"] == "siphon")
signal.data["stabalize"] = 1
else if(memory["pump_status"] != "release")
signal.data["power"] = 1
post_signal(signal)
else if(target_state > state)
state = AIRLOCK_STATE_CLOSED
process_again = 1
if(AIRLOCK_STATE_CLOSED)
if(target_state > state)
if(memory["interior_status"] == "closed")
state = AIRLOCK_STATE_DEPRESSURIZE
process_again = 1
else
var/datum/signal/signal = new
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
process_again = 1
else
var/datum/signal/signal = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_close"
post_signal(signal)
else
if(memory["pump_status"] != "off")
var/datum/signal/signal = new
signal.data = list(
"tag" = airpump_tag,
"power" = 0,
"sigtype"="command"
)
post_signal(signal)
if(AIRLOCK_STATE_DEPRESSURIZE)
var/target_pressure = ONE_ATMOSPHERE*0.04
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 = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_open"
post_signal(signal)
else if(target_state < state)
state = AIRLOCK_STATE_CLOSED
process_again = 1
else if((target_state < state) && !sanitize_external)
state = AIRLOCK_STATE_CLOSED
process_again = 1
else
var/datum/signal/signal = new
signal.transmission_method = 1 //radio signal
signal.data = list(
"tag" = airpump_tag,
"sigtype"="command"
)
if(memory["pump_status"] == "release")
signal.data["purge"] = 1
else if(memory["pump_status"] != "siphon")
signal.data["power"] = 1
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
process_again = 1
else
state = AIRLOCK_STATE_CLOSED
process_again = 1
else
var/datum/signal/signal = new
signal.data["tag"] = exterior_door_tag
signal.data["command"] = "secure_close"
post_signal(signal)
else
if(memory["pump_status"] != "off")
var/datum/signal/signal = new
signal.data = list(
"tag" = airpump_tag,
"power" = 0,
"sigtype"="command"
)
post_signal(signal)
memory["sensor_pressure"] = sensor_pressure
memory["int_sensor_pressure"] = int_sensor_pressure
memory["processing"] = state != target_state
//sensor_pressure = null //not sure if we can comment this out. Uncomment in case of problems -rastaf0
return 1
obj/machinery/embedded_controller/radio/airlock_controller
icon = 'icons/obj/airlock_machines.dmi'
icon_state = "airlock_control_standby"
name = "Airlock Console"
density = 0
unacidable = 1
frequency = 1449
power_channel = ENVIRON
// Setup parameters only
var/id_tag
var/exterior_door_tag
var/interior_door_tag
var/airpump_tag
var/sensor_tag
var/sensor_tag_int
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.sensor_tag_int = sensor_tag_int
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/int_sensor_pressure = "----"
var/exterior_status = "----"
var/interior_status = "----"
var/pump_status = "----"
if(program)
state = program.state
sensor_pressure = program.memory["sensor_pressure"]
int_sensor_pressure = program.memory["int_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>"}
if(AIRLOCK_STATE_BOTHOPEN)
state_options = "<A href='?src=\ref[src];command=close'>Close Airlocks</A><BR>"
var/output = {"<B>Airlock Control Console</B><HR>
[state_options]<HR>
<B>Chamber Pressure:</B> [sensor_pressure] kPa<BR>
<B>Internal Pressure:</B> [int_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>"}
if(program && program.state == AIRLOCK_STATE_CLOSED)
output += {"<A href='?src=\ref[src];command=force_both'>Force Both Airlocks</A><br>
<A href='?src=\ref[src];command=force_interior'>Force Inner Airlock</A><br>
<A href='?src=\ref[src];command=force_exterior'>Force Outer Airlock</A>"}
return output
code/game/machinery/embedded_controller/airlock_controllers.dm
+186
View File
@@ -0,0 +1,186 @@
//base type for controllers of two-door systems
/obj/machinery/embedded_controller/radio/airlock
// Setup parameters only
var/tag_exterior_door
var/tag_interior_door
var/tag_airpump
var/tag_chamber_sensor
var/tag_exterior_sensor
var/tag_interior_sensor
var/tag_secure = 0
/obj/machinery/embedded_controller/radio/airlock/initialize()
..()
program = new/datum/computer/file/embedded_program/airlock(src)
//Advanced airlock controller for when you want a more versatile airlock controller - useful for turning simple access control rooms into airlocks
/obj/machinery/embedded_controller/radio/airlock/advanced_airlock_controller
name = "Advanced Airlock Controller"
/obj/machinery/embedded_controller/radio/airlock/advanced_airlock_controller/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null)
var/data[0]
data = list(
"chamber_pressure" = round(program.memory["chamber_sensor_pressure"]),
"external_pressure" = round(program.memory["external_sensor_pressure"]),
"internal_pressure" = round(program.memory["internal_sensor_pressure"]),
"processing" = program.memory["processing"],
"purge" = program.memory["purge"],
"secure" = program.memory["secure"]
)
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data)
if (!ui)
ui = new(user, src, ui_key, "advanced_airlock_console.tmpl", name, 470, 290)
ui.set_initial_data(data)
ui.open()
ui.set_auto_update(1)
/obj/machinery/embedded_controller/radio/airlock/advanced_airlock_controller/Topic(href, href_list)
if(..())
return
usr.set_machine(src)
src.add_fingerprint(usr)
var/clean = 0
switch(href_list["command"]) //anti-HTML-hacking checks
if("cycle_ext")
clean = 1
if("cycle_int")
clean = 1
if("force_ext")
clean = 1
if("force_int")
clean = 1
if("abort")
clean = 1
if("purge")
clean = 1
if("secure")
clean = 1
if(clean)
program.receive_user_command(href_list["command"])
return 1
//Airlock controller for airlock control - most airlocks on the station use this
/obj/machinery/embedded_controller/radio/airlock/airlock_controller
name = "Airlock Controller"
tag_secure = 1
/obj/machinery/embedded_controller/radio/airlock/airlock_controller/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null)
var/data[0]
data = list(
"chamber_pressure" = round(program.memory["chamber_sensor_pressure"]),
"exterior_status" = program.memory["exterior_status"],
"interior_status" = program.memory["interior_status"],
"processing" = program.memory["processing"],
)
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data)
if (!ui)
ui = new(user, src, ui_key, "simple_airlock_console.tmpl", name, 470, 290)
ui.set_initial_data(data)
ui.open()
ui.set_auto_update(1)
/obj/machinery/embedded_controller/radio/airlock/airlock_controller/Topic(href, href_list)
if(..())
return
usr.set_machine(src)
src.add_fingerprint(usr)
var/clean = 0
switch(href_list["command"]) //anti-HTML-hacking checks
if("cycle_ext")
clean = 1
if("cycle_int")
clean = 1
if("force_ext")
clean = 1
if("force_int")
clean = 1
if("abort")
clean = 1
if(clean)
program.receive_user_command(href_list["command"])
return 1
//Access controller for door control - used in virology and the like
/obj/machinery/embedded_controller/radio/airlock/access_controller
icon = 'icons/obj/airlock_machines.dmi'
icon_state = "access_control_standby"
name = "Access Controller"
tag_secure = 1
/obj/machinery/embedded_controller/radio/airlock/access_controller/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"
/obj/machinery/embedded_controller/radio/airlock/access_controller/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null)
var/data[0]
data = list(
"exterior_status" = program.memory["exterior_status"],
"interior_status" = program.memory["interior_status"],
"processing" = program.memory["processing"]
)
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data)
if (!ui)
ui = new(user, src, ui_key, "door_access_console.tmpl", name, 330, 220)
ui.set_initial_data(data)
ui.open()
ui.set_auto_update(1)
/obj/machinery/embedded_controller/radio/airlock/access_controller/Topic(href, href_list)
if(..())
return
usr.set_machine(src)
src.add_fingerprint(usr)
var/clean = 0
switch(href_list["command"]) //anti-HTML-hacking checks
if("cycle_ext_door")
clean = 1
if("cycle_int_door")
clean = 1
if("force_ext")
if(program.memory["interior_status"]["state"] == "closed")
clean = 1
if("force_int")
if(program.memory["exterior_status"]["state"] == "closed")
clean = 1
if(clean)
program.receive_user_command(href_list["command"])
return 1
code/game/machinery/embedded_controller/airlock_docking_controller.dm
+174
View File
@@ -0,0 +1,174 @@
//a docking port based on an airlock
/obj/machinery/embedded_controller/radio/airlock/docking_port
name = "docking port controller"
var/datum/computer/file/embedded_program/airlock/docking/airlock_program
var/datum/computer/file/embedded_program/docking/airlock/docking_program
tag_secure = 1
/obj/machinery/embedded_controller/radio/airlock/docking_port/initialize()
..()
airlock_program = new/datum/computer/file/embedded_program/airlock/docking(src)
docking_program = new/datum/computer/file/embedded_program/docking/airlock(src, airlock_program)
program = docking_program
/obj/machinery/embedded_controller/radio/airlock/docking_port/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null)
var/data[0]
data = list(
"chamber_pressure" = round(airlock_program.memory["chamber_sensor_pressure"]),
"exterior_status" = airlock_program.memory["exterior_status"],
"interior_status" = airlock_program.memory["interior_status"],
"processing" = airlock_program.memory["processing"],
"docking_status" = docking_program.get_docking_status(),
"airlock_disabled" = !(docking_program.undocked() || docking_program.override_enabled),
)
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data)
if (!ui)
ui = new(user, src, ui_key, "docking_airlock_console.tmpl", name, 470, 290)
ui.set_initial_data(data)
ui.open()
ui.set_auto_update(1)
/obj/machinery/embedded_controller/radio/airlock/docking_port/Topic(href, href_list)
if(..())
return
usr.set_machine(src)
src.add_fingerprint(usr)
var/clean = 0
switch(href_list["command"]) //anti-HTML-hacking checks
if("cycle_ext")
clean = 1
if("cycle_int")
clean = 1
if("force_ext")
clean = 1
if("force_int")
clean = 1
if("abort")
clean = 1
if("toggle_override")
clean = 1
if(clean)
program.receive_user_command(href_list["command"])
return 1
//A docking controller for an airlock based docking port
/datum/computer/file/embedded_program/docking/airlock
var/datum/computer/file/embedded_program/airlock/docking/airlock_program
/datum/computer/file/embedded_program/docking/airlock/New(var/obj/machinery/embedded_controller/M, var/datum/computer/file/embedded_program/airlock/docking/A)
..(M)
airlock_program = A
airlock_program.master_prog = src
/datum/computer/file/embedded_program/docking/airlock/receive_user_command(command)
if (command == "toggle_override")
if (override_enabled)
disable_override()
else
enable_override()
return
..(command)
airlock_program.receive_user_command(command) //pass along to subprograms
/datum/computer/file/embedded_program/docking/airlock/process()
airlock_program.process()
..()
/datum/computer/file/embedded_program/docking/airlock/receive_signal(datum/signal/signal, receive_method, receive_param)
airlock_program.receive_signal(signal, receive_method, receive_param) //pass along to subprograms
..(signal, receive_method, receive_param)
//tell the docking port to start getting ready for docking - e.g. pressurize
/datum/computer/file/embedded_program/docking/airlock/prepare_for_docking()
airlock_program.begin_cycle_in()
//are we ready for docking?
/datum/computer/file/embedded_program/docking/airlock/ready_for_docking()
return airlock_program.done_cycling()
//we are docked, open the doors or whatever.
/datum/computer/file/embedded_program/docking/airlock/finish_docking()
airlock_program.open_doors()
//tell the docking port to start getting ready for undocking - e.g. close those doors.
/datum/computer/file/embedded_program/docking/airlock/prepare_for_undocking()
airlock_program.stop_cycling()
airlock_program.close_doors()
//are we ready for undocking?
/datum/computer/file/embedded_program/docking/airlock/ready_for_undocking()
return airlock_program.check_doors_secured()
/datum/computer/file/embedded_program/docking/airlock/reset()
airlock_program.stop_cycling()
airlock_program.close_doors()
..()
//An airlock controller to be used by the airlock-based docking port controller.
//Same as a regular airlock controller but allows disabling of the regular airlock functions when docking
/datum/computer/file/embedded_program/airlock/docking
var/datum/computer/file/embedded_program/docking/airlock/master_prog
/datum/computer/file/embedded_program/airlock/docking/receive_user_command(command)
if (master_prog.undocked() || master_prog.override_enabled) //only allow the port to be used as an airlock if nothing is docked here or the override is enabled
..(command)
/datum/computer/file/embedded_program/airlock/docking/proc/open_doors()
toggleDoor(memory["interior_status"], tag_interior_door, memory["secure"], "open")
toggleDoor(memory["exterior_status"], tag_exterior_door, memory["secure"], "open")
/datum/computer/file/embedded_program/airlock/docking/cycleDoors(var/target)
if (master_prog.undocked() || master_prog.override_enabled) //only allow the port to be used as an airlock if nothing is docked here or the override is enabled
..(target)
/*** DEBUG VERBS ***
/datum/computer/file/embedded_program/docking/proc/print_state()
world << "id_tag: [id_tag]"
world << "dock_state: [dock_state]"
world << "control_mode: [control_mode]"
world << "tag_target: [tag_target]"
world << "response_sent: [response_sent]"
/datum/computer/file/embedded_program/docking/post_signal(datum/signal/signal, comm_line)
world << "Program [id_tag] sent a message!"
print_state()
world << "[id_tag] sent command \"[signal.data["command"]]\" to \"[signal.data["recipient"]]\""
..(signal)
/obj/machinery/embedded_controller/radio/airlock/docking_port/verb/view_state()
set category = "Debug"
set src in view(1)
src.program:print_state()
/obj/machinery/embedded_controller/radio/airlock/docking_port/verb/spoof_signal(var/command as text, var/sender as text)
set category = "Debug"
set src in view(1)
var/datum/signal/signal = new
signal.data["tag"] = sender
signal.data["command"] = command
signal.data["recipient"] = id_tag
src.program:receive_signal(signal)
/obj/machinery/embedded_controller/radio/airlock/docking_port/verb/debug_init_dock(var/target as text)
set category = "Debug"
set src in view(1)
src.program:initiate_docking(target)
/obj/machinery/embedded_controller/radio/airlock/docking_port/verb/debug_init_undock()
set category = "Debug"
set src in view(1)
src.program:initiate_undocking()
*/
code/game/machinery/embedded_controller/airlock_program.dm
+42 -35
View File
@@ -8,11 +8,8 @@
#define TARGET_INOPEN -1
#define TARGET_OUTOPEN -2
/datum/computer/file/embedded_program
var/list/memory = list()
var/obj/machinery/embedded_controller/master
var/id_tag
/datum/computer/file/embedded_program/airlock
var/tag_exterior_door
var/tag_interior_door
var/tag_airpump
@@ -23,9 +20,9 @@
var/state = STATE_WAIT
var/target_state = TARGET_NONE
/datum/computer/file/embedded_program/New()
..()
/datum/computer/file/embedded_program/airlock/New(var/obj/machinery/embedded_controller/M)
..(M)
memory["chamber_sensor_pressure"] = ONE_ATMOSPHERE
memory["external_sensor_pressure"] = 0 //assume vacuum for simple airlock controller
memory["internal_sensor_pressure"] = ONE_ATMOSPHERE
@@ -35,11 +32,22 @@
memory["target_pressure"] = ONE_ATMOSPHERE
memory["purge"] = 0
memory["secure"] = 0
if (istype(M, /obj/machinery/embedded_controller/radio/airlock)) //if our controller is an airlock controller than we can auto-init our tags
var/obj/machinery/embedded_controller/radio/airlock/controller = M
tag_exterior_door = controller.tag_exterior_door
tag_interior_door = controller.tag_interior_door
tag_airpump = controller.tag_airpump
tag_chamber_sensor = controller.tag_chamber_sensor
tag_exterior_sensor = controller.tag_exterior_sensor
tag_interior_sensor = controller.tag_interior_sensor
memory["secure"] = controller.tag_secure
spawn(10)
signalDoor(tag_exterior_door, "update") //signals connected doors to update their status
signalDoor(tag_interior_door, "update")
/datum/computer/file/embedded_program/proc/receive_signal(datum/signal/signal, receive_method, receive_param)
/datum/computer/file/embedded_program/airlock/receive_signal(datum/signal/signal, receive_method, receive_param)
var/receive_tag = signal.data["tag"]
if(!receive_tag) return
@@ -68,7 +76,7 @@
memory["pump_status"] = "off"
else if(receive_tag==id_tag)
if(istype(master, /obj/machinery/embedded_controller/radio/access_controller))
if(istype(master, /obj/machinery/embedded_controller/radio/airlock/access_controller))
switch(signal.data["command"])
if("cycle_exterior")
receive_user_command("cycle_ext_door")
@@ -92,7 +100,7 @@
receive_user_command("cycle_int")
/datum/computer/file/embedded_program/proc/receive_user_command(command)
/datum/computer/file/embedded_program/airlock/receive_user_command(command)
var/shutdown_pump = 0
switch(command)
if("cycle_ext")
@@ -142,7 +150,7 @@
signalPump(tag_airpump, 0) //send a signal to stop pressurizing
/datum/computer/file/embedded_program/proc/process()
/datum/computer/file/embedded_program/airlock/process()
if(!state)
if(target_state)
switch(target_state)
@@ -152,8 +160,7 @@
memory["target_pressure"] = memory["external_sensor_pressure"]
//lock down the airlock before activating pumps
toggleDoor(memory["exterior_status"], tag_exterior_door, 1, "close")
toggleDoor(memory["interior_status"], tag_interior_door, 1, "close")
close_doors()
var/chamber_pressure = memory["chamber_sensor_pressure"]
var/target_pressure = memory["target_pressure"]
@@ -178,7 +185,7 @@
signalPump(tag_airpump, 0)
//the airlock will not allow itself to continue to cycle when any of the doors are forced open.
if (state && !check_doors_closed())
if (state && !check_doors_secured())
stop_cycling()
switch(state)
@@ -215,40 +222,40 @@
return 1
//these are here so that subtypes don't have to make so many assuptions about our implementation
//these are here so that other types don't have to make so many assuptions about our implementation
/datum/computer/file/embedded_program/proc/begin_cycle_in()
/datum/computer/file/embedded_program/airlock/proc/begin_cycle_in()
state = STATE_WAIT
target_state = TARGET_INOPEN
/datum/computer/file/embedded_program/proc/begin_cycle_out()
/datum/computer/file/embedded_program/airlock/proc/begin_cycle_out()
state = STATE_WAIT
target_state = TARGET_OUTOPEN
/datum/computer/file/embedded_program/proc/stop_cycling()
/datum/computer/file/embedded_program/airlock/proc/close_doors()
toggleDoor(memory["interior_status"], tag_interior_door, 1, "close")
toggleDoor(memory["exterior_status"], tag_exterior_door, 1, "close")
/datum/computer/file/embedded_program/airlock/proc/stop_cycling()
state = STATE_WAIT
target_state = TARGET_NONE
/datum/computer/file/embedded_program/proc/done_cycling()
/datum/computer/file/embedded_program/airlock/proc/done_cycling()
return (state == STATE_WAIT && target_state == TARGET_NONE)
/datum/computer/file/embedded_program/proc/post_signal(datum/signal/signal, comm_line)
if(master)
master.post_signal(signal, comm_line)
else
del(signal)
//are the doors closed and locked?
/datum/computer/file/embedded_program/airlock/proc/check_doors_secured()
var/ext_closed = (memory["exterior_status"]["state"] == "closed" && memory["exterior_status"]["lock"] == "locked")
var/int_closed = (memory["interior_status"]["state"] == "closed" && memory["interior_status"]["lock"] == "locked")
return (ext_closed && int_closed)
/datum/computer/file/embedded_program/proc/check_doors_closed()
return (memory["interior_status"]["state"] == "closed" && memory["exterior_status"["state"] == "closed")
/datum/computer/file/embedded_program/proc/signalDoor(var/tag, var/command)
/datum/computer/file/embedded_program/airlock/proc/signalDoor(var/tag, var/command)
var/datum/signal/signal = new
signal.data["tag"] = tag
signal.data["command"] = command
post_signal(signal)
/datum/computer/file/embedded_program/proc/signalPump(var/tag, var/power, var/direction, var/pressure)
/datum/computer/file/embedded_program/airlock/proc/signalPump(var/tag, var/power, var/direction, var/pressure)
var/datum/signal/signal = new
signal.data = list(
"tag" = tag,
@@ -260,7 +267,7 @@
post_signal(signal)
//this is called to set the appropriate door state at the end of a cycling process, or for the exterior buttons
/datum/computer/file/embedded_program/proc/cycleDoors(var/target)
/datum/computer/file/embedded_program/airlock/proc/cycleDoors(var/target)
switch(target)
if(TARGET_OUTOPEN)
toggleDoor(memory["interior_status"], tag_interior_door, memory["secure"], "close")
@@ -289,7 +296,7 @@ Only sends a command if it is needed, i.e. if the door is
already open, passing an open command to this proc will not
send an additional command to open the door again.
----------------------------------------------------------*/
/datum/computer/file/embedded_program/proc/toggleDoor(var/list/doorStatus, var/doorTag, var/secure, var/command)
/datum/computer/file/embedded_program/airlock/proc/toggleDoor(var/list/doorStatus, var/doorTag, var/secure, var/command)
var/doorCommand = null
if(command == "toggle")
code/game/machinery/embedded_controller/docking_program.dm
+189 -84
View File
@@ -4,104 +4,209 @@
#define STATE_UNDOCKING 2
#define STATE_DOCKED 3
#define MODE_NONE 0
#define MODE_SERVER 1
#define MODE_CLIENT 2 //The one who initiated the docking, and who can initiate the undocking. The server cannot initiate undocking. (Think server == station, client == shuttle)
/datum/computer/file/embedded_program/docking_port
/*
*** STATE TABLE ***
MODE_CLIENT|STATE_UNDOCKED sent a request for docking and now waiting for a reply.
MODE_CLIENT|STATE_DOCKING server told us they are OK to dock, waiting for our docking port to be ready.
MODE_CLIENT|STATE_DOCKED idle - docked as client.
MODE_CLIENT|STATE_UNDOCKING we are either waiting for our docking port to be ready or for the server to give us the OK to undock.
MODE_SERVER|STATE_UNDOCKED should never happen.
MODE_SERVER|STATE_DOCKING someone requested docking, we are waiting for our docking port to be ready.
MODE_SERVER|STATE_DOCKED idle - docked as server
MODE_SERVER|STATE_UNDOCKING client requested undocking, we are waiting for our docking port to be ready.
MODE_NONE|STATE_UNDOCKED idle - not docked.
MODE_NONE|anything else should never happen.
*/
/datum/computer/file/embedded_program/docking
var/tag_target //the tag of the docking controller that we are trying to dock with
var/airlock_override = 0 //allows use of the docking port as a normal airlock (normally this is only allowed in STATE_UNDOCKED)
var/dock_state = STATE_UNDOCKED
var/dock_master = 0 //are we the initiator of the dock?
var/control_mode = MODE_NONE
var/response_sent = 0 //so we don't spam confirmation messages
var/override_enabled = 0 //skips checks for the docking port being ready
/datum/computer/file/embedded_program/docking_port/receive_signal(datum/signal/signal, receive_method, receive_param)
var/receive_tag = signal.data["tag"] //for docking signals, this is the sender id
/datum/computer/file/embedded_program/docking/receive_signal(datum/signal/signal, receive_method, receive_param)
var/receive_tag = signal.data["tag"] //for docking signals, this is the sender id
var/command = signal.data["command"]
var/recipient = signal.data["recipient"]
var/recipient = signal.data["recipient"] //the intended recipient of the docking signal
if (recipient == id_tag)
switch (command)
if ("request_dock")
if (state == STATE_UNDOCKED)
tag_target = receive_tag
begin_dock()
if ("request_undock")
if(receive_tag == tag_target)
begin_undock()
if ("confirm_dock")
if(receive_tag == tag_target)
dock_master = 1
begin_dock()
else
send_docking_command(receive_tag, "docking_error") //send an error message
if ("confirm_undock")
if(receive_tag == tag_target)
begin_undock()
if ("docking_error")
if(receive_tag==tag_target)
//try to return to a good state
stop_cycling()
//close the doors
toggleDoor(memory["interior_status"], tag_interior_door, memory["secure"], "close")
toggleDoor(memory["exterior_status"], tag_exterior_door, memory["secure"], "close")
state = STATE_UNDOCKED
tag_target = null
dock_master = 0
if (recipient != id_tag)
return //this signal is not for us
..()
switch (command)
if ("confirm_dock")
if (control_mode == MODE_CLIENT && dock_state == STATE_UNDOCKED && receive_tag == tag_target)
dock_state = STATE_DOCKING
if (!override_enabled)
prepare_for_docking()
else if (control_mode == MODE_SERVER && dock_state == STATE_DOCKING && receive_tag == tag_target) //client just sent us the confirmation back, we're done with the docking process
dock_state = STATE_DOCKED
if (!override_enabled)
finish_docking() //server done docking!
response_sent = 0
else
send_docking_command(tag_target, "abort_dock") //not expecting confirmation for anything - tell the other guy.
if ("request_dock")
if (control_mode == MODE_NONE && dock_state == STATE_UNDOCKED)
control_mode = MODE_SERVER
dock_state = STATE_DOCKING
tag_target = receive_tag
if (!override_enabled)
prepare_for_docking()
if ("confirm_undock")
if (control_mode == MODE_CLIENT && dock_state == STATE_UNDOCKING && receive_tag == tag_target)
send_docking_command(tag_target, "confirm_undock")
reset() //client is done undocking!
if ("request_undock")
if (control_mode == MODE_SERVER && dock_state == STATE_DOCKED && receive_tag == tag_target)
dock_state = STATE_UNDOCKING
prepare_for_undocking()
if ("dock_error")
if (receive_tag == tag_target)
reset()
/datum/computer/file/embedded_program/docking_port/receive_user_command(command)
if (state == STATE_UNDOCKED || airlock_override)
..(command)
/datum/computer/file/embedded_program/docking_port/process()
..() //process regular airlock stuff first
/datum/computer/file/embedded_program/docking/process()
switch(dock_state)
if(STATE_DOCKING)
if(done_cycling() || airlock_override)
state = STATE_DOCKED
if (STATE_DOCKING) //waiting for our docking port to be ready for docking
if (ready_for_docking() || override_enabled)
if (!response_sent)
send_docking_command(tag_target, "confirm_dock") //tell the other guy we're ready
response_sent = 1
if (!dock_master)
send_docking_command(tag_target, "confirm_dock") //send confirmation
//open doors
toggleDoor(memory["interior_status"], tag_interior_door, memory["secure"], "open")
toggleDoor(memory["exterior_status"], tag_exterior_door, memory["secure"], "open")
if(STATE_UNDOCKING)
if(check_doors_closed() || airlock_override) //check doors are closed or override
state = STATE_UNDOCKED
if (!dock_master)
send_docking_command(tag_target, "confirm_undock") //send confirmation
dock_master = 0
tag_target = null
/datum/computer/file/embedded_program/docking_port/cycleDoors(var/target)
if (state == STATE_UNDOCKED || airlock_override)
..(target)
//get the docking port into a good state for docking.
/datum/computer/file/embedded_program/docking_port/proc/begin_dock()
dock_state = STATE_DOCKING
begin_cycle_in()
//get the docking port into a good state for undocking.
/datum/computer/file/embedded_program/docking_port/proc/begin_undock()
dock_state = STATE_UNDOCKING
stop_cycling()
if (control_mode == MODE_CLIENT) //client doesn't need to do anything further
dock_state = STATE_DOCKED
if (!override_enabled)
finish_docking() //client done docking!
response_sent = 0
if (STATE_UNDOCKING)
if (ready_for_undocking() || override_enabled)
if (control_mode == MODE_CLIENT)
if (!response_sent)
send_docking_command(tag_target, "request_undock") //tell the server we want to undock now.
response_sent = 1
else if (control_mode == MODE_SERVER)
send_docking_command(tag_target, "confirm_undock") //tell the client we are OK to undock.
reset() //server is done undocking!
//close the doors
toggleDoor(memory["interior_status"], tag_interior_door, memory["secure"], "close")
toggleDoor(memory["exterior_status"], tag_exterior_door, memory["secure"], "close")
if (dock_state != STATE_DOCKING && dock_state != STATE_UNDOCKING)
response_sent = 0
//handle invalid states
if (control_mode == MODE_NONE && dock_state != STATE_UNDOCKED)
if (tag_target)
send_docking_command(tag_target, "dock_error")
reset()
if (control_mode == MODE_SERVER && dock_state == STATE_UNDOCKED)
control_mode = MODE_NONE
/datum/computer/file/embedded_program/docking_port/proc/send_docking_command(var/recipient, var/command)
/datum/computer/file/embedded_program/docking/proc/initiate_docking(var/target)
if (dock_state != STATE_UNDOCKED || control_mode == MODE_SERVER) //must be undocked and not serving another request to begin a new docking handshake
return
tag_target = target
control_mode = MODE_CLIENT
send_docking_command(tag_target, "request_dock")
/datum/computer/file/embedded_program/docking/proc/initiate_undocking()
if (dock_state != STATE_DOCKED || control_mode != MODE_CLIENT) //must be docked and must be client to start undocking
return
dock_state = STATE_UNDOCKING
prepare_for_undocking()
send_docking_command(tag_target, "request_undock")
//tell the docking port to start getting ready for docking - e.g. pressurize
/datum/computer/file/embedded_program/docking/proc/prepare_for_docking()
return
//are we ready for docking?
/datum/computer/file/embedded_program/docking/proc/ready_for_docking()
return 1
//we are docked, open the doors or whatever.
/datum/computer/file/embedded_program/docking/proc/finish_docking()
return
//tell the docking port to start getting ready for undocking - e.g. close those doors.
/datum/computer/file/embedded_program/docking/proc/prepare_for_undocking()
return
//are we ready for undocking?
/datum/computer/file/embedded_program/docking/proc/ready_for_undocking()
return 1
/datum/computer/file/embedded_program/docking/proc/enable_override()
override_enabled = 1
//if (tag_target)
// send_docking_command(tag_target, "enable_override")
/datum/computer/file/embedded_program/docking/proc/disable_override()
override_enabled = 0
//if (tag_target)
// send_docking_command(tag_target, "disable_override")
/datum/computer/file/embedded_program/docking/proc/reset()
dock_state = STATE_UNDOCKED
control_mode = MODE_NONE
tag_target = null
response_sent = 0
/datum/computer/file/embedded_program/docking/proc/force_undock()
if (tag_target)
send_docking_command(tag_target, "dock_error")
reset()
/datum/computer/file/embedded_program/docking/proc/docked()
return (dock_state == STATE_DOCKED)
/datum/computer/file/embedded_program/docking/proc/undocked()
return (dock_state == STATE_UNDOCKED)
//returns 1 if we are saftely undocked (and the shuttle can leave)
/datum/computer/file/embedded_program/docking/proc/can_launch()
return undocked()
/datum/computer/file/embedded_program/docking/proc/send_docking_command(var/recipient, var/command)
var/datum/signal/signal = new
signal.data["tag"] = id_tag
signal.data["command"] = command
signal.data["recipient"] = recipient
post_signal(signal)
//this is mostly for NanoUI
/datum/computer/file/embedded_program/docking/proc/get_docking_status()
switch (dock_state)
if (STATE_UNDOCKED) return "undocked"
if (STATE_DOCKING) return "docking"
if (STATE_UNDOCKING) return "undocking"
if (STATE_DOCKED) return "docked"
#undef STATE_UNDOCKED
#undef STATE_DOCKING
#undef STATE_UNDOCKING
#undef STATE_DOCKED
#undef MODE_NONE
#undef MODE_SERVER
#undef MODE_CLIENT
code/game/machinery/embedded_controller/embedded_controller_base.dm
+54 -65
View File
@@ -1,84 +1,73 @@
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
del(signal)
receive_user_command(command)
receive_signal(datum/signal/signal, receive_method, receive_param)
return null
process()
return 0
obj/machinery/embedded_controller
/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.set_machine(src)
onclose(user, "computer")
/obj/machinery/embedded_controller/proc/post_signal(datum/signal/signal, comm_line)
return 0
update_icon()
proc/return_text()
/obj/machinery/embedded_controller/receive_signal(datum/signal/signal, receive_method, receive_param)
if(!signal || signal.encryption) return
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)
program.receive_signal(signal, receive_method, receive_param)
if(program)
program.receive_signal(signal, receive_method, receive_param)
//spawn(5) program.process() //no, program.process sends some signals and machines respond and we here again and we lag -rastaf0
Topic(href, href_list)
if(..())
return 0
/obj/machinery/embedded_controller/process()
if(program)
program.process()
if(program)
program.receive_user_command(href_list["command"])
spawn(5) program.process()
update_icon()
src.updateDialog()
usr.set_machine(src)
spawn(5) src.updateDialog()
/obj/machinery/embedded_controller/attack_ai(mob/user as mob)
src.ui_interact(user)
process()
if(program)
program.process()
/obj/machinery/embedded_controller/attack_paw(mob/user as mob)
user << "You do not have the dexterity to use this."
return
update_icon()
src.updateDialog()
/obj/machinery/embedded_controller/attack_hand(mob/user as mob)
src.ui_interact(user)
radio
var/frequency
var/datum/radio_frequency/radio_connection
/obj/machinery/embedded_controller/ui_interact()
return
initialize()
set_frequency(frequency)
/obj/machinery/embedded_controller/radio
icon = 'icons/obj/airlock_machines.dmi'
icon_state = "airlock_control_standby"
power_channel = ENVIRON
density = 0
var/id_tag
post_signal(datum/signal/signal)
signal.transmission_method = TRANSMISSION_RADIO
if(radio_connection)
return radio_connection.post_signal(src, signal)
else
del(signal)
var/frequency = 1379
var/datum/radio_frequency/radio_connection
unacidable = 1
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/initialize()
set_frequency(frequency)
/obj/machinery/embedded_controller/radio/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"
/obj/machinery/embedded_controller/radio/post_signal(datum/signal/signal)
signal.transmission_method = TRANSMISSION_RADIO
if(radio_connection)
return radio_connection.post_signal(src, signal)
else
del(signal)
/obj/machinery/embedded_controller/radio/proc/set_frequency(new_frequency)
radio_controller.remove_object(src, frequency)
frequency = new_frequency
radio_connection = radio_controller.add_object(src, frequency)
code/game/machinery/embedded_controller/embedded_program_base.dm
+27
View File
@@ -0,0 +1,27 @@
/datum/computer/file/embedded_program
var/list/memory = list()
var/obj/machinery/embedded_controller/master
var/id_tag
/datum/computer/file/embedded_program/New(var/obj/machinery/embedded_controller/M)
master = M
if (istype(M, /obj/machinery/embedded_controller/radio))
var/obj/machinery/embedded_controller/radio/R = M
id_tag = R.id_tag
/datum/computer/file/embedded_program/proc/receive_user_command(command)
return
/datum/computer/file/embedded_program/proc/receive_signal(datum/signal/signal, receive_method, receive_param)
return
/datum/computer/file/embedded_program/proc/process()
return
/datum/computer/file/embedded_program/proc/post_signal(datum/signal/signal, comm_line)
if(master)
master.post_signal(signal, comm_line)
else
del(signal)
code/game/machinery/embedded_controller/simple_docking_controller.dm
+160
View File
@@ -0,0 +1,160 @@
//a docking port that uses a single door
/obj/machinery/embedded_controller/radio/simple_docking_controller
name = "docking hatch controller"
var/tag_door
var/datum/computer/file/embedded_program/docking/simple/docking_program
/obj/machinery/embedded_controller/radio/simple_docking_controller/initialize()
..()
docking_program = new/datum/computer/file/embedded_program/docking/simple(src)
program = docking_program
/obj/machinery/embedded_controller/radio/simple_docking_controller/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null)
var/data[0]
data = list(
"docking_status" = docking_program.get_docking_status(),
"override_enabled" = docking_program.override_enabled,
)
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data)
if (!ui)
ui = new(user, src, ui_key, "simple_docking_console.tmpl", name, 470, 290)
ui.set_initial_data(data)
ui.open()
ui.set_auto_update(1)
/obj/machinery/embedded_controller/radio/simple_docking_controller/Topic(href, href_list)
if(..())
return
usr.set_machine(src)
src.add_fingerprint(usr)
var/clean = 0
switch(href_list["command"]) //anti-HTML-hacking checks
if("force_door")
clean = 1
if("toggle_override")
clean = 1
if(clean)
program.receive_user_command(href_list["command"])
return 1
//A docking controller program for a simple door based docking port
/datum/computer/file/embedded_program/docking/simple
var/tag_door
/datum/computer/file/embedded_program/docking/simple/New(var/obj/machinery/embedded_controller/M)
..(M)
memory["door_status"] = list(state = "closed", lock = "locked") //assume closed and locked in case the doors dont report in
memory["door_status"] = list(state = "closed", lock = "locked")
if (istype(M, /obj/machinery/embedded_controller/radio/simple_docking_controller))
var/obj/machinery/embedded_controller/radio/simple_docking_controller/controller = M
tag_door = controller.tag_door
spawn(10)
signal_door("update") //signals connected doors to update their status
/datum/computer/file/embedded_program/docking/simple/receive_signal(datum/signal/signal, receive_method, receive_param)
var/receive_tag = signal.data["tag"]
if(!receive_tag) return
if(receive_tag==tag_door)
memory["door_status"]["state"] = signal.data["door_status"]
memory["door_status"]["lock"] = signal.data["lock_status"]
..(signal, receive_method, receive_param)
/datum/computer/file/embedded_program/docking/simple/receive_user_command(command)
switch(command)
if("force_door")
if (override_enabled)
if(memory["door_status"]["state"] == "open")
close_door()
else
open_door()
if("toggle_override")
if (override_enabled)
disable_override()
else
enable_override()
/datum/computer/file/embedded_program/docking/simple/proc/signal_door(var/command)
var/datum/signal/signal = new
signal.data["tag"] = tag_door
signal.data["command"] = command
post_signal(signal)
/datum/computer/file/embedded_program/docking/simple/proc/open_door()
if(memory["door_status"]["state"] == "closed")
signal_door("secure_open")
else if(memory["door_status"]["lock"] == "unlocked")
signal_door("lock")
/datum/computer/file/embedded_program/docking/simple/proc/close_door()
if(memory["door_status"]["state"] == "open")
signal_door("secure_close")
else if(memory["door_status"]["lock"] == "unlocked")
signal_door("lock")
//tell the docking port to start getting ready for docking - e.g. pressurize
/datum/computer/file/embedded_program/docking/simple/prepare_for_docking()
return //don't need to do anything
//are we ready for docking?
/datum/computer/file/embedded_program/docking/simple/ready_for_docking()
return 1 //don't need to do anything
//we are docked, open the doors or whatever.
/datum/computer/file/embedded_program/docking/simple/finish_docking()
open_door()
//tell the docking port to start getting ready for undocking - e.g. close those doors.
/datum/computer/file/embedded_program/docking/simple/prepare_for_undocking()
close_door()
//are we ready for undocking?
/datum/computer/file/embedded_program/docking/simple/ready_for_undocking()
return (memory["door_status"]["state"] == "closed" && memory["door_status"]["lock"] == "locked")
/datum/computer/file/embedded_program/docking/simple/reset()
close_door()
..()
/*** DEBUG VERBS ***
/obj/machinery/embedded_controller/radio/simple_docking_controller/verb/view_state()
set category = "Debug"
set src in view(1)
src.program:print_state()
/obj/machinery/embedded_controller/radio/simple_docking_controller/verb/spoof_signal(var/command as text, var/sender as text)
set category = "Debug"
set src in view(1)
var/datum/signal/signal = new
signal.data["tag"] = sender
signal.data["command"] = command
signal.data["recipient"] = id_tag
src.program:receive_signal(signal)
/obj/machinery/embedded_controller/radio/simple_docking_controller/verb/debug_init_dock(var/target as text)
set category = "Debug"
set src in view(1)
src.program:initiate_docking(target)
/obj/machinery/embedded_controller/radio/simple_docking_controller/verb/debug_init_undock()
set category = "Debug"
set src in view(1)
src.program:initiate_undocking()
*/
code/game/machinery/embedded_controller/simple_vent_controller.dm
-79
View File
@@ -1,79 +0,0 @@
/datum/computer/file/embedded_program/simple_vent_controller
var/airpump_tag
receive_user_command(command)
switch(command)
if("vent_inactive")
var/datum/signal/signal = new
signal.data = list(
"tag" = airpump_tag,
"sigtype"="command"
)
signal.data["power"] = 0
post_signal(signal)
if("vent_pump")
var/datum/signal/signal = new
signal.data = list(
"tag" = airpump_tag,
"sigtype"="command"
)
signal.data["stabalize"] = 1
signal.data["power"] = 1
post_signal(signal)
if("vent_clear")
var/datum/signal/signal = new
signal.transmission_method = 1 //radio signal
signal.data = list(
"tag" = airpump_tag,
"sigtype"="command"
)
signal.data["purge"] = 1
signal.data["power"] = 1
post_signal(signal)
process()
return 0
/obj/machinery/embedded_controller/radio/simple_vent_controller
icon = 'icons/obj/airlock_machines.dmi'
icon_state = "airlock_control_standby"
name = "Vent Controller"
density = 0
unacidable = 1
frequency = 1229
power_channel = ENVIRON
// Setup parameters only
var/airpump_tag
initialize()
..()
var/datum/computer/file/embedded_program/simple_vent_controller/new_prog = new
new_prog.airpump_tag = airpump_tag
new_prog.master = src
program = new_prog
update_icon()
if(on && program)
icon_state = "airlock_control_standby"
else
icon_state = "airlock_control_off"
return_text()
var/state_options = null
state_options = {"<A href='?src=\ref[src];command=vent_inactive'>Deactivate Vent</A><BR>
<A href='?src=\ref[src];command=vent_pump'>Activate Vent / Pump</A><BR>
<A href='?src=\ref[src];command=vent_clear'>Activate Vent / Clear</A><BR>"}
var/output = {"<B>Vent Control Console</B><HR>
[state_options]<HR>"}
return output
code/game/machinery/embedded_controller/smart_airlock_controller.dm
-369
View File
@@ -1,369 +0,0 @@
//States for airlock_control
#define AIRLOCK_STATE_WAIT 0
#define AIRLOCK_STATE_DEPRESSURIZE 1
#define AIRLOCK_STATE_PRESSURIZE 2
#define AIRLOCK_TARGET_INOPEN -1
#define AIRLOCK_TARGET_NONE 0
#define AIRLOCK_TARGET_OUTOPEN 1
datum/computer/file/embedded_program/smart_airlock_controller
var/id_tag
var/tag_exterior_door
var/tag_interior_door
var/tag_airpump
var/tag_chamber_sensor
var/tag_exterior_sensor
var/tag_interior_sensor
//var/sanitize_external
state = AIRLOCK_STATE_WAIT
var/target_state = AIRLOCK_TARGET_NONE
datum/computer/file/embedded_program/smart_airlock_controller/New()
..()
memory["chamber_sensor_pressure"] = ONE_ATMOSPHERE
memory["external_sensor_pressure"] = ONE_ATMOSPHERE
memory["internal_sensor_pressure"] = ONE_ATMOSPHERE
memory["exterior_status"] = "unknown"
memory["interior_status"] = "unknown"
memory["pump_status"] = "unknown"
memory["target_pressure"] = ONE_ATMOSPHERE
datum/computer/file/embedded_program/smart_airlock_controller/receive_signal(datum/signal/signal, receive_method, receive_param)
var/receive_tag = signal.data["tag"]
if(!receive_tag) return
if(receive_tag==tag_chamber_sensor)
if(signal.data["pressure"])
memory["chamber_sensor_pressure"] = text2num(signal.data["pressure"])
else if(receive_tag==tag_exterior_sensor)
if(signal.data["pressure"])
memory["external_sensor_pressure"] = text2num(signal.data["pressure"])
else if(receive_tag==tag_interior_sensor)
if(signal.data["pressure"])
memory["internal_sensor_pressure"] = text2num(signal.data["pressure"])
else if(receive_tag==tag_exterior_door)
memory["exterior_status"] = signal.data["door_status"]
else if(receive_tag==tag_interior_door)
memory["interior_status"] = signal.data["door_status"]
else if(receive_tag==tag_airpump)
if(signal.data["power"])
memory["pump_status"] = signal.data["direction"]
else
memory["pump_status"] = "off"
else if(receive_tag==id_tag)
switch(signal.data["command"])
if("cycle_exterior")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_OUTOPEN
if("cycle_interior")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_INOPEN
master.updateDialog()
datum/computer/file/embedded_program/smart_airlock_controller/receive_user_command(command)
var/shutdown_pump = 0
switch(command)
if("cycle_closed")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_NONE
if(memory["interior_status"] != "closed")
var/datum/signal/signal = new
signal.data["tag"] = tag_interior_door
signal.data["command"] = "secure_close"
post_signal(signal)
if(memory["exterior_status"] != "closed")
var/datum/signal/signal = new
signal.data["tag"] = tag_exterior_door
signal.data["command"] = "secure_close"
post_signal(signal)
shutdown_pump = 1
if("open_interior")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_NONE
if(memory["interior_status"] != "open")
var/datum/signal/signal = new
signal.data["tag"] = tag_interior_door
signal.data["command"] = "secure_open"
post_signal(signal)
if("close_interior")
if(memory["interior_status"] != "closed")
var/datum/signal/signal = new
signal.data["tag"] = tag_interior_door
signal.data["command"] = "secure_close"
post_signal(signal)
shutdown_pump = 1
if("close_exterior")
if(memory["exterior_status"] != "closed")
var/datum/signal/signal = new
signal.data["tag"] = tag_exterior_door
signal.data["command"] = "secure_close"
post_signal(signal)
shutdown_pump = 1
if("open_exterior")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_NONE
if(memory["exterior_status"] != "open")
var/datum/signal/signal = new
signal.data["tag"] = tag_exterior_door
signal.data["command"] = "secure_open"
post_signal(signal)
if("cycle_exterior")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_OUTOPEN
if("cycle_interior")
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_INOPEN
if(shutdown_pump)
//send a signal to stop pressurizing
if(memory["pump_status"] != "off")
var/datum/signal/signal = new
signal.data = list(
"tag" = tag_airpump,
"power" = 0,
"sigtype"="command"
)
post_signal(signal)
master.updateDialog()
datum/computer/file/embedded_program/smart_airlock_controller/process()
var/process_again = 1
while(process_again)
process_again = 0
if(!state && target_state)
//we're ready to do stuff, now what do we want to do?
switch(target_state)
if(AIRLOCK_TARGET_INOPEN)
memory["target_pressure"] = memory["internal_sensor_pressure"]
if(AIRLOCK_TARGET_OUTOPEN)
memory["target_pressure"] = memory["external_sensor_pressure"]
//work out whether we need to pressurize or depressurize the chamber (5% leeway with target pressure)
var/chamber_pressure = memory["chamber_sensor_pressure"]
var/target_pressure = memory["target_pressure"]
if(chamber_pressure <= target_pressure)
state = AIRLOCK_STATE_PRESSURIZE
//send a signal to start pressurizing
var/datum/signal/signal = new
signal.data = list(
"tag" = tag_airpump,
"sigtype"="command",
"power"=1,
"direction"=1,
"set_external_pressure"=target_pressure
)
post_signal(signal)
else if(chamber_pressure > target_pressure)
state = AIRLOCK_STATE_DEPRESSURIZE
//send a signal to start depressurizing
var/datum/signal/signal = new
signal.transmission_method = 1 //radio signal
signal.data = list(
"tag" = tag_airpump,
"sigtype"="command",
"power"=1,
"direction"=0,
"set_external_pressure"=target_pressure
)
post_signal(signal)
//actually do stuff
//override commands are handled elsewhere, otherwise everything proceeds automatically
switch(state)
if(AIRLOCK_STATE_PRESSURIZE)
if(memory["chamber_sensor_pressure"] >= memory["target_pressure"] * 0.95)
if(target_state < 0)
if(memory["interior_status"] != "open")
var/datum/signal/signal = new
signal.data["tag"] = tag_interior_door
signal.data["command"] = "secure_open"
post_signal(signal)
else if(target_state > 0)
if(memory["exterior_status"] != "open")
var/datum/signal/signal = new
signal.data["tag"] = tag_exterior_door
signal.data["command"] = "secure_open"
post_signal(signal)
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_NONE
//send a signal to stop pumping
if(memory["pump_status"] != "off")
var/datum/signal/signal = new
signal.data = list(
"tag" = tag_airpump,
"sigtype"="command",
"power" = 0
)
post_signal(signal)
master.updateDialog()
if(AIRLOCK_STATE_DEPRESSURIZE)
if(memory["chamber_sensor_pressure"] <= memory["target_pressure"] * 1.05)
if(target_state > 0)
if(memory["exterior_status"] != "open")
var/datum/signal/signal = new
signal.data["tag"] = tag_exterior_door
signal.data["command"] = "secure_open"
post_signal(signal)
else if(target_state < 0)
if(memory["interior_status"] != "open")
var/datum/signal/signal = new
signal.data["tag"] = tag_interior_door
signal.data["command"] = "secure_open"
post_signal(signal)
state = AIRLOCK_STATE_WAIT
target_state = AIRLOCK_TARGET_NONE
//send a signal to stop pumping
if(memory["pump_status"] != "off")
var/datum/signal/signal = new
signal.data = list(
"tag" = tag_airpump,
"sigtype"="command",
"power" = 0
)
post_signal(signal)
master.updateDialog()
//memory["sensor_pressure"] = sensor_pressure
memory["processing"] = state != target_state
//sensor_pressure = null //not sure if we can comment this out. Uncomment in case of problems -rastaf0
return 1
obj/machinery/embedded_controller/radio/smart_airlock_controller
icon = 'icons/obj/airlock_machines.dmi'
icon_state = "airlock_control_standby"
name = "Cycling Airlock Console"
density = 0
unacidable = 1
frequency = 1449
power_channel = ENVIRON
// Setup parameters only
var/id_tag
var/tag_exterior_door
var/tag_interior_door
var/tag_airpump
var/tag_chamber_sensor
var/tag_exterior_sensor
var/tag_interior_sensor
//var/sanitize_external
initialize()
..()
var/datum/computer/file/embedded_program/smart_airlock_controller/new_prog = new
new_prog.id_tag = id_tag
new_prog.tag_exterior_door = tag_exterior_door
new_prog.tag_interior_door = tag_interior_door
new_prog.tag_airpump = tag_airpump
new_prog.tag_chamber_sensor = tag_chamber_sensor
new_prog.tag_exterior_sensor = tag_exterior_sensor
new_prog.tag_interior_sensor = tag_interior_sensor
//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 = ""
var/state = 0
var/chamber_sensor_pressure = "----"
var/external_sensor_pressure = "----"
var/internal_sensor_pressure = "----"
var/exterior_status = "----"
var/interior_status = "----"
var/pump_status = "----"
var/target_pressure = "----"
if(program)
state = program.state
chamber_sensor_pressure = program.memory["chamber_sensor_pressure"]
external_sensor_pressure = program.memory["external_sensor_pressure"]
internal_sensor_pressure = program.memory["internal_sensor_pressure"]
exterior_status = program.memory["exterior_status"]
interior_status = program.memory["interior_status"]
pump_status = program.memory["pump_status"]
target_pressure = program.memory["target_pressure"]
var/exterior_closed = 0
if(exterior_status == "closed")
exterior_closed = 1
var/interior_closed = 0
if(interior_status == "closed")
interior_closed = 1
state_options += "<B>Exterior status: </B> [exterior_status] ([external_sensor_pressure] kPa)<br>"
if(exterior_closed)
state_options += "<A href='?src=\ref[src];command=open_exterior'>Open exterior airlock</A> "
if(abs(chamber_sensor_pressure - external_sensor_pressure) > ONE_ATMOSPHERE * 0.05)
state_options += "<font color='red'><b>WARNING</b></font>"
state_options += "<BR>"
if(!state && exterior_closed && interior_closed)
state_options += "<A href='?src=\ref[src];command=cycle_exterior'>Cycle to Exterior Airlock</A><BR>"
else
state_options += "<br>"
else
state_options += "<A href='?src=\ref[src];command=close_exterior'>Close exterior airlock</A><BR>"
state_options += "<BR>"
state_options += "<B>Interior status: </B> [interior_status] ([internal_sensor_pressure] kPa)<br>"
if(interior_closed)
state_options += "<A href='?src=\ref[src];command=open_interior'>Open interior airlock</A> "
if(abs(chamber_sensor_pressure - internal_sensor_pressure) > ONE_ATMOSPHERE * 0.05)
state_options += "<font color='red'><b>WARNING</b></font>"
state_options += "<BR>"
if(!state && exterior_closed && interior_closed)
state_options += "<A href='?src=\ref[src];command=cycle_interior'>Cycle to Interior Airlock</A><BR>"
else
state_options += "<br>"
else
state_options += "<A href='?src=\ref[src];command=close_interior'>Close interior airlock</A><BR>"
state_options += "<BR>"
state_options += "<br>"
state_options += "<B>Chamber Pressure:</B> [chamber_sensor_pressure] kPa<BR>"
state_options += "<B>Target Chamber Pressure:</B> [target_pressure] kPa<BR>"
state_options += "<B>Control Pump: </B> [pump_status]<BR>"
if(state)
state_options += "<A href='?src=\ref[src];command=cycle_closed'>Abort Cycling</A><BR>"
else
state_options += "<br>"
return state_options
#undef AIRLOCK_STATE_PRESSURIZE
#undef AIRLOCK_STATE_WAIT
#undef AIRLOCK_STATE_DEPRESSURIZE
#undef AIRLOCK_TARGET_INOPEN
#undef AIRLOCK_TARGET_CLOSED
#undef AIRLOCK_TARGET_OUTOPEN