mirror of
https://github.com/CHOMPStation2/CHOMPStation2.git
synced 2025-12-11 10:43:20 +00:00
246 lines
9.0 KiB
Plaintext
246 lines
9.0 KiB
Plaintext
|
|
#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. (Think server == station, client == shuttle)
|
|
|
|
/*
|
|
*** 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
|
|
When server is ready, sends confirm_dock
|
|
Client sends confirm_dock back
|
|
|
|
Undocking
|
|
Client sends request_undock
|
|
When server is ready, sends confirm_dock
|
|
Client sends confirm_dock back
|
|
|
|
Note that in both cases each side exchanges confirm_dock before the docking operation is considered done.
|
|
|
|
*** 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 plamsa/phoron 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/override_enabled = 0 //skips checks for the docking port being ready
|
|
var/received_confirm = 0 //for undocking, whether the client has recieved a confirmation from the server
|
|
|
|
/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
|
|
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)
|
|
received_confirm = 1
|
|
else if (control_mode == MODE_SERVER && dock_state == STATE_UNDOCKING && receive_tag == tag_target)
|
|
if (!override_enabled)
|
|
finish_undocking()
|
|
reset() //server is done undocking!
|
|
|
|
if ("request_undock")
|
|
if (control_mode == MODE_SERVER && dock_state == STATE_DOCKED && receive_tag == tag_target)
|
|
dock_state = STATE_UNDOCKING
|
|
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 (!response_sent)
|
|
send_docking_command(tag_target, "confirm_dock") //tell the other guy we're ready
|
|
response_sent = 1
|
|
|
|
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())
|
|
if (control_mode == MODE_CLIENT && received_confirm)
|
|
send_docking_command(tag_target, "confirm_undock") //tell the server we are done undocking.
|
|
if (!override_enabled)
|
|
finish_undocking()
|
|
reset() //client is done undocking!
|
|
else if (control_mode == MODE_SERVER)
|
|
send_docking_command(tag_target, "confirm_undock") //tell the client we are OK to undock.
|
|
|
|
|
|
|
|
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/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
|
|
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
|
|
control_mode = MODE_NONE
|
|
tag_target = null
|
|
response_sent = 0
|
|
received_confirm = 0
|
|
|
|
/datum/computer/file/embedded_program/docking/proc/force_undock()
|
|
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)
|
|
|
|
//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 |