mirror of
https://github.com/goonstation/goonstation-2016.git
synced 2026-05-18 06:29:01 +01:00
Tobba
291 lines
9.0 KiB
Plaintext
291 lines
9.0 KiB
Plaintext
//Singularity engine control program
|
|
#ifdef SINGULARITY_TIME
|
|
/datum/computer/file/terminal_program/engine_control
|
|
name = "EngineMaster"
|
|
size = 10
|
|
req_access = list(access_engineering_engine)
|
|
var/tmp/authenticated = null //Are we currently logged in?
|
|
var/datum/computer/file/user_data/account = null
|
|
var/log_string = null
|
|
var/obj/item/peripheral/network/powernet_card/netcard = null
|
|
var/obj/item/peripheral/network/radio/radiocard = null
|
|
var/tmp/task = null //What are we doing at the moment?
|
|
var/tmp/startup_line = 1
|
|
var/tmp/starting_up = 0 //Are we currently starting up?
|
|
var/list/emitter_ids = list() //Net ids of located emitters.
|
|
var/list/fieldgen_ids = list() //Net ids of located field generators.
|
|
var/tmp/last_event_report = 0 //When did we last report an event?
|
|
|
|
var/setup_acc_filepath = "/logs/sysusr"//Where do we look for login data?
|
|
var/setup_logdump_name = "englog"
|
|
var/setup_mail_freq = 1149 //Which freq do we report to?
|
|
var/setup_mailgroup = "engineer" //The PDA mailgroup used when alerting engineer pdas.
|
|
|
|
|
|
initialize()
|
|
|
|
src.authenticated = null
|
|
src.task = null
|
|
src.master.temp = null
|
|
src.startup_line = 1
|
|
|
|
if(!src.find_access_file()) //Find the account information, as it's essentially a ~digital ID card~
|
|
src.print_text("<b>Error:</b> Cannot locate user file. Quitting...")
|
|
src.master.unload_program(src) //Oh no, couldn't find the file.
|
|
return
|
|
if(!src.check_access(src.account.access))
|
|
src.print_text("User [src.account.registered] does not have needed access credentials.<br>Quitting...")
|
|
src.master.unload_program(src)
|
|
return
|
|
|
|
src.netcard = locate() in src.master.peripherals
|
|
if(!src.netcard || !istype(src.netcard))
|
|
src.print_text("<b>Error:</b> No network card detected.<br>Quitting...")
|
|
src.log_string += "<br>Startup Failure: No network card."
|
|
src.master.unload_program(src)
|
|
return
|
|
|
|
src.radiocard = locate() in src.master.peripherals
|
|
if(!radiocard || !istype(src.radiocard))
|
|
src.radiocard = null
|
|
src.print_text("<b>Warning:</b> No radio module detected.")
|
|
src.log_string += "<br>Startup Error: No radio."
|
|
|
|
src.authenticated = src.account.registered
|
|
src.log_string += "<br><b>LOGIN:</b> [src.authenticated]"
|
|
|
|
src.ping_devices()
|
|
|
|
var/intro_text = {"<br>EngineMaster
|
|
<br>Automated Engine Control System
|
|
<br><b>Commands:</b>
|
|
<br>(Startup) to activate engine systems.
|
|
<br>(Abort) to abort startup procedure.
|
|
<br>(Rescan) to rescan for engine devices.
|
|
<br>(Clear) to clear the screen.
|
|
<br>(Quit) to exit."}
|
|
src.print_text(intro_text)
|
|
|
|
return
|
|
|
|
input_text(text)
|
|
if(..())
|
|
return
|
|
|
|
var/list/command_list = parse_string(text)
|
|
var/command = command_list[1]
|
|
command_list -= command_list[1]
|
|
|
|
src.print_text(strip_html(text))
|
|
|
|
switch(lowertext(command))
|
|
|
|
if("startup")
|
|
//We're already starting, jeez give it some time
|
|
if(src.starting_up)
|
|
src.print_text("Startup already in progress.")
|
|
src.master.add_fingerprint(usr)
|
|
return
|
|
|
|
if(!emitter_ids || emitter_ids.len <= 0)
|
|
src.print_text("<b>Error:</b> Insufficient emitters detected.")
|
|
src.master.add_fingerprint(usr)
|
|
return
|
|
|
|
if(!fieldgen_ids || fieldgen_ids.len < 4)
|
|
src.print_text("<b>Error:</b> Insufficient field generators detected.")
|
|
src.master.add_fingerprint(usr)
|
|
return
|
|
|
|
src.startup_line = 1
|
|
src.starting_up = 1
|
|
src.task = "startup-emit"
|
|
src.log_string += "<br>Startup initiated."
|
|
src.report_event("Engine starting up...")
|
|
src.print_text("Startup procedure initiated.")
|
|
|
|
if("abort")
|
|
if(!src.starting_up)
|
|
src.print_text("No startup procedure in progress.")
|
|
src.master.add_fingerprint(usr)
|
|
return
|
|
|
|
src.startup_line = 1
|
|
src.task = null
|
|
src.starting_up = 0
|
|
src.log_string += "<br>Startup aborted."
|
|
src.print_text("Startup procedure aborted.")
|
|
|
|
if("rescan")
|
|
if((src.task && src.task != "scan") || src.starting_up)
|
|
src.print_text("Unable to scan, system is busy.")
|
|
return
|
|
|
|
src.ping_devices()
|
|
|
|
if("logdump")
|
|
if(!src.log_string) //Something is wrong.
|
|
src.print_text("<b>Error:</b> No log data to dump.")
|
|
return
|
|
|
|
if(src.holder.read_only)
|
|
src.print_text("<b>Error:</b> Destination drive is read-only.")
|
|
return
|
|
|
|
var/datum/computer/file/text/logdump = get_file_name(setup_logdump_name, src.holding_folder)
|
|
if(logdump && !istype(logdump) || get_folder_name(setup_logdump_name, src.holding_folder))
|
|
src.print_text("<b>Error:</b> Name in use.")
|
|
return
|
|
|
|
if(logdump && istype(logdump))
|
|
logdump.data = src.log_string
|
|
else
|
|
logdump = new /datum/computer/file/text
|
|
logdump.name = setup_logdump_name
|
|
logdump.data = src.log_string
|
|
if(!src.holding_folder.add_file(logdump))
|
|
//qdel(logdump)
|
|
logdump.dispose()
|
|
src.print_text("<b>Error:</b> Cannot save to disk.")
|
|
return
|
|
|
|
src.print_text("Log dumped to holding directory.")
|
|
|
|
if("clear")
|
|
src.master.temp = null
|
|
src.master.temp_add = "Workspace cleared.<br>"
|
|
|
|
if("quit")
|
|
src.log_string += "<br><b>LOGOUT:</b> [src.authenticated]"
|
|
src.print_text("Now quitting...")
|
|
src.master.unload_program(src)
|
|
return
|
|
|
|
else
|
|
src.print_text("Unknown command.")
|
|
|
|
src.master.add_fingerprint(usr)
|
|
src.master.updateUsrDialog()
|
|
return
|
|
|
|
process()
|
|
if(..() || !src.task)
|
|
return
|
|
|
|
switch(src.task)
|
|
if("startup-emit")
|
|
if(startup_line > src.emitter_ids.len)
|
|
src.task = "startup-field"
|
|
src.startup_line = 1
|
|
return
|
|
|
|
post_status(src.emitter_ids[src.startup_line], "command", "activate")
|
|
src.startup_line++
|
|
|
|
if("startup-field")
|
|
if(startup_line > src.fieldgen_ids.len)
|
|
src.task = null
|
|
src.startup_line = 1
|
|
src.starting_up = 0
|
|
src.print_text("Startup procedure complete.")
|
|
return
|
|
|
|
post_status(src.fieldgen_ids[src.startup_line], "command", "activate")
|
|
src.startup_line++
|
|
|
|
receive_command(obj/source, command, datum/signal/signal)
|
|
if((..()) || !signal)
|
|
return
|
|
|
|
//Time to populate our lists of components.
|
|
if(signal.data["command"] == "ping_reply" && (src.task == "scan"))
|
|
if(!signal.data["netid"])
|
|
return
|
|
|
|
switch(signal.data["device"])
|
|
if("PNET_ENG_EMITR") //Oh hey a new emitter.
|
|
if(!(signal.data["netid"] in src.emitter_ids))
|
|
src.emitter_ids += signal.data["netid"]
|
|
if("PNET_ENG_FIELD")
|
|
if(!(signal.data["netid"] in src.fieldgen_ids))
|
|
src.fieldgen_ids += signal.data["netid"]
|
|
else
|
|
return
|
|
|
|
return
|
|
|
|
proc
|
|
ping_devices()
|
|
if(!src.netcard)
|
|
return
|
|
src.task = "scan"
|
|
src.emitter_ids = new
|
|
src.fieldgen_ids = new
|
|
|
|
var/datum/signal/newsignal = get_free_signal()
|
|
//newsignal.encryption = "\ref[src.netcard]"
|
|
|
|
src.log_string += "<br>Scanning for devices..."
|
|
src.print_text("Scanning for devices...")
|
|
src.peripheral_command("ping", newsignal, "\ref[src.netcard]")
|
|
|
|
return
|
|
|
|
post_status(var/target_id, var/key, var/value, var/key2, var/value2, var/key3, var/value3)
|
|
if(!src.netcard)
|
|
return
|
|
|
|
var/datum/signal/signal = get_free_signal()
|
|
|
|
//signal.encryption = "\ref[src.netcard]"
|
|
signal.data[key] = value
|
|
if(key2)
|
|
signal.data[key2] = value2
|
|
if(key3)
|
|
signal.data[key3] = value3
|
|
|
|
signal.data["address_1"] = target_id
|
|
src.peripheral_command("transmit", signal, "\ref[src.netcard]")
|
|
|
|
report_event(var/event_string)
|
|
if(!event_string || !src.radiocard)
|
|
return
|
|
|
|
//Unlikely that this would be a problem but OH WELL
|
|
if(last_event_report && world.time < (last_event_report + 10))
|
|
return
|
|
|
|
//Set card frequency if it isn't already.
|
|
if(src.radiocard.frequency != src.setup_mail_freq && !src.radiocard.setup_freq_locked)
|
|
var/datum/signal/freqsignal = get_free_signal()
|
|
//freqsignal.encryption = "\ref[src.radiocard]"
|
|
peripheral_command("[src.setup_mail_freq]", freqsignal,"\ref[src.radiocard]")
|
|
src.log_string += "<br>Adjusting frequency... \[[src.setup_mail_freq]]."
|
|
|
|
var/datum/signal/signal = get_free_signal()
|
|
//signal.encryption = "\ref[src.radiocard]"
|
|
|
|
//Create a PDA mass-message string.
|
|
signal.data["address_1"] = "00000000"
|
|
signal.data["command"] = "text_message"
|
|
signal.data["sender_name"] = "ENGINE-MAILBOT"
|
|
signal.data["group"] = src.setup_mailgroup //Only engineer PDAs should be informed.
|
|
signal.data["message"] = "Notice: [event_string]"
|
|
|
|
src.log_string += "<br>Event notification sent."
|
|
last_event_report = world.time
|
|
peripheral_command("transmit", signal, "\ref[src.radiocard]")
|
|
return
|
|
|
|
find_access_file() //Look for the whimsical account_data file
|
|
var/datum/computer/folder/accdir = src.holder.root
|
|
if(src.master.host_program) //Check where the OS is, preferably.
|
|
accdir = src.master.host_program.holder.root
|
|
|
|
var/datum/computer/file/user_data/target = parse_file_directory(setup_acc_filepath, accdir)
|
|
if(target && istype(target))
|
|
src.account = target
|
|
return 1
|
|
|
|
return 0
|
|
#endif |