mirror of
https://github.com/ParadiseSS13/Paradise.git
synced 2026-08-22 11:37:40 +01:00
Removes Docking Controllers
This commit is contained in:
Fox-McCloud
@@ -1,180 +0,0 @@
|
||||
//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/force_open = 1)
|
||||
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),
|
||||
"override_enabled" = docking_program.override_enabled,
|
||||
)
|
||||
|
||||
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data, force_open)
|
||||
|
||||
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.enable_mech_regulators()
|
||||
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()
|
||||
airlock_program.disable_mech_regulators()
|
||||
|
||||
//are we ready for undocking?
|
||||
/datum/computer/file/embedded_program/docking/airlock/ready_for_undocking()
|
||||
var/ext_closed = airlock_program.check_exterior_door_secured()
|
||||
var/int_closed = airlock_program.check_interior_door_secured()
|
||||
return (ext_closed || int_closed)
|
||||
|
||||
//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/enable_mech_regulators()
|
||||
enable_mech_regulation()
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/docking/proc/disable_mech_regulators()
|
||||
disable_mech_regulation()
|
||||
|
||||
/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()
|
||||
to_chat(world, "id_tag: [id_tag]")
|
||||
to_chat(world, "dock_state: [dock_state]")
|
||||
to_chat(world, "control_mode: [control_mode]")
|
||||
to_chat(world, "tag_target: [tag_target]")
|
||||
to_chat(world, "response_sent: [response_sent]")
|
||||
|
||||
/datum/computer/file/embedded_program/docking/post_signal(datum/signal/signal, comm_line)
|
||||
to_chat(world, "Program [id_tag] sent a message!")
|
||||
print_state()
|
||||
to_chat(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()
|
||||
|
||||
*/
|
||||
@@ -1,153 +0,0 @@
|
||||
//a controller for a docking port with multiple independent airlocks
|
||||
//this is the master controller, that things will try to dock with.
|
||||
/obj/machinery/embedded_controller/radio/docking_port_multi
|
||||
name = "docking port controller"
|
||||
|
||||
var/child_tags_txt
|
||||
var/child_names_txt
|
||||
var/list/child_names = list()
|
||||
|
||||
var/datum/computer/file/embedded_program/docking/multi/docking_program
|
||||
|
||||
/obj/machinery/embedded_controller/radio/docking_port_multi/initialize()
|
||||
..()
|
||||
docking_program = new/datum/computer/file/embedded_program/docking/multi(src)
|
||||
program = docking_program
|
||||
|
||||
var/list/names = splittext(child_names_txt, ";")
|
||||
var/list/tags = splittext(child_tags_txt, ";")
|
||||
|
||||
if(names.len == tags.len)
|
||||
for(var/i = 1; i <= tags.len; i++)
|
||||
child_names[tags[i]] = names[i]
|
||||
|
||||
|
||||
/obj/machinery/embedded_controller/radio/docking_port_multi/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1)
|
||||
var/data[0]
|
||||
|
||||
var/list/airlocks[child_names.len]
|
||||
var/i = 1
|
||||
for(var/child_tag in child_names)
|
||||
airlocks[i++] = list("name"=child_names[child_tag], "override_enabled"=(docking_program.children_override[child_tag] == "enabled"))
|
||||
|
||||
data = list(
|
||||
"docking_status" = docking_program.get_docking_status(),
|
||||
"airlocks" = airlocks,
|
||||
)
|
||||
|
||||
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data, force_open)
|
||||
|
||||
if(!ui)
|
||||
ui = new(user, src, ui_key, "multi_docking_console.tmpl", name, 470, 290)
|
||||
ui.set_initial_data(data)
|
||||
ui.open()
|
||||
ui.set_auto_update(1)
|
||||
|
||||
/obj/machinery/embedded_controller/radio/docking_port_multi/Topic(href, href_list)
|
||||
return
|
||||
|
||||
|
||||
|
||||
//a docking port based on an airlock
|
||||
/obj/machinery/embedded_controller/radio/airlock/docking_port_multi
|
||||
name = "docking port controller"
|
||||
var/master_tag //for mapping
|
||||
var/datum/computer/file/embedded_program/airlock/multi_docking/airlock_program
|
||||
tag_secure = 1
|
||||
|
||||
/obj/machinery/embedded_controller/radio/airlock/docking_port_multi/initialize()
|
||||
..()
|
||||
airlock_program = new/datum/computer/file/embedded_program/airlock/multi_docking(src)
|
||||
program = airlock_program
|
||||
|
||||
/obj/machinery/embedded_controller/radio/airlock/docking_port_multi/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1)
|
||||
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" = airlock_program.master_status,
|
||||
"airlock_disabled" = (airlock_program.docking_enabled && !airlock_program.override_enabled),
|
||||
"override_enabled" = airlock_program.override_enabled,
|
||||
)
|
||||
|
||||
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data, force_open)
|
||||
|
||||
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_multi/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
|
||||
|
||||
|
||||
|
||||
/*** DEBUG VERBS ***
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/proc/print_state()
|
||||
to_chat(world, "id_tag: [id_tag]")
|
||||
to_chat(world, "dock_state: [dock_state]")
|
||||
to_chat(world, "control_mode: [control_mode]")
|
||||
to_chat(world, "tag_target: [tag_target]")
|
||||
to_chat(world, "response_sent: [response_sent]")
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/post_signal(datum/signal/signal, comm_line)
|
||||
to_chat(world, "Program [id_tag] sent a message!")
|
||||
print_state()
|
||||
to_chat(world, "[id_tag] sent command \"[signal.data["command"]]\" to \"[signal.data["recipient"]]\"")
|
||||
..(signal)
|
||||
|
||||
/obj/machinery/embedded_controller/radio/docking_port_multi/verb/view_state()
|
||||
set category = "Debug"
|
||||
set src in view(1)
|
||||
src.program:print_state()
|
||||
|
||||
/obj/machinery/embedded_controller/radio/docking_port_multi/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/docking_port_multi/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/docking_port_multi/verb/debug_init_undock()
|
||||
set category = "Debug"
|
||||
set src in view(1)
|
||||
src.program:initiate_undocking()
|
||||
|
||||
*/
|
||||
@@ -1,286 +0,0 @@
|
||||
|
||||
#define STATE_UNDOCKED 0
|
||||
#define STATE_DOCKING 1
|
||||
#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, and is the one responsible for deciding to accept a docking request and signals when docking and undocking is complete. (Think server == station, client == shuttle)
|
||||
|
||||
#define MESSAGE_RESEND_TIME 5 //how long (in seconds) do we wait before resending a message
|
||||
|
||||
/*
|
||||
*** 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 finish undocking.
|
||||
|
||||
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.
|
||||
|
||||
*** Docking Signals ***
|
||||
|
||||
Docking
|
||||
Client sends request_dock
|
||||
|
||||
Server sends confirm_dock to say that yes, we will serve your request
|
||||
When client is ready, sends confirm_dock
|
||||
Server sends confirm_dock back to indicate that docking is complete
|
||||
|
||||
Undocking
|
||||
Client sends request_undock
|
||||
When client is ready, sends confirm_undock
|
||||
Server sends confirm_undock back to indicate that docking is complete
|
||||
|
||||
Note that in both cases each side exchanges confirm_dock before the docking operation is considered done.
|
||||
The client first sends a confirm message to indicate it is ready, and then finally the server will send it's
|
||||
confirm message to indicate that the operation is complete.
|
||||
|
||||
Note also that when docking, the server sends an additional confirm message. This is because before docking,
|
||||
the server and client do not have a defined relationship. Before undocking, the server and client are already
|
||||
related to each other, thus the extra confirm message is not needed.
|
||||
|
||||
*** Override, what is it? ***
|
||||
|
||||
The purpose of enabling the override is to prevent the docking program from automatically doing things with the docking port when docking or undocking.
|
||||
Maybe the shuttle is full of plasma for some reason, and you don't want the door to automatically open, or the airlock to cycle.
|
||||
This means that the prepare_for_docking/undocking and finish_docking/undocking procs don't get called.
|
||||
|
||||
The docking controller will still check the state of the docking port, and thus prevent the shuttle from launching unless they force the launch (handling forced
|
||||
launches is not the docking controller's responsibility). In this case it is up to the players to manually get the docking port into a good state to undock
|
||||
(which usually just means closing and locking the doors).
|
||||
|
||||
In line with this, docking controllers should prevent players from manually doing things when the override is NOT enabled.
|
||||
*/
|
||||
|
||||
|
||||
/datum/computer/file/embedded_program/docking
|
||||
var/tag_target //the tag of the docking controller that we are trying to dock with
|
||||
var/dock_state = STATE_UNDOCKED
|
||||
var/control_mode = MODE_NONE
|
||||
var/response_sent = 0 //so we don't spam confirmation messages
|
||||
var/resend_counter = 0 //for periodically resending confirmation messages in case they are missed
|
||||
|
||||
var/override_enabled = 0 //when enabled, do not open/close doors or cycle airlocks and wait for the player to do it manually
|
||||
var/received_confirm = 0 //for undocking, whether the server has recieved a confirmation from the client
|
||||
|
||||
/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"] //the intended recipient of the docking signal
|
||||
|
||||
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
|
||||
broadcast_docking_status()
|
||||
if(!override_enabled)
|
||||
prepare_for_docking()
|
||||
|
||||
else if(control_mode == MODE_CLIENT && dock_state == STATE_DOCKING && receive_tag == tag_target)
|
||||
dock_state = STATE_DOCKED
|
||||
broadcast_docking_status()
|
||||
if(!override_enabled)
|
||||
finish_docking() //client done docking!
|
||||
response_sent = 0
|
||||
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
|
||||
received_confirm = 1
|
||||
|
||||
if("request_dock")
|
||||
if(control_mode == MODE_NONE && dock_state == STATE_UNDOCKED)
|
||||
control_mode = MODE_SERVER
|
||||
|
||||
dock_state = STATE_DOCKING
|
||||
broadcast_docking_status()
|
||||
|
||||
tag_target = receive_tag
|
||||
if(!override_enabled)
|
||||
prepare_for_docking()
|
||||
send_docking_command(tag_target, "confirm_dock") //acknowledge the request
|
||||
|
||||
if("confirm_undock")
|
||||
if(control_mode == MODE_CLIENT && dock_state == STATE_UNDOCKING && receive_tag == tag_target)
|
||||
if(!override_enabled)
|
||||
finish_undocking()
|
||||
reset() //client is done undocking!
|
||||
else if(control_mode == MODE_SERVER && dock_state == STATE_UNDOCKING && receive_tag == tag_target)
|
||||
received_confirm = 1
|
||||
|
||||
if("request_undock")
|
||||
if(control_mode == MODE_SERVER && dock_state == STATE_DOCKED && receive_tag == tag_target)
|
||||
dock_state = STATE_UNDOCKING
|
||||
broadcast_docking_status()
|
||||
|
||||
if(!override_enabled)
|
||||
prepare_for_undocking()
|
||||
|
||||
if("dock_error")
|
||||
if(receive_tag == tag_target)
|
||||
reset()
|
||||
|
||||
/datum/computer/file/embedded_program/docking/process()
|
||||
switch(dock_state)
|
||||
if(STATE_DOCKING) //waiting for our docking port to be ready for docking
|
||||
if(ready_for_docking())
|
||||
if(control_mode == MODE_CLIENT)
|
||||
if(!response_sent)
|
||||
send_docking_command(tag_target, "confirm_dock") //tell the server we're ready
|
||||
response_sent = 1
|
||||
|
||||
else if(control_mode == MODE_SERVER && received_confirm)
|
||||
send_docking_command(tag_target, "confirm_dock") //tell the client we are done docking.
|
||||
|
||||
dock_state = STATE_DOCKED
|
||||
broadcast_docking_status()
|
||||
|
||||
if(!override_enabled)
|
||||
finish_docking() //server done docking!
|
||||
response_sent = 0
|
||||
received_confirm = 0
|
||||
|
||||
if(STATE_UNDOCKING)
|
||||
if(ready_for_undocking())
|
||||
if(control_mode == MODE_CLIENT)
|
||||
if(!response_sent)
|
||||
send_docking_command(tag_target, "confirm_undock") //tell the server we are OK to undock.
|
||||
response_sent = 1
|
||||
|
||||
else if(control_mode == MODE_SERVER && received_confirm)
|
||||
send_docking_command(tag_target, "confirm_undock") //tell the client we are done undocking.
|
||||
if(!override_enabled)
|
||||
finish_undocking()
|
||||
reset() //server is done undocking!
|
||||
|
||||
if(response_sent || resend_counter > 0)
|
||||
resend_counter++
|
||||
|
||||
if(resend_counter >= MESSAGE_RESEND_TIME || (dock_state != STATE_DOCKING && dock_state != STATE_UNDOCKING))
|
||||
response_sent = 0
|
||||
resend_counter = 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/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
|
||||
broadcast_docking_status()
|
||||
|
||||
if(!override_enabled)
|
||||
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
|
||||
|
||||
//we are docked, open the doors or whatever.
|
||||
/datum/computer/file/embedded_program/docking/proc/finish_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
|
||||
|
||||
/datum/computer/file/embedded_program/docking/proc/disable_override()
|
||||
override_enabled = 0
|
||||
|
||||
/datum/computer/file/embedded_program/docking/proc/reset()
|
||||
dock_state = STATE_UNDOCKED
|
||||
broadcast_docking_status()
|
||||
|
||||
control_mode = MODE_NONE
|
||||
tag_target = null
|
||||
response_sent = 0
|
||||
received_confirm = 0
|
||||
|
||||
/datum/computer/file/embedded_program/docking/proc/force_undock()
|
||||
// to_chat(world, "[id_tag]: forcing 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)
|
||||
|
||||
/datum/computer/file/embedded_program/docking/proc/broadcast_docking_status()
|
||||
var/datum/signal/signal = new
|
||||
signal.data["tag"] = id_tag
|
||||
signal.data["dock_status"] = get_docking_status()
|
||||
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
|
||||
@@ -1,223 +0,0 @@
|
||||
/*
|
||||
These programs are for docking controllers that consist of multiple independent airlocks
|
||||
Each airlock has an airlock controller running the child program, and there is one docking controller running the master program
|
||||
*/
|
||||
|
||||
/*
|
||||
the master program
|
||||
*/
|
||||
/datum/computer/file/embedded_program/docking/multi
|
||||
var/list/children_tags
|
||||
var/list/children_ready
|
||||
var/list/children_override
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/New(var/obj/machinery/embedded_controller/M)
|
||||
..(M)
|
||||
|
||||
if(istype(M,/obj/machinery/embedded_controller/radio/docking_port_multi)) //if our parent controller is the right type, then we can auto-init stuff at construction
|
||||
var/obj/machinery/embedded_controller/radio/docking_port_multi/controller = M
|
||||
//parse child_tags_txt and create child tags
|
||||
children_tags = splittext(controller.child_tags_txt, ";")
|
||||
|
||||
children_ready = list()
|
||||
children_override = list()
|
||||
for(var/child_tag in children_tags)
|
||||
children_ready[child_tag] = 0
|
||||
children_override[child_tag] = "disabled"
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/proc/clear_children_ready_status()
|
||||
for(var/child_tag in children_tags)
|
||||
children_ready[child_tag] = 0
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/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"] //the intended recipient of the docking signal
|
||||
|
||||
if(receive_tag in children_tags)
|
||||
|
||||
//track children status
|
||||
if(signal.data["override_status"])
|
||||
children_override[receive_tag] = signal.data["override_status"]
|
||||
|
||||
if(recipient == id_tag)
|
||||
switch(command)
|
||||
if("ready_for_docking")
|
||||
children_ready[receive_tag] = 1
|
||||
if("ready_for_undocking")
|
||||
children_ready[receive_tag] = 1
|
||||
if("status_override_enabled")
|
||||
children_override[receive_tag] = 1
|
||||
if("status_override_disabled")
|
||||
children_override[receive_tag] = 0
|
||||
|
||||
..(signal, receive_method, receive_param)
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/prepare_for_docking()
|
||||
//clear children ready status
|
||||
clear_children_ready_status()
|
||||
|
||||
//tell children to prepare for docking
|
||||
for(var/child_tag in children_tags)
|
||||
send_docking_command(child_tag, "prepare_for_docking")
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/ready_for_docking()
|
||||
//check children ready status
|
||||
for(var/child_tag in children_tags)
|
||||
if(!children_ready[child_tag])
|
||||
return 0
|
||||
return 1
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/finish_docking()
|
||||
//tell children to finish docking
|
||||
for(var/child_tag in children_tags)
|
||||
send_docking_command(child_tag, "finish_docking")
|
||||
|
||||
//clear ready flags
|
||||
clear_children_ready_status()
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/prepare_for_undocking()
|
||||
//clear children ready status
|
||||
clear_children_ready_status()
|
||||
|
||||
//tell children to prepare for undocking
|
||||
for(var/child_tag in children_tags)
|
||||
send_docking_command(child_tag, "prepare_for_undocking")
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/ready_for_undocking()
|
||||
//check children ready status
|
||||
for(var/child_tag in children_tags)
|
||||
if(!children_ready[child_tag])
|
||||
return 0
|
||||
return 1
|
||||
|
||||
/datum/computer/file/embedded_program/docking/multi/finish_undocking()
|
||||
//tell children to finish undocking
|
||||
for(var/child_tag in children_tags)
|
||||
send_docking_command(child_tag, "finish_undocking")
|
||||
|
||||
//clear ready flags
|
||||
clear_children_ready_status()
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
the child program
|
||||
technically should be "slave" but eh... I'm too politically correct.
|
||||
*/
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking
|
||||
var/master_tag
|
||||
|
||||
var/master_status = "undocked"
|
||||
var/override_enabled = 0
|
||||
var/docking_enabled = 0
|
||||
var/docking_mode = 0 //0 = docking, 1 = undocking
|
||||
var/response_sent = 0
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/New(var/obj/machinery/embedded_controller/M)
|
||||
..(M)
|
||||
|
||||
if(istype(M, /obj/machinery/embedded_controller/radio/airlock/docking_port_multi)) //if our parent controller is the right type, then we can auto-init stuff at construction
|
||||
var/obj/machinery/embedded_controller/radio/airlock/docking_port_multi/controller = M
|
||||
src.master_tag = controller.master_tag
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/receive_user_command(command)
|
||||
if(command == "toggle_override")
|
||||
if(override_enabled)
|
||||
override_enabled = 0
|
||||
broadcast_override_status()
|
||||
else
|
||||
override_enabled = 1
|
||||
broadcast_override_status()
|
||||
return
|
||||
|
||||
if(!docking_enabled|| 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/multi_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"] //the intended recipient of the docking signal
|
||||
|
||||
if(receive_tag != master_tag)
|
||||
return //only respond to master
|
||||
|
||||
//track master's status
|
||||
if(signal.data["dock_status"])
|
||||
master_status = signal.data["dock_status"]
|
||||
|
||||
if(recipient != id_tag)
|
||||
return //this signal is not for us
|
||||
|
||||
switch(command)
|
||||
if("prepare_for_docking")
|
||||
docking_enabled = 1
|
||||
docking_mode = 0
|
||||
response_sent = 0
|
||||
|
||||
if(!override_enabled)
|
||||
begin_cycle_in()
|
||||
|
||||
if("prepare_for_undocking")
|
||||
docking_mode = 1
|
||||
response_sent = 0
|
||||
|
||||
if(!override_enabled)
|
||||
stop_cycling()
|
||||
close_doors()
|
||||
disable_mech_regulation()
|
||||
|
||||
if("finish_docking")
|
||||
if(!override_enabled)
|
||||
enable_mech_regulation()
|
||||
open_doors()
|
||||
|
||||
if("finish_undocking")
|
||||
docking_enabled = 0
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/process()
|
||||
..()
|
||||
|
||||
if(docking_enabled && !response_sent)
|
||||
|
||||
switch(docking_mode)
|
||||
if(0) //docking
|
||||
if(ready_for_docking())
|
||||
send_signal_to_master("ready_for_docking")
|
||||
response_sent = 1
|
||||
if(1) //undocking
|
||||
if(ready_for_undocking())
|
||||
send_signal_to_master("ready_for_undocking")
|
||||
response_sent = 1
|
||||
|
||||
//checks if we are ready for docking
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/proc/ready_for_docking()
|
||||
return done_cycling()
|
||||
|
||||
//checks if we are ready for undocking
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/proc/ready_for_undocking()
|
||||
return check_doors_secured()
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/multi_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/multi_docking/cycleDoors(var/target)
|
||||
if(!docking_enabled|| override_enabled) //only allow the port to be used as an airlock if nothing is docked here or the override is enabled
|
||||
..(target)
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/proc/send_signal_to_master(var/command)
|
||||
var/datum/signal/signal = new
|
||||
signal.data["tag"] = id_tag
|
||||
signal.data["command"] = command
|
||||
signal.data["recipient"] = master_tag
|
||||
post_signal(signal)
|
||||
|
||||
/datum/computer/file/embedded_program/airlock/multi_docking/proc/broadcast_override_status()
|
||||
var/datum/signal/signal = new
|
||||
signal.data["tag"] = id_tag
|
||||
signal.data["override_status"] = override_enabled? "enabled" : "disabled"
|
||||
post_signal(signal)
|
||||
@@ -1,158 +0,0 @@
|
||||
//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/force_open = 1)
|
||||
var/data[0]
|
||||
|
||||
data = list(
|
||||
"docking_status" = docking_program.get_docking_status(),
|
||||
"override_enabled" = docking_program.override_enabled,
|
||||
"door_state" = docking_program.memory["door_status"]["state"],
|
||||
"door_lock" = docking_program.memory["door_status"]["lock"],
|
||||
)
|
||||
|
||||
ui = nanomanager.try_update_ui(user, src, ui_key, ui, data, force_open)
|
||||
|
||||
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 1
|
||||
|
||||
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 0
|
||||
|
||||
|
||||
//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
|
||||
|
||||
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? controller.tag_door : "[id_tag]_hatch"
|
||||
|
||||
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")
|
||||
|
||||
/*** 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()
|
||||
|
||||
*/
|
||||
Reference in New Issue
Block a user