[REVIEW] Ports Modular Computers from Baystation

code/modules/modular_computers/NTNet/NTNRC/conversation.dm

@@ -0,0 +1,65 @@
+var/global/ntnrc_uid = 0
+
+/datum/ntnet_conversation/
+	var/id = null
+	var/title = "Untitled Conversation"
+	var/datum/computer_file/program/chatclient/operator // "Administrator" of this channel. Creator starts as channel's operator,
+	var/list/messages = list()
+	var/list/clients = list()
+	var/password
+
+/datum/ntnet_conversation/New()
+	id = ntnrc_uid
+	ntnrc_uid++
+	if(ntnet_global)
+		ntnet_global.chat_channels.Add(src)
+	..()
+
+/datum/ntnet_conversation/proc/add_message(var/message, var/username)
+	message = "[stationtime2text()] [username]: [message]"
+	messages.Add(message)
+	trim_message_list()
+
+/datum/ntnet_conversation/proc/add_status_message(var/message)
+	messages.Add("[stationtime2text()] -!- [message]")
+	trim_message_list()
+
+/datum/ntnet_conversation/proc/trim_message_list()
+	if(messages.len <= 50)
+		return
+	messages.Cut(1, (messages.len-49))
+
+/datum/ntnet_conversation/proc/add_client(var/datum/computer_file/program/chatclient/C)
+	if(!istype(C))
+		return
+	clients.Add(C)
+	add_status_message("[C.username] has joined the channel.")
+	// No operator, so we assume the channel was empty. Assign this user as operator.
+	if(!operator)
+		changeop(C)
+
+/datum/ntnet_conversation/proc/remove_client(var/datum/computer_file/program/chatclient/C)
+	if(!istype(C) || !(C in clients))
+		return
+	clients.Remove(C)
+	add_status_message("[C.username] has left the channel.")
+
+	// Channel operator left, pick new operator
+	if(C == operator)
+		operator = null
+		if(clients.len)
+			var/datum/computer_file/program/chatclient/newop = pick(clients)
+			changeop(newop)
+
+
+/datum/ntnet_conversation/proc/changeop(var/datum/computer_file/program/chatclient/newop)
+	if(istype(newop))
+		operator = newop
+		add_status_message("Channel operator status transferred to [newop.username].")
+
+/datum/ntnet_conversation/proc/change_title(var/newtitle, var/datum/computer_file/program/chatclient/client)
+	if(operator != client)
+		return 0 // Not Authorised
+
+	add_status_message("[client.username] has changed channel title from [title] to [newtitle]")
+	title = newtitle

code/modules/modular_computers/NTNet/NTNet.dm

@@ -0,0 +1,184 @@
+var/global/datum/ntnet/ntnet_global = new()
+
+
+// This is the NTNet datum. There can be only one NTNet datum in game at once. Modular computers read data from this.
+/datum/ntnet/
+	var/list/relays = list()
+	var/list/logs = list()
+	var/list/available_station_software = list()
+	var/list/available_antag_software = list()
+	var/list/available_news = list()
+	var/list/chat_channels = list()
+	var/list/fileservers = list()
+	var/list/email_accounts = list()				// I guess we won't have more than 999 email accounts active at once in single round, so this will do until Servers are implemented someday.
+	var/list/banned_nids = list()
+	// Amount of logs the system tries to keep in memory. Keep below 999 to prevent byond from acting weirdly.
+	// High values make displaying logs much laggier.
+	var/setting_maxlogcount = 100
+
+	// These only affect wireless. LAN (consoles) are unaffected since it would be possible to create scenario where someone turns off NTNet, and is unable to turn it back on since it refuses connections
+	var/setting_softwaredownload = 1
+	var/setting_peertopeer = 1
+	var/setting_communication = 1
+	var/setting_systemcontrol = 1
+	var/setting_disabled = 0					// Setting to 1 will disable all wireless, independently on relays status.
+
+	var/intrusion_detection_enabled = 1 		// Whether the IDS warning system is enabled
+	var/intrusion_detection_alarm = 0			// Set when there is an IDS warning due to malicious (antag) software.
+
+
+// If new NTNet datum is spawned, it replaces the old one.
+/datum/ntnet/New()
+	if(ntnet_global && (ntnet_global != src))
+		ntnet_global = src // There can be only one.
+	for(var/obj/machinery/ntnet_relay/R in machines)
+		relays.Add(R)
+		R.NTNet = src
+	build_software_lists()
+	build_news_list()
+	build_emails_list()
+	add_log("NTNet logging system activated.")
+
+/datum/ntnet/proc/add_log_with_ids_check(var/log_string, var/obj/item/weapon/computer_hardware/network_card/source = null)
+	if(intrusion_detection_enabled)
+		add_log(log_string, source)
+
+// Simplified logging: Adds a log. log_string is mandatory parameter, source is optional.
+/datum/ntnet/proc/add_log(var/log_string, var/obj/item/weapon/computer_hardware/network_card/source = null)
+	var/log_text = "[stationtime2text()] - "
+	if(source)
+		log_text += "[source.get_network_tag()] - "
+	else
+		log_text += "*SYSTEM* - "
+	log_text += log_string
+	logs.Add(log_text)
+
+	if(logs.len > setting_maxlogcount)
+		// We have too many logs, remove the oldest entries until we get into the limit
+		for(var/L in logs)
+			if(logs.len > setting_maxlogcount)
+				logs.Remove(L)
+			else
+				break
+
+/datum/ntnet/proc/check_banned(var/NID)
+	if(!relays || !relays.len)
+		return FALSE
+
+	for(var/obj/machinery/ntnet_relay/R in relays)
+		if(R.operable())
+			return (NID in banned_nids)
+
+	return FALSE
+
+// Checks whether NTNet operates. If parameter is passed checks whether specific function is enabled.
+/datum/ntnet/proc/check_function(var/specific_action = 0)
+	if(!relays || !relays.len) // No relays found. NTNet is down
+		return 0
+
+	var/operating = 0
+
+	// Check all relays. If we have at least one working relay, network is up.
+	for(var/obj/machinery/ntnet_relay/R in relays)
+		if(R.operable())
+			operating = 1
+			break
+
+	if(setting_disabled)
+		return 0
+
+	if(specific_action == NTNET_SOFTWAREDOWNLOAD)
+		return (operating && setting_softwaredownload)
+	if(specific_action == NTNET_PEERTOPEER)
+		return (operating && setting_peertopeer)
+	if(specific_action == NTNET_COMMUNICATION)
+		return (operating && setting_communication)
+	if(specific_action == NTNET_SYSTEMCONTROL)
+		return (operating && setting_systemcontrol)
+	return operating
+
+// Builds lists that contain downloadable software.
+/datum/ntnet/proc/build_software_lists()
+	available_station_software = list()
+	available_antag_software = list()
+	for(var/F in typesof(/datum/computer_file/program))
+		var/datum/computer_file/program/prog = new F
+		// Invalid type (shouldn't be possible but just in case), invalid filetype (not executable program) or invalid filename (unset program)
+		if(!prog || !istype(prog) || prog.filename == "UnknownProgram" || prog.filetype != "PRG")
+			continue
+		// Check whether the program should be available for station/antag download, if yes, add it to lists.
+		if(prog.available_on_ntnet)
+			available_station_software.Add(prog)
+		if(prog.available_on_syndinet)
+			available_antag_software.Add(prog)
+
+// Builds lists that contain downloadable software.
+/datum/ntnet/proc/build_news_list()
+	available_news = list()
+	for(var/F in typesof(/datum/computer_file/data/news_article/))
+		var/datum/computer_file/data/news_article/news = new F(1)
+		if(news.stored_data)
+			available_news.Add(news)
+
+// Generates service email list. Currently only used by broadcaster service
+/datum/ntnet/proc/build_emails_list()
+	for(var/F in subtypesof(/datum/computer_file/data/email_account/service))
+		new F()
+
+// Attempts to find a downloadable file according to filename var
+/datum/ntnet/proc/find_ntnet_file_by_name(var/filename)
+	for(var/datum/computer_file/program/P in available_station_software)
+		if(filename == P.filename)
+			return P
+	for(var/datum/computer_file/program/P in available_antag_software)
+		if(filename == P.filename)
+			return P
+
+// Resets the IDS alarm
+/datum/ntnet/proc/resetIDS()
+	intrusion_detection_alarm = 0
+
+/datum/ntnet/proc/toggleIDS()
+	resetIDS()
+	intrusion_detection_enabled = !intrusion_detection_enabled
+
+// Removes all logs
+/datum/ntnet/proc/purge_logs()
+	logs = list()
+	add_log("-!- LOGS DELETED BY SYSTEM OPERATOR -!-")
+
+// Updates maximal amount of stored logs. Use this instead of setting the number, it performs required checks.
+/datum/ntnet/proc/update_max_log_count(var/lognumber)
+	if(!lognumber)
+		return 0
+	// Trim the value if necessary
+	lognumber = between(MIN_NTNET_LOGS, lognumber, MAX_NTNET_LOGS)
+	setting_maxlogcount = lognumber
+	add_log("Configuration Updated. Now keeping [setting_maxlogcount] logs in system memory.")
+
+/datum/ntnet/proc/toggle_function(var/function)
+	if(!function)
+		return
+	function = text2num(function)
+	switch(function)
+		if(NTNET_SOFTWAREDOWNLOAD)
+			setting_softwaredownload = !setting_softwaredownload
+			add_log("Configuration Updated. Wireless network firewall now [setting_softwaredownload ? "allows" : "disallows"] connection to software repositories.")
+		if(NTNET_PEERTOPEER)
+			setting_peertopeer = !setting_peertopeer
+			add_log("Configuration Updated. Wireless network firewall now [setting_peertopeer ? "allows" : "disallows"] peer to peer network traffic.")
+		if(NTNET_COMMUNICATION)
+			setting_communication = !setting_communication
+			add_log("Configuration Updated. Wireless network firewall now [setting_communication ? "allows" : "disallows"] instant messaging and similar communication services.")
+		if(NTNET_SYSTEMCONTROL)
+			setting_systemcontrol = !setting_systemcontrol
+			add_log("Configuration Updated. Wireless network firewall now [setting_systemcontrol ? "allows" : "disallows"] remote control of station's systems.")
+
+/datum/ntnet/proc/does_email_exist(var/login)
+	for(var/datum/computer_file/data/email_account/A in ntnet_global.email_accounts)
+		if(A.login == login)
+			return 1
+	return 0
+
+
+

code/modules/modular_computers/NTNet/NTNet_relay.dm

@@ -0,0 +1,136 @@
+// Relays don't handle any actual communication. Global NTNet datum does that, relays only tell the datum if it should or shouldn't work.
+/obj/machinery/ntnet_relay
+	name = "NTNet Quantum Relay"
+	desc = "A very complex router and transmitter capable of connecting electronic devices together. Looks fragile."
+	use_power = 2
+	active_power_usage = 20000 //20kW, apropriate for machine that keeps massive cross-Zlevel wireless network operational.
+	idle_power_usage = 100
+	icon_state = "bus"
+	anchored = 1
+	density = 1
+	var/datum/ntnet/NTNet = null // This is mostly for backwards reference and to allow varedit modifications from ingame.
+	var/enabled = 1				// Set to 0 if the relay was turned off
+	var/dos_failure = 0			// Set to 1 if the relay failed due to (D)DoS attack
+	var/list/dos_sources = list()	// Backwards reference for qdel() stuff
+
+	// Denial of Service attack variables
+	var/dos_overload = 0		// Amount of DoS "packets" in this relay's buffer
+	var/dos_capacity = 500		// Amount of DoS "packets" in buffer required to crash the relay
+	var/dos_dissipate = 1		// Amount of DoS "packets" dissipated over time.
+
+
+// TODO: Implement more logic here. For now it's only a placeholder.
+/obj/machinery/ntnet_relay/operable()
+	if(!..(EMPED))
+		return 0
+	if(dos_failure)
+		return 0
+	if(!enabled)
+		return 0
+	return 1
+
+/obj/machinery/ntnet_relay/update_icon()
+	if(operable())
+		icon_state = "bus"
+	else
+		icon_state = "bus_off"
+
+/obj/machinery/ntnet_relay/process()
+	if(operable())
+		use_power = 2
+	else
+		use_power = 1
+
+	if(dos_overload)
+		dos_overload = max(0, dos_overload - dos_dissipate)
+
+	// If DoS traffic exceeded capacity, crash.
+	if((dos_overload > dos_capacity) && !dos_failure)
+		dos_failure = 1
+		update_icon()
+		ntnet_global.add_log("Quantum relay switched from normal operation mode to overload recovery mode.")
+	// If the DoS buffer reaches 0 again, restart.
+	if((dos_overload == 0) && dos_failure)
+		dos_failure = 0
+		update_icon()
+		ntnet_global.add_log("Quantum relay switched from overload recovery mode to normal operation mode.")
+	..()
+
+/obj/machinery/ntnet_relay/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = list()
+	data["enabled"] = enabled
+	data["dos_capacity"] = dos_capacity
+	data["dos_overload"] = dos_overload
+	data["dos_crashed"] = dos_failure
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "ntnet_relay.tmpl", "NTNet Quantum Relay", 500, 300, state = state)
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+/obj/machinery/ntnet_relay/attack_hand(var/mob/living/user)
+	ui_interact(user)
+
+/obj/machinery/ntnet_relay/Topic(href, href_list)
+	if(..())
+		return 1
+	if(href_list["restart"])
+		dos_overload = 0
+		dos_failure = 0
+		update_icon()
+		ntnet_global.add_log("Quantum relay manually restarted from overload recovery mode to normal operation mode.")
+		return 1
+	else if(href_list["toggle"])
+		enabled = !enabled
+		ntnet_global.add_log("Quantum relay manually [enabled ? "enabled" : "disabled"].")
+		update_icon()
+		return 1
+	else if(href_list["purge"])
+		ntnet_global.banned_nids.Cut()
+		ntnet_global.add_log("Manual override: Network blacklist cleared.")
+		return 1
+
+/obj/machinery/ntnet_relay/New()
+	uid = gl_uid
+	gl_uid++
+	component_parts = list()
+	component_parts += new /obj/item/stack/cable_coil(src,15)
+	component_parts += new /obj/item/weapon/circuitboard/ntnet_relay(src)
+
+	if(ntnet_global)
+		ntnet_global.relays.Add(src)
+		NTNet = ntnet_global
+		ntnet_global.add_log("New quantum relay activated. Current amount of linked relays: [NTNet.relays.len]")
+	..()
+
+/obj/machinery/ntnet_relay/Destroy()
+	if(ntnet_global)
+		ntnet_global.relays.Remove(src)
+		ntnet_global.add_log("Quantum relay connection severed. Current amount of linked relays: [NTNet.relays.len]")
+		NTNet = null
+	for(var/datum/computer_file/program/ntnet_dos/D in dos_sources)
+		D.target = null
+		D.error = "Connection to quantum relay severed"
+	..()
+
+/obj/machinery/ntnet_relay/attackby(var/obj/item/weapon/W as obj, var/mob/user as mob)
+	if(W.is_screwdriver())
+		playsound(src.loc, 'sound/items/Screwdriver.ogg', 50, 1)
+		panel_open = !panel_open
+		to_chat(user, "You [panel_open ? "open" : "close"] the maintenance hatch")
+		return
+	if(W.is_crowbar())
+		if(!panel_open)
+			to_chat(user, "Open the maintenance panel first.")
+			return
+		playsound(src.loc, 'sound/items/Crowbar.ogg', 50, 1)
+		to_chat(user, "You disassemble \the [src]!")
+
+		for(var/atom/movable/A in component_parts)
+			A.forceMove(src.loc)
+		new /obj/structure/frame(src.loc)
+		qdel(src)
+		return
+	..()

code/modules/modular_computers/NTNet/emails/email_account.dm

@@ -0,0 +1,82 @@
+/datum/computer_file/data/email_account/
+	var/list/inbox = list()
+	var/list/spam = list()
+	var/list/deleted = list()
+
+	var/login = ""
+	var/password = ""
+	var/can_login = TRUE	// Whether you can log in with this account. Set to false for system accounts
+	var/suspended = FALSE	// Whether the account is banned by the SA.
+
+/datum/computer_file/data/email_account/calculate_size()
+	size = 1
+	for(var/datum/computer_file/data/email_message/stored_message in all_emails())
+		stored_message.calculate_size()
+		size += stored_message.size
+
+/datum/computer_file/data/email_account/New()
+	ntnet_global.email_accounts.Add(src)
+	..()
+
+/datum/computer_file/data/email_account/Destroy()
+	ntnet_global.email_accounts.Remove(src)
+	. = ..()
+
+/datum/computer_file/data/email_account/proc/all_emails()
+	return (inbox | spam | deleted)
+
+/datum/computer_file/data/email_account/proc/send_mail(var/recipient_address, var/datum/computer_file/data/email_message/message, var/relayed = 0)
+	var/datum/computer_file/data/email_account/recipient
+	for(var/datum/computer_file/data/email_account/account in ntnet_global.email_accounts)
+		if(account.login == recipient_address)
+			recipient = account
+			break
+
+	if(!istype(recipient))
+		return 0
+
+	if(!recipient.receive_mail(message, relayed))
+		return
+
+	ntnet_global.add_log_with_ids_check("EMAIL LOG: [login] -> [recipient.login] title: [message.title].")
+	return 1
+
+/datum/computer_file/data/email_account/proc/receive_mail(var/datum/computer_file/data/email_message/received_message, var/relayed)
+	received_message.set_timestamp()
+	if(!ntnet_global.intrusion_detection_enabled)
+		inbox.Add(received_message)
+		return 1
+	// Spam filters may occassionally let something through, or mark something as spam that isn't spam.
+	if(received_message.spam)
+		if(prob(98))
+			spam.Add(received_message)
+		else
+			inbox.Add(received_message)
+	else
+		if(prob(1))
+			spam.Add(received_message)
+		else
+			inbox.Add(received_message)
+	return 1
+
+// Address namespace (@internal-services.nt) for email addresses with special purpose only!.
+/datum/computer_file/data/email_account/service/
+	can_login = FALSE
+
+/datum/computer_file/data/email_account/service/broadcaster/
+	login = "broadcast@internal-services.nt"
+
+/datum/computer_file/data/email_account/service/broadcaster/receive_mail(var/datum/computer_file/data/email_message/received_message, var/relayed)
+	if(!istype(received_message) || relayed)
+		return 0
+	// Possibly exploitable for user spamming so keep admins informed.
+	if(!received_message.spam)
+		log_and_message_admins("Broadcast email address used by [usr]. Message title: [received_message.title].")
+
+	spawn(0)
+		for(var/datum/computer_file/data/email_account/email_account in ntnet_global.email_accounts)
+			var/datum/computer_file/data/email_message/new_message = received_message.clone()
+			send_mail(email_account.login, new_message, 1)
+			sleep(2)
+
+	return 1

code/modules/modular_computers/NTNet/emails/email_message.dm

@@ -0,0 +1,32 @@
+// Currently not actually represented in file systems, though the support for it is in place already.
+/datum/computer_file/data/email_message/
+	stored_data = ""
+	var/title = ""
+	var/source = ""
+	var/spam = FALSE
+	var/timestamp = ""
+	var/datum/computer_file/attachment = null
+
+/datum/computer_file/data/email_message/clone()
+	var/datum/computer_file/data/email_message/temp = ..()
+	temp.title = title
+	temp.source = source
+	temp.spam = spam
+	temp.timestamp = timestamp
+	if(attachment)
+		temp.attachment = attachment.clone()
+	return temp
+
+
+// Turns /email_message/ file into regular /data/ file.
+/datum/computer_file/data/email_message/proc/export()
+	var/datum/computer_file/data/dat = new/datum/computer_file/data()
+	dat.stored_data =  "Received from [source] at [timestamp]."
+	dat.stored_data += "\[b\][title]\[/b\]"
+	dat.stored_data += stored_data
+	dat.calculate_size()
+	return dat
+
+/datum/computer_file/data/email_message/proc/set_timestamp()
+	timestamp = stationtime2text()
+

code/modules/modular_computers/_description.dm

@@ -0,0 +1,121 @@
+/*
+Program-based computers, designed to replace computer3 project and eventually most consoles on station
+
+
+1. Basic information
+Program based computers will allow you to do multiple things from single computer. Each computer will have programs, with more being downloadable from NTNet (stationwide network with wireless coverage)
+if user has apropriate ID card access. It will be possible to hack the computer by using an emag on it - the emag will have to be completely new and will be consumed on use, but it will
+lift ALL locks on ALL installed programs, and allow download of programs even if your ID doesn't have access to them. Computers will have hard drives that can store files.
+Files can be programs (datum/computer_file/program/ subtype) or data files (datum/computer_file/data/ subtypes). Program for sending files will be available that will allow transfer via NTNet.
+NTNet coverage will be limited to station's Z level, but better network card (=more expensive and higher power use) will allow usage everywhere. Hard drives will have limited capacity for files
+which will be related to how good hard drive you buy when purchasing the laptop. For storing more files USB-style drives will be buildable with Protolathe in research.
+
+2. Available devices
+CONSOLES
+Consoles will come in various pre-fabricated loadouts, each loadout starting with certain set of programs (aka Engineering console, Medical console, etc.), of course, more software may be downloaded.
+Consoles won't usually have integrated battery, but the possibility to install one will exist for critical applications. Consoles are considered hardwired into NTNet network which means they
+will have working coverage on higher speed (Ethernet is faster than Wi-Fi) and won't require wireless coverage to exist.
+LAPTOPS
+Laptops are middle ground between actual portable devices and full consoles. They offer certain level of mobility, as they can be closed, moved somewhere else and then opened again.
+Laptops will by default have internal battery to power them, and may be recharged with rechargers. However, laptops rely on wireless NTNet coverage. Laptop HDDs are also designed with power efficiency
+in mind, which means they sacrifice some storage space for higher battery life. Laptops may be dispensed from computer vendor machine, and may be customised before vending. For people which don't
+want to rely on internal battery, tesla link exists that connects to APC, if one exists.
+TABLETS
+Tablets are smallest available devices, designed with full mobility in mind. Tablets have only weak CPU which means the software they can run is somewhat limited. They are also designed with high
+battery life in mind, which means the hardware focuses on power efficiency rather than high performance. This is most visible with hard drives which have quite small storage capacity.
+Tablets can't be equipped with tesla link, which means they have to be recharged manually.
+
+
+3. Computer Hardware
+Computers will come with basic hardware installed, with upgrades being selectable when purchasing the device.
+Hard Drive: Stores data, mandatory for the computer to work
+Network Card: Connects to NTNet
+Battery: Internal power source that ensures the computer operates when not connected to APC.
+Extras (those won't be installed by default, but can be bought)
+ID Card Slot: Required for HoP-style programs to work. Access for security record-style programs is read from ID of user [RFID?] without requiring this
+APC Tesla Relay: Wirelessly powers the device from APC. Consoles have it by default. Laptops can buy it.
+Disk Drive: Allows usage of portable data disks.
+Nano Printer: Allows the computer to scan paper contents and save them to file, as well as recycle papers and print stuff on it.
+
+4. NTNet
+NTNet is stationwide network that allows users to download programs needed for their work. It will be possible to send any files to other active computers using relevant program (NTN Transfer).
+NTNet is under jurisdiction of both Engineering and Research. Engineering is responsible for any repairs if necessary and research is responsible for monitoring. It is similar to PDA messaging.
+Operation requires functional "NTNet Relay" which is by default placed on tcommsat. If the relay is damaged NTNet will be offline until it is replaced. Multiple relays bring extra redundancy,
+if one is destroyed the second will take over. If all relays are gone it stops working, simple as that. NTNet may be altered via administration console available to Research Director. It is
+possible to enable/disable Software Downloading, P2P file transfers and Communication (IC version of IRC, PDA messages for more than two people)
+
+5. Software
+Software would almost exclusively use NanoUI modules. Few exceptions are text editor (uses similar screen as TCS IDE used for editing and classic HTML for previewing as Nano looks differently)
+and similar programs which for some reason require HTML UI. Most software will be highly dependent on NTNet to work as laptops are not physically connected to the station's network.
+What i plan to add:
+
+Note: XXXXDB programs will use ingame_manuals to display basic help for players, similar to how books, etc. do
+
+Basic - Software in this bundle is automagically preinstalled in every new computer
+	NTN Transfer - Allows P2P transfer of files to other computers that run this.
+	Configurator - Allows configuration of computer's hardware, basically status screen.
+	File Browser - Allows you to browse all files stored on the computer. Allows renaming/deleting of files.
+	TXT Editor - Allows you editing data files in text editor mode.
+	NanoPrint - Allows you to operate NanoPrinter hardware to print text files.
+	NTNRC Chat - NTNet Relay Chat client. Allows PDA-messaging style messaging for more than two users. Person which created the conversation is Host and has administrative privilegies (kicking, etc.)
+	NTNet News - Allows reading news from newscaster network.
+
+Engineering - Requires "Engineering" access on ID card (ie. CE, Atmostech, Engineer)
+	Alarm Monitor - Allows monitoring alarms, same as the stationbound one.
+	Power Monitor - Power monitoring computer, connects to sensors in same way as regular one does.
+	Atmospheric Control - Allows access to the Atmospherics Monitor Console that operates air alarms. Requires extra access: "Atmospherics"
+	RCON Remote Control Console - Allows access to the RCON Remote Control Console. Requires extra access: "Power Equipment"
+	EngiDB - Allows accessing NTNet information repository for information about engineering-related things.
+
+Medical - Requires "Medbay" access on ID card (ie. CMO, Doctor,..)
+	Medical Records Uplink - Allows editing/reading of medical records. Printing requires NanoPrinter hardware.
+	MediDB - Allows accessing NTNet information repository for information about medical procedures
+	ChemDB - Requires extra access: "Chemistry" - Downloads basic information about recipes from NTNet
+
+Research - Requires "Research and Development" access on ID card (ie. RD, Roboticist, etc.)
+	Research Server Monitor - Allows monitoring of research levels on RnD servers. (read only)
+	Robotics Monitor Console - Allows monitoring of robots and exosuits. Lockdown/Self-Destruct options are unavailable [balance reasons for malf/traitor AIs]. Requires extra access: "Robotics"
+	NTNRC Administration Console - Allows administrative access to NTNRC. This includes bypassing any channel passwords and enabling "invisible" mode for spying on conversations. Requires extra access: "Research Director"
+	NTNet Administration Console - Allows remote configuration of NTNet Relay - CAUTION: If NTNet is turned off it won't be possible to turn it on again from the computer, as operation requires NTNet to work! Requires extra access: "Research Director"
+	NTNet Monitor - Allows monitoring of NTNet and it's various components, including simplified network logs and system status.
+
+Security - Requires "Security" access on ID card (ie. HOS, Security officer, Detective)
+	Security Records Uplink - Allows editing/reading of security records. Printing requires Nanoprinter hardware.
+	LawDB - Allows accessing NTNet information repository for security information (corporate regulations)
+	Camera Uplink - Allows viewing cameras around the station.
+
+Command - Requires "Bridge" access on ID card (all heads)
+	Alertcon Access - Allows changing of alert levels. Red requires activation from two computers with two IDs similar to how those wall mounted devices do.
+	Employment Records Access - Allows reading of employment records. Printing requires NanoPrinter hardware.
+	Communication Console - Allows sending emergency messages to Central.
+	Emergency Shuttle Control Console - Allows calling/recalling the emergency shuttle.
+	Shuttle Control Console - Allows control of various shuttles around the station (mining, research, engineering)
+
+*REDACTED* - Can be downloaded from SyndiCorp servers, only via emagged devices. These files are very large and limited to laptops/consoles only.
+	SYSCRACK - Allows cracking of secure network terminals, such as, NTNet administration. The sysadmin will probably notice this.
+	SYSOVERRIDE - Allows hacking into any device connected to NTNet. User will notice this and may stop the hack by disconnecting from NTNet first. After hacking various options exist, such as stealing/deleting files.
+	SYSKILL - Tricks NTNet to force-disconnect a device. The sysadmin will probably notice this.
+	SYSDOS - Launches a Denial of Service attack on NTNet relay. Can DoS only one relay at once. Requires NTNet connection. After some time the relay crashes until attack stops. The sysadmin will probably notice this.
+	AIHACK - Hacks an AI, allowing you to upload/remove/modify a law even without relevant circuit board. The AI is alerted once the hack starts, and it takes a while for it to complete. Does not work on AIs with zeroth law.
+	COREPURGE - Deletes all files on the hard drive, including the undeletable ones. Something like software self-destruct for computer.
+
+6. Security
+Laptops will be password-lockable. If password is set a MD5 hash of it is stored and password is required every time you turn on the laptop.
+Passwords may be decrypted by using special Decrypter (protolathable, RDs office starts with one) device that will slowly decrypt the password.
+Decryption time would be length_of_password * 30 seconds, with maximum being 9 minutes (due to battery life limitations, which is 10+ min).
+If decrypted the password is cleared, so you can keep using your favorite password without people ever actually revealing it (for meta prevention reasons mostly).
+Emagged laptops will have option to enable "Safe Encryption". If safely encrypted laptop is decrypted it loses it's emag status and 50% of files is deleted (randomly selected).
+
+7. System Administrator
+System Administrator will be new job under Research. It's main specifics will be maintaining of computer systems on station, espicially from software side.
+From IC perspective they'd probably know how to build a console or something given they work with computers, but they are mostly programmers/network experts.
+They will have office in research, which will probably replace (and contain) the server room and part of the toxins storage which is currently oversized.
+They will have access to DOWNLOAD (not run) all programs that exist on NTNet. They'll have fairly good amount of available programs, most of them being
+administrative consoles and other very useful things. They'll also be able to monitor NTNet. There will probably be one or two job slots.
+
+8. IDS
+With addition of various antag programs, IDS(Intrusion Detection System) will be added to NTNet. This system can be turned on/off via administration console.
+If enabled, this system automatically detects any abnormality and triggers a warning that's visible on the NTNet status screen, as well as generating a security log.
+IDS can be disabled by simple on/off switch in the configuration.
+
+*/

code/modules/modular_computers/computers/modular_computer/core.dm

@@ -0,0 +1,269 @@
+/obj/item/modular_computer/process()
+	if(!enabled) // The computer is turned off
+		last_power_usage = 0
+		return 0
+
+	if(damage > broken_damage)
+		shutdown_computer()
+		return 0
+
+	if(active_program && active_program.requires_ntnet && !get_ntnet_status(active_program.requires_ntnet_feature)) // Active program requires NTNet to run but we've just lost connection. Crash.
+		active_program.event_networkfailure(0)
+
+	for(var/datum/computer_file/program/P in idle_threads)
+		if(P.requires_ntnet && !get_ntnet_status(P.requires_ntnet_feature))
+			P.event_networkfailure(1)
+
+	if(active_program)
+		if(active_program.program_state != PROGRAM_STATE_KILLED)
+			active_program.ntnet_status = get_ntnet_status()
+			active_program.computer_emagged = computer_emagged
+			active_program.process_tick()
+		else
+			active_program = null
+
+	for(var/datum/computer_file/program/P in idle_threads)
+		if(P.program_state != PROGRAM_STATE_KILLED)
+			P.ntnet_status = get_ntnet_status()
+			P.computer_emagged = computer_emagged
+			P.process_tick()
+		else
+			idle_threads.Remove(P)
+
+	handle_power() // Handles all computer power interaction
+	check_update_ui_need()
+
+// Used to perform preset-specific hardware changes.
+/obj/item/modular_computer/proc/install_default_hardware()
+	return 1
+
+// Used to install preset-specific programs
+/obj/item/modular_computer/proc/install_default_programs()
+	return 1
+
+/obj/item/modular_computer/New()
+	START_PROCESSING(SSobj, src)
+	install_default_hardware()
+	if(hard_drive)
+		install_default_programs()
+	update_icon()
+	update_verbs()
+	..()
+
+/obj/item/modular_computer/Destroy()
+	kill_program(1)
+	STOP_PROCESSING(SSobj, src)
+	for(var/obj/item/weapon/computer_hardware/CH in src.get_all_components())
+		uninstall_component(null, CH)
+		qdel(CH)
+	return ..()
+
+/obj/item/modular_computer/emag_act(var/remaining_charges, var/mob/user)
+	if(computer_emagged)
+		to_chat(user, "\The [src] was already emagged.")
+		return //NO_EMAG_ACT
+	else
+		computer_emagged = 1
+		to_chat(user, "You emag \the [src]. It's screen briefly shows a \"OVERRIDE ACCEPTED: New software downloads available.\" message.")
+		return 1
+
+/obj/item/modular_computer/update_icon()
+	icon_state = icon_state_unpowered
+
+	overlays.Cut()
+	if(bsod)
+		overlays.Add("bsod")
+		return
+	if(!enabled)
+		if(icon_state_screensaver)
+			overlays.Add(icon_state_screensaver)
+		set_light(0)
+		return
+	set_light(light_strength)
+	if(active_program)
+		overlays.Add(active_program.program_icon_state ? active_program.program_icon_state : icon_state_menu)
+		if(active_program.program_key_state)
+			overlays.Add(active_program.program_key_state)
+	else
+		overlays.Add(icon_state_menu)
+
+/obj/item/modular_computer/proc/turn_on(var/mob/user)
+	if(bsod)
+		return
+	if(tesla_link)
+		tesla_link.enabled = 1
+	var/issynth = issilicon(user) // Robots and AIs get different activation messages.
+	if(damage > broken_damage)
+		if(issynth)
+			to_chat(user, "You send an activation signal to \the [src], but it responds with an error code. It must be damaged.")
+		else
+			to_chat(user, "You press the power button, but the computer fails to boot up, displaying variety of errors before shutting down again.")
+		return
+	if(processor_unit && (apc_power(0) || battery_power(0))) // Battery-run and charged or non-battery but powered by APC.
+		if(issynth)
+			to_chat(user, "You send an activation signal to \the [src], turning it on")
+		else
+			to_chat(user, "You press the power button and start up \the [src]")
+		enable_computer(user)
+
+	else // Unpowered
+		if(issynth)
+			to_chat(user, "You send an activation signal to \the [src] but it does not respond")
+		else
+			to_chat(user, "You press the power button but \the [src] does not respond")
+
+// Relays kill program request to currently active program. Use this to quit current program.
+/obj/item/modular_computer/proc/kill_program(var/forced = 0)
+	if(active_program)
+		active_program.kill_program(forced)
+		active_program = null
+	var/mob/user = usr
+	if(user && istype(user))
+		ui_interact(user) // Re-open the UI on this computer. It should show the main screen now.
+	update_icon()
+
+// Returns 0 for No Signal, 1 for Low Signal and 2 for Good Signal. 3 is for wired connection (always-on)
+/obj/item/modular_computer/proc/get_ntnet_status(var/specific_action = 0)
+	if(network_card)
+		return network_card.get_signal(specific_action)
+	else
+		return 0
+
+/obj/item/modular_computer/proc/add_log(var/text)
+	if(!get_ntnet_status())
+		return 0
+	return ntnet_global.add_log(text, network_card)
+
+/obj/item/modular_computer/proc/shutdown_computer(var/loud = 1)
+	kill_program(1)
+	for(var/datum/computer_file/program/P in idle_threads)
+		P.kill_program(1)
+		idle_threads.Remove(P)
+	if(loud)
+		visible_message("\The [src] shuts down.")
+	enabled = 0
+	update_icon()
+
+/obj/item/modular_computer/proc/enable_computer(var/mob/user = null)
+	enabled = 1
+	update_icon()
+
+	// Autorun feature
+	var/datum/computer_file/data/autorun = hard_drive ? hard_drive.find_file_by_name("autorun") : null
+	if(istype(autorun))
+		run_program(autorun.stored_data)
+
+	if(user)
+		ui_interact(user)
+
+/obj/item/modular_computer/proc/minimize_program(mob/user)
+	if(!active_program || !processor_unit)
+		return
+
+	idle_threads.Add(active_program)
+	active_program.program_state = PROGRAM_STATE_BACKGROUND // Should close any existing UIs
+	SSnanoui.close_uis(active_program.NM ? active_program.NM : active_program)
+	active_program = null
+	update_icon()
+	if(istype(user))
+		ui_interact(user) // Re-open the UI on this computer. It should show the main screen now.
+
+
+/obj/item/modular_computer/proc/run_program(prog)
+	var/datum/computer_file/program/P = null
+	var/mob/user = usr
+	if(hard_drive)
+		P = hard_drive.find_file_by_name(prog)
+
+	if(!P || !istype(P)) // Program not found or it's not executable program.
+		to_chat(user, "<span class='danger'>\The [src]'s screen shows \"I/O ERROR - Unable to run [prog]\" warning.</span>")
+		return
+
+	P.computer = src
+
+	if(!P.is_supported_by_hardware(hardware_flag, 1, user))
+		return
+	if(P in idle_threads)
+		P.program_state = PROGRAM_STATE_ACTIVE
+		active_program = P
+		idle_threads.Remove(P)
+		update_icon()
+		return
+
+	if(idle_threads.len >= processor_unit.max_idle_programs+1)
+		to_chat(user, "<span class='notice'>\The [src] displays a \"Maximal CPU load reached. Unable to run another program.\" error</span>")
+		return
+
+	if(P.requires_ntnet && !get_ntnet_status(P.requires_ntnet_feature)) // The program requires NTNet connection, but we are not connected to NTNet.
+		to_chat(user, "<span class='danger'>\The [src]'s screen shows \"NETWORK ERROR - Unable to connect to NTNet. Please retry. If problem persists contact your system administrator.\" warning.</span>")
+		return
+
+	if(active_program)
+		minimize_program(user)
+
+	if(P.run_program(user))
+		active_program = P
+		update_icon()
+	return 1
+
+/obj/item/modular_computer/proc/update_uis()
+	if(active_program) //Should we update program ui or computer ui?
+		SSnanoui.update_uis(active_program)
+		if(active_program.NM)
+			SSnanoui.update_uis(active_program.NM)
+	else
+		SSnanoui.update_uis(src)
+
+/obj/item/modular_computer/proc/check_update_ui_need()
+	var/ui_update_needed = 0
+	if(battery_module)
+		var/batery_percent = battery_module.battery.percent()
+		if(last_battery_percent != batery_percent) //Let's update UI on percent change
+			ui_update_needed = 1
+			last_battery_percent = batery_percent
+
+	if(stationtime2text() != last_world_time)
+		last_world_time = stationtime2text()
+		ui_update_needed = 1
+
+	if(idle_threads.len)
+		var/list/current_header_icons = list()
+		for(var/datum/computer_file/program/P in idle_threads)
+			if(!P.ui_header)
+				continue
+			current_header_icons[P.type] = P.ui_header
+		if(!last_header_icons)
+			last_header_icons = current_header_icons
+
+		else if(!listequal(last_header_icons, current_header_icons))
+			last_header_icons = current_header_icons
+			ui_update_needed = 1
+		else
+			for(var/x in last_header_icons|current_header_icons)
+				if(last_header_icons[x]!=current_header_icons[x])
+					last_header_icons = current_header_icons
+					ui_update_needed = 1
+					break
+
+	if(ui_update_needed)
+		update_uis()
+
+// Used by camera monitor program
+/obj/item/modular_computer/check_eye(var/mob/user)
+	if(active_program)
+		return active_program.check_eye(user)
+	else
+		return ..()
+
+/obj/item/modular_computer/proc/set_autorun(program)
+	if(!hard_drive)
+		return
+	var/datum/computer_file/data/autorun = hard_drive.find_file_by_name("autorun")
+	if(!istype(autorun))
+		autorun = new/datum/computer_file/data()
+		autorun.filename = "autorun"
+		hard_drive.store_file(autorun)
+	if(autorun.stored_data == program)
+		autorun.stored_data = null
+	else
+		autorun.stored_data = program

code/modules/modular_computers/computers/modular_computer/damage.dm

@@ -0,0 +1,55 @@
+/obj/item/modular_computer/examine(var/mob/user)
+	. = ..()
+	if(damage > broken_damage)
+		to_chat(user, "<span class='danger'>It is heavily damaged!</span>")
+	else if(damage)
+		to_chat(user, "It is damaged.")
+
+/obj/item/modular_computer/proc/break_apart()
+	visible_message("\The [src] breaks apart!")
+	var/turf/newloc = get_turf(src)
+	new /obj/item/stack/material/steel(newloc, round(steel_sheet_cost/2))
+	for(var/obj/item/weapon/computer_hardware/H in get_all_components())
+		uninstall_component(null, H)
+		H.forceMove(newloc)
+		if(prob(25))
+			H.take_damage(rand(10,30))
+	qdel()
+
+/obj/item/modular_computer/proc/take_damage(var/amount, var/component_probability, var/damage_casing = 1, var/randomize = 1)
+	if(randomize)
+		// 75%-125%, rand() works with integers, apparently.
+		amount *= (rand(75, 125) / 100.0)
+	amount = round(amount)
+	if(damage_casing)
+		damage += amount
+		damage = between(0, damage, max_damage)
+
+	if(component_probability)
+		for(var/obj/item/weapon/computer_hardware/H in get_all_components())
+			if(prob(component_probability))
+				H.take_damage(round(amount / 2))
+
+	if(damage >= max_damage)
+		break_apart()
+
+// Stronger explosions cause serious damage to internal components
+// Minor explosions are mostly mitigitated by casing.
+/obj/item/modular_computer/ex_act(var/severity)
+	take_damage(rand(100,200) / severity, 30 / severity)
+
+// EMPs are similar to explosions, but don't cause physical damage to the casing. Instead they screw up the components
+/obj/item/modular_computer/emp_act(var/severity)
+	take_damage(rand(100,200) / severity, 50 / severity, 0)
+
+// "Stun" weapons can cause minor damage to components (short-circuits?)
+// "Burn" damage is equally strong against internal components and exterior casing
+// "Brute" damage mostly damages the casing.
+/obj/item/modular_computer/bullet_act(var/obj/item/projectile/Proj)
+	switch(Proj.damage_type)
+		if(BRUTE)
+			take_damage(Proj.damage, Proj.damage / 2)
+		if(HALLOSS)
+			take_damage(Proj.damage, Proj.damage / 3, 0)
+		if(BURN)
+			take_damage(Proj.damage, Proj.damage / 1.5)

code/modules/modular_computers/computers/modular_computer/hardware.dm

@@ -0,0 +1,139 @@
+// Attempts to install the hardware into apropriate slot.
+/obj/item/modular_computer/proc/try_install_component(var/mob/living/user, var/obj/item/weapon/computer_hardware/H, var/found = 0)
+	// "USB" flash drive.
+	if(istype(H, /obj/item/weapon/computer_hardware/hard_drive/portable))
+		if(portable_drive)
+			to_chat(user, "This computer's portable drive slot is already occupied by \the [portable_drive].")
+			return
+		found = 1
+		portable_drive = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/hard_drive))
+		if(hard_drive)
+			to_chat(user, "This computer's hard drive slot is already occupied by \the [hard_drive].")
+			return
+		found = 1
+		hard_drive = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/network_card))
+		if(network_card)
+			to_chat(user, "This computer's network card slot is already occupied by \the [network_card].")
+			return
+		found = 1
+		network_card = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/nano_printer))
+		if(nano_printer)
+			to_chat(user, "This computer's nano printer slot is already occupied by \the [nano_printer].")
+			return
+		found = 1
+		nano_printer = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/card_slot))
+		if(card_slot)
+			to_chat(user, "This computer's card slot is already occupied by \the [card_slot].")
+			return
+		found = 1
+		card_slot = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/battery_module))
+		if(battery_module)
+			to_chat(user, "This computer's battery slot is already occupied by \the [battery_module].")
+			return
+		found = 1
+		battery_module = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/processor_unit))
+		if(processor_unit)
+			to_chat(user, "This computer's processor slot is already occupied by \the [processor_unit].")
+			return
+		found = 1
+		processor_unit = H
+	else if(istype(H, /obj/item/weapon/computer_hardware/tesla_link))
+		if(tesla_link)
+			to_chat(user, "This computer's tesla link slot is already occupied by \the [tesla_link].")
+			return
+		found = 1
+		tesla_link = H
+	if(found)
+		to_chat(user, "You install \the [H] into \the [src]")
+		H.holder2 = src
+		user.drop_from_inventory(H)
+		H.forceMove(src)
+		update_verbs()
+
+// Uninstalls component. Found and Critical vars may be passed by parent types, if they have additional hardware.
+/obj/item/modular_computer/proc/uninstall_component(var/mob/living/user, var/obj/item/weapon/computer_hardware/H, var/found = 0, var/critical = 0)
+	if(portable_drive == H)
+		portable_drive = null
+		found = 1
+	if(hard_drive == H)
+		hard_drive = null
+		found = 1
+		critical = 1
+	if(network_card == H)
+		network_card = null
+		found = 1
+	if(nano_printer == H)
+		nano_printer = null
+		found = 1
+	if(card_slot == H)
+		card_slot = null
+		found = 1
+	if(battery_module == H)
+		battery_module = null
+		found = 1
+	if(processor_unit == H)
+		processor_unit = null
+		found = 1
+		critical = 1
+	if(tesla_link == H)
+		tesla_link = null
+		found = 1
+	if(found)
+		if(user)
+			to_chat(user, "You remove \the [H] from \the [src].")
+		H.forceMove(get_turf(src))
+		H.holder2 = null
+		update_verbs()
+	if(critical && enabled)
+		if(user)
+			to_chat(user, "<span class='danger'>\The [src]'s screen freezes for few seconds and then displays an \"HARDWARE ERROR: Critical component disconnected. Please verify component connection and reboot the device. If the problem persists contact technical support for assistance.\" warning.</span>")
+		shutdown_computer()
+		update_icon()
+
+
+// Checks all hardware pieces to determine if name matches, if yes, returns the hardware piece, otherwise returns null
+/obj/item/modular_computer/proc/find_hardware_by_name(var/name)
+	if(portable_drive && (portable_drive.name == name))
+		return portable_drive
+	if(hard_drive && (hard_drive.name == name))
+		return hard_drive
+	if(network_card && (network_card.name == name))
+		return network_card
+	if(nano_printer && (nano_printer.name == name))
+		return nano_printer
+	if(card_slot && (card_slot.name == name))
+		return card_slot
+	if(battery_module && (battery_module.name == name))
+		return battery_module
+	if(processor_unit && (processor_unit.name == name))
+		return processor_unit
+	if(tesla_link && (tesla_link.name == name))
+		return tesla_link
+	return null
+
+// Returns list of all components
+/obj/item/modular_computer/proc/get_all_components()
+	var/list/all_components = list()
+	if(hard_drive)
+		all_components.Add(hard_drive)
+	if(network_card)
+		all_components.Add(network_card)
+	if(portable_drive)
+		all_components.Add(portable_drive)
+	if(nano_printer)
+		all_components.Add(nano_printer)
+	if(card_slot)
+		all_components.Add(card_slot)
+	if(battery_module)
+		all_components.Add(battery_module)
+	if(processor_unit)
+		all_components.Add(processor_unit)
+	if(tesla_link)
+		all_components.Add(tesla_link)
+	return all_components

code/modules/modular_computers/computers/modular_computer/interaction.dm

@@ -0,0 +1,200 @@
+/obj/item/modular_computer/proc/update_verbs()
+	verbs.Cut()
+	if(portable_drive)
+		verbs |= /obj/item/modular_computer/verb/eject_usb
+	if(card_slot)
+		verbs |= /obj/item/modular_computer/verb/eject_id
+	verbs |= /obj/item/modular_computer/verb/emergency_shutdown
+
+// Forcibly shut down the device. To be used when something bugs out and the UI is nonfunctional.
+/obj/item/modular_computer/verb/emergency_shutdown()
+	set name = "Forced Shutdown"
+	set category = "Object"
+	set src in view(1)
+
+	if(usr.incapacitated() || !istype(usr, /mob/living))
+		to_chat(usr, "<span class='warning'>You can't do that.</span>")
+		return
+
+	if(!Adjacent(usr))
+		to_chat(usr, "<span class='warning'>You can't reach it.</span>")
+		return
+
+	if(enabled)
+		bsod = 1
+		update_icon()
+		shutdown_computer()
+		to_chat(usr, "You press a hard-reset button on \the [src]. It displays a brief debug screen before shutting down.")
+		spawn(2 SECONDS)
+			bsod = 0
+			update_icon()
+
+
+// Eject ID card from computer, if it has ID slot with card inside.
+/obj/item/modular_computer/verb/eject_id()
+	set name = "Eject ID"
+	set category = "Object"
+	set src in view(1)
+
+	if(usr.incapacitated() || !istype(usr, /mob/living))
+		to_chat(usr, "<span class='warning'>You can't do that.</span>")
+		return
+
+	if(!Adjacent(usr))
+		to_chat(usr, "<span class='warning'>You can't reach it.</span>")
+		return
+
+	proc_eject_id(usr)
+
+// Eject ID card from computer, if it has ID slot with card inside.
+/obj/item/modular_computer/verb/eject_usb()
+	set name = "Eject Portable Storage"
+	set category = "Object"
+	set src in view(1)
+
+	if(usr.incapacitated() || !istype(usr, /mob/living))
+		to_chat(usr, "<span class='warning'>You can't do that.</span>")
+		return
+
+	if(!Adjacent(usr))
+		to_chat(usr, "<span class='warning'>You can't reach it.</span>")
+		return
+
+	proc_eject_usb(usr)
+
+/obj/item/modular_computer/proc/proc_eject_id(mob/user)
+	if(!user)
+		user = usr
+
+	if(!card_slot)
+		to_chat(user, "\The [src] does not have an ID card slot")
+		return
+
+	if(!card_slot.stored_card)
+		to_chat(user, "There is no card in \the [src]")
+		return
+
+	if(active_program)
+		active_program.event_idremoved(0)
+
+	for(var/datum/computer_file/program/P in idle_threads)
+		P.event_idremoved(1)
+
+	card_slot.stored_card.forceMove(get_turf(src))
+	card_slot.stored_card = null
+	update_uis()
+	to_chat(user, "You remove the card from \the [src]")
+
+
+/obj/item/modular_computer/proc/proc_eject_usb(mob/user)
+	if(!user)
+		user = usr
+
+	if(!portable_drive)
+		to_chat(user, "There is no portable device connected to \the [src].")
+		return
+
+	uninstall_component(user, portable_drive)
+	update_uis()
+
+/obj/item/modular_computer/attack_ghost(var/mob/observer/ghost/user)
+	if(enabled)
+		ui_interact(user)
+	else if(check_rights(R_ADMIN, 0, user))
+		var/response = alert(user, "This computer is turned off. Would you like to turn it on?", "Admin Override", "Yes", "No")
+		if(response == "Yes")
+			turn_on(user)
+
+/obj/item/modular_computer/attack_ai(var/mob/user)
+	return attack_self(user)
+
+/obj/item/modular_computer/attack_hand(var/mob/user)
+	if(anchored)
+		return attack_self(user)
+	return ..()
+
+// On-click handling. Turns on the computer if it's off and opens the GUI.
+/obj/item/modular_computer/attack_self(var/mob/user)
+	if(enabled && screen_on)
+		ui_interact(user)
+	else if(!enabled && screen_on)
+		turn_on(user)
+
+/obj/item/modular_computer/attackby(var/obj/item/weapon/W as obj, var/mob/user as mob)
+	if(istype(W, /obj/item/weapon/card/id)) // ID Card, try to insert it.
+		var/obj/item/weapon/card/id/I = W
+		if(!card_slot)
+			to_chat(user, "You try to insert \the [I] into \the [src], but it does not have an ID card slot installed.")
+			return
+
+		if(card_slot.stored_card)
+			to_chat(user, "You try to insert \the [I] into \the [src], but it's ID card slot is occupied.")
+			return
+		user.drop_from_inventory(I)
+		card_slot.stored_card = I
+		I.forceMove(src)
+		update_uis()
+		to_chat(user, "You insert \the [I] into \the [src].")
+		return
+	if(istype(W, /obj/item/weapon/paper) || istype(W, /obj/item/weapon/paper_bundle))
+		if(!nano_printer)
+			return
+		nano_printer.attackby(W, user)
+	if(istype(W, /obj/item/weapon/computer_hardware))
+		var/obj/item/weapon/computer_hardware/C = W
+		if(C.hardware_size <= max_hardware_size)
+			try_install_component(user, C)
+		else
+			to_chat(user, "This component is too large for \the [src].")
+	if(W.is_wrench())
+		var/list/components = get_all_components()
+		if(components.len)
+			to_chat(user, "Remove all components from \the [src] before disassembling it.")
+			return
+		new /obj/item/stack/material/steel( get_turf(src.loc), steel_sheet_cost )
+		src.visible_message("\The [src] has been disassembled by [user].")
+		qdel(src)
+		return
+	if(istype(W, /obj/item/weapon/weldingtool))
+		var/obj/item/weapon/weldingtool/WT = W
+		if(!WT.isOn())
+			to_chat(user, "\The [W] is off.")
+			return
+
+		if(!damage)
+			to_chat(user, "\The [src] does not require repairs.")
+			return
+
+		to_chat(user, "You begin repairing damage to \the [src]...")
+		if(WT.remove_fuel(round(damage/75)) && do_after(usr, damage/10))
+			damage = 0
+			to_chat(user, "You repair \the [src].")
+		return
+
+	if(W.is_screwdriver())
+		var/list/all_components = get_all_components()
+		if(!all_components.len)
+			to_chat(user, "This device doesn't have any components installed.")
+			return
+		var/list/component_names = list()
+		for(var/obj/item/weapon/computer_hardware/H in all_components)
+			component_names.Add(H.name)
+
+		var/choice = input(usr, "Which component do you want to uninstall?", "Computer maintenance", null) as null|anything in component_names
+
+		if(!choice)
+			return
+
+		if(!Adjacent(usr))
+			return
+
+		var/obj/item/weapon/computer_hardware/H = find_hardware_by_name(choice)
+
+		if(!H)
+			return
+
+		uninstall_component(user, H)
+
+		return
+
+	..()

code/modules/modular_computers/computers/modular_computer/power.dm

@@ -0,0 +1,51 @@
+/obj/item/modular_computer/proc/power_failure(var/malfunction = 0)
+	if(enabled) // Shut down the computer
+		visible_message("<span class='danger'>\The [src]'s screen flickers briefly and then goes dark.</span>")
+		if(active_program)
+			active_program.event_powerfailure(0)
+		for(var/datum/computer_file/program/PRG in idle_threads)
+			PRG.event_powerfailure(1)
+		shutdown_computer(0)
+
+// Tries to use power from battery. Passing 0 as parameter results in this proc returning whether battery is functional or not.
+/obj/item/modular_computer/proc/battery_power(var/power_usage = 0)
+	apc_powered = FALSE
+	if(!battery_module || !battery_module.check_functionality() || battery_module.battery.charge <= 0)
+		return FALSE
+	if(battery_module.battery.use(power_usage * CELLRATE) || ((power_usage == 0) && battery_module.battery.charge))
+		return TRUE
+	return FALSE
+
+// Tries to use power from APC, if present.
+/obj/item/modular_computer/proc/apc_power(var/power_usage = 0)
+	apc_powered = TRUE
+	// Tesla link was originally limited to machinery only, but this probably works too, and the benefit of being able to power all devices from an APC outweights
+	// the possible minor performance loss.
+	if(!tesla_link || !tesla_link.check_functionality())
+		return FALSE
+	var/area/A = get_area(src)
+	if(!istype(A) || !A.powered(EQUIP))
+		return FALSE
+
+	// At this point, we know that APC can power us for this tick. Check if we also need to charge our battery, and then actually use the power.
+	if(battery_module && (battery_module.battery.charge < battery_module.battery.maxcharge) && (power_usage > 0))
+		power_usage += tesla_link.passive_charging_rate
+		battery_module.battery.give(tesla_link.passive_charging_rate * CELLRATE)
+
+	A.use_power(power_usage, EQUIP)
+	return TRUE
+
+// Handles power-related things, such as battery interaction, recharging, shutdown when it's discharged
+/obj/item/modular_computer/proc/handle_power()
+	var/power_usage = screen_on ? base_active_power_usage : base_idle_power_usage
+	for(var/obj/item/weapon/computer_hardware/H in get_all_components())
+		if(H.enabled)
+			power_usage += H.power_usage
+	last_power_usage = power_usage
+
+	// First tries to charge from an APC, if APC is unavailable switches to battery power. If neither works the computer fails.
+	if(apc_power(power_usage))
+		return
+	if(battery_power(power_usage))
+		return
+	power_failure()

code/modules/modular_computers/computers/modular_computer/ui.dm

@@ -0,0 +1,155 @@
+// Operates NanoUI
+/obj/item/modular_computer/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1)
+	if(!screen_on || !enabled)
+		if(ui)
+			ui.close()
+		return 0
+	if(!apc_power(0) && !battery_power(0))
+		if(ui)
+			ui.close()
+		return 0
+
+	// If we have an active program switch to it now.
+	if(active_program)
+		if(ui) // This is the main laptop screen. Since we are switching to program's UI close it for now.
+			ui.close()
+		active_program.ui_interact(user)
+		return
+
+	// We are still here, that means there is no program loaded. Load the BIOS/ROM/OS/whatever you want to call it.
+	// This screen simply lists available programs and user may select them.
+	if(!hard_drive || !hard_drive.stored_files || !hard_drive.stored_files.len)
+		visible_message("\The [src] beeps three times, it's screen displaying \"DISK ERROR\" warning.")
+		return // No HDD, No HDD files list or no stored files. Something is very broken.
+
+	var/datum/computer_file/data/autorun = hard_drive.find_file_by_name("autorun")
+
+	var/list/data = get_header_data()
+
+	var/list/programs = list()
+	for(var/datum/computer_file/program/P in hard_drive.stored_files)
+		var/list/program = list()
+		program["name"] = P.filename
+		program["desc"] = P.filedesc
+		program["icon"] = P.program_menu_icon
+		program["autorun"] = (istype(autorun) && (autorun.stored_data == P.filename)) ? 1 : 0
+		if(P in idle_threads)
+			program["running"] = 1
+		programs.Add(list(program))
+
+	data["programs"] = programs
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "laptop_mainscreen.tmpl", "NTOS Main Menu", 400, 500)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+// Handles user's GUI input
+/obj/item/modular_computer/Topic(href, href_list)
+	if(..())
+		return 1
+	if( href_list["PC_exit"] )
+		kill_program()
+		return 1
+	if( href_list["PC_enable_component"] )
+		var/obj/item/weapon/computer_hardware/H = find_hardware_by_name(href_list["PC_enable_component"])
+		if(H && istype(H) && !H.enabled)
+			H.enabled = 1
+		. = 1
+	if( href_list["PC_disable_component"] )
+		var/obj/item/weapon/computer_hardware/H = find_hardware_by_name(href_list["PC_disable_component"])
+		if(H && istype(H) && H.enabled)
+			H.enabled = 0
+		. = 1
+	if( href_list["PC_shutdown"] )
+		shutdown_computer()
+		return 1
+	if( href_list["PC_minimize"] )
+		var/mob/user = usr
+		minimize_program(user)
+
+	if( href_list["PC_killprogram"] )
+		var/prog = href_list["PC_killprogram"]
+		var/datum/computer_file/program/P = null
+		var/mob/user = usr
+		if(hard_drive)
+			P = hard_drive.find_file_by_name(prog)
+
+		if(!istype(P) || P.program_state == PROGRAM_STATE_KILLED)
+			return
+
+		P.kill_program(1)
+		update_uis()
+		to_chat(user, "<span class='notice'>Program [P.filename].[P.filetype] with PID [rand(100,999)] has been killed.</span>")
+
+	if( href_list["PC_runprogram"] )
+		return run_program(href_list["PC_runprogram"])
+
+	if( href_list["PC_setautorun"] )
+		if(!hard_drive)
+			return
+		set_autorun(href_list["PC_setautorun"])
+
+	if(.)
+		update_uis()
+
+// Function used by NanoUI's to obtain data for header. All relevant entries begin with "PC_"
+/obj/item/modular_computer/proc/get_header_data()
+	var/list/data = list()
+
+	if(battery_module)
+		switch(battery_module.battery.percent())
+			if(80 to 200) // 100 should be maximal but just in case..
+				data["PC_batteryicon"] = "batt_100.gif"
+			if(60 to 80)
+				data["PC_batteryicon"] = "batt_80.gif"
+			if(40 to 60)
+				data["PC_batteryicon"] = "batt_60.gif"
+			if(20 to 40)
+				data["PC_batteryicon"] = "batt_40.gif"
+			if(5 to 20)
+				data["PC_batteryicon"] = "batt_20.gif"
+			else
+				data["PC_batteryicon"] = "batt_5.gif"
+		data["PC_batterypercent"] = "[round(battery_module.battery.percent())] %"
+		data["PC_showbatteryicon"] = 1
+	else
+		data["PC_batteryicon"] = "batt_5.gif"
+		data["PC_batterypercent"] = "N/C"
+		data["PC_showbatteryicon"] = battery_module ? 1 : 0
+
+	if(tesla_link && tesla_link.enabled && apc_powered)
+		data["PC_apclinkicon"] = "charging.gif"
+
+	if(network_card && network_card.is_banned())
+		data["PC_ntneticon"] = "sig_warning.gif"
+	else
+		switch(get_ntnet_status())
+			if(0)
+				data["PC_ntneticon"] = "sig_none.gif"
+			if(1)
+				data["PC_ntneticon"] = "sig_low.gif"
+			if(2)
+				data["PC_ntneticon"] = "sig_high.gif"
+			if(3)
+				data["PC_ntneticon"] = "sig_lan.gif"
+
+	var/list/program_headers = list()
+	for(var/datum/computer_file/program/P in idle_threads)
+		if(!P.ui_header)
+			continue
+		program_headers.Add(list(list(
+			"icon" = P.ui_header
+		)))
+	if(active_program && active_program.ui_header)
+		program_headers.Add(list(list(
+			"icon" = active_program.ui_header
+		)))
+	data["PC_programheaders"] = program_headers
+
+	data["PC_stationtime"] = stationtime2text()
+	data["PC_hasheader"] = 1
+	data["PC_showexitprogram"] = active_program ? 1 : 0 // Hides "Exit Program" button on mainscreen
+	return data

code/modules/modular_computers/computers/modular_computer/variables.dm

@@ -0,0 +1,53 @@
+// This is the base type that handles everything. Subtypes can be easily created by tweaking variables in this file to your liking.
+
+/obj/item/modular_computer
+	name = "Modular Computer"
+	desc = "A modular computer. You shouldn't see this."
+
+	var/enabled = 0											// Whether the computer is turned on.
+	var/screen_on = 1										// Whether the computer is active/opened/it's screen is on.
+	var/datum/computer_file/program/active_program = null	// A currently active program running on the computer.
+	var/hardware_flag = 0									// A flag that describes this device type
+	var/last_power_usage = 0								// Last tick power usage of this computer
+	var/last_battery_percent = 0							// Used for deciding if battery percentage has chandged
+	var/last_world_time = "00:00"
+	var/list/last_header_icons
+	var/computer_emagged = FALSE							// Whether the computer is emagged.
+	var/apc_powered = FALSE									// Set automatically. Whether the computer used APC power last tick.
+	var/base_active_power_usage = 50						// Power usage when the computer is open (screen is active) and can be interacted with. Remember hardware can use power too.
+	var/base_idle_power_usage = 5							// Power usage when the computer is idle and screen is off (currently only applies to laptops)
+	var/bsod = FALSE										// Error screen displayed
+
+	// Modular computers can run on various devices. Each DEVICE (Laptop, Console, Tablet,..)
+	// must have it's own DMI file. Icon states must be called exactly the same in all files, but may look differently
+	// If you create a program which is limited to Laptops and Consoles you don't have to add it's icon_state overlay for Tablets too, for example.
+
+	icon = null												// This thing isn't meant to be used on it's own. Subtypes should supply their own icon.
+	icon_state = null
+	//center_of_mass = null									// No pixelshifting by placing on tables, etc.
+	//randpixel = 0											// And no random pixelshifting on-creation either.
+	var/icon_state_unpowered = null							// Icon state when the computer is turned off
+	var/icon_state_menu = "menu"							// Icon state overlay when the computer is turned on, but no program is loaded that would override the screen.
+	var/icon_state_screensaver = null
+	var/max_hardware_size = 0								// Maximal hardware size. Currently, tablets have 1, laptops 2 and consoles 3. Limits what hardware types can be installed.
+	var/steel_sheet_cost = 5								// Amount of steel sheets refunded when disassembling an empty frame of this computer.
+	var/light_strength = 0									// Intensity of light this computer emits. Comparable to numbers light fixtures use.
+	var/list/idle_threads = list()							// Idle programs on background. They still receive process calls but can't be interacted with.
+
+	// Damage of the chassis. If the chassis takes too much damage it will break apart.
+	var/damage = 0				// Current damage level
+	var/broken_damage = 50		// Damage level at which the computer ceases to operate
+	var/max_damage = 100		// Damage level at which the computer breaks apart.
+
+	// Important hardware (must be installed for computer to work)
+	var/obj/item/weapon/computer_hardware/processor_unit/processor_unit				// CPU. Without it the computer won't run. Better CPUs can run more programs at once.
+	var/obj/item/weapon/computer_hardware/network_card/network_card					// Network Card component of this computer. Allows connection to NTNet
+	var/obj/item/weapon/computer_hardware/hard_drive/hard_drive						// Hard Drive component of this computer. Stores programs and files.
+
+	// Optional hardware (improves functionality, but is not critical for computer to work in most cases)
+	var/obj/item/weapon/computer_hardware/battery_module/battery_module				// An internal power source for this computer. Can be recharged.
+	var/obj/item/weapon/computer_hardware/card_slot/card_slot						// ID Card slot component of this computer. Mostly for HoP modification console that needs ID slot for modification.
+	var/obj/item/weapon/computer_hardware/nano_printer/nano_printer					// Nano Printer component of this computer, for your everyday paperwork needs.
+	var/obj/item/weapon/computer_hardware/hard_drive/portable/portable_drive		// Portable data storage
+	var/obj/item/weapon/computer_hardware/ai_slot/ai_slot							// AI slot, an intellicard housing that allows modifications of AIs.
+	var/obj/item/weapon/computer_hardware/tesla_link/tesla_link						// Tesla Link, Allows remote charging from nearest APC.

code/modules/modular_computers/computers/subtypes/dev_console.dm

@@ -0,0 +1,18 @@
+/obj/item/modular_computer/console
+	name = "console"
+	desc = "A stationary computer."
+	icon = 'icons/obj/modular_console.dmi'
+	icon_state = "console"
+	icon_state_unpowered = "console"
+	icon_state_screensaver = "standby"
+	icon_state_menu = "menu"
+	hardware_flag = PROGRAM_CONSOLE
+	anchored = TRUE
+	density = 1
+	base_idle_power_usage = 100
+	base_active_power_usage = 500
+	max_hardware_size = 3
+	steel_sheet_cost = 20
+	light_strength = 4
+	max_damage = 300
+	broken_damage = 150

code/modules/modular_computers/computers/subtypes/dev_laptop.dm

@@ -0,0 +1,37 @@
+/obj/item/modular_computer/laptop
+	anchored = TRUE
+	name = "laptop computer"
+	desc = "A portable computer."
+	hardware_flag = PROGRAM_LAPTOP
+	icon_state_unpowered = "laptop-open"
+	icon = 'icons/obj/modular_laptop.dmi'
+	icon_state = "laptop-open"
+	icon_state_screensaver = "standby"
+	base_idle_power_usage = 25
+	base_active_power_usage = 200
+	max_hardware_size = 2
+	light_strength = 3
+	max_damage = 200
+	broken_damage = 100
+	w_class = ITEMSIZE_NORMAL
+	var/icon_state_closed = "laptop-closed"
+
+/obj/item/modular_computer/laptop/AltClick()
+	// Prevents carrying of open laptops inhand.
+	// While they work inhand, i feel it'd make tablets lose some of their high-mobility advantage they have over laptops now.
+	if(!istype(loc, /turf/))
+		to_chat(usr, "\The [src] has to be on a stable surface first!")
+		return
+	anchored = !anchored
+	screen_on = anchored
+	update_icon()
+
+/obj/item/modular_computer/laptop/update_icon()
+	if(anchored)
+		..()
+	else
+		overlays.Cut()
+		icon_state = icon_state_closed
+
+/obj/item/modular_computer/laptop/preset
+	anchored = FALSE

code/modules/modular_computers/computers/subtypes/dev_tablet.dm

@@ -0,0 +1,16 @@
+/obj/item/modular_computer/tablet
+	name = "tablet computer"
+	desc = "A small portable microcomputer"
+	icon = 'icons/obj/modular_tablet.dmi'
+	icon_state = "tablet"
+	icon_state_unpowered = "tablet"
+	icon_state_menu = "menu"
+	hardware_flag = PROGRAM_TABLET
+	max_hardware_size = 1
+	w_class = ITEMSIZE_SMALL
+	light_strength = 2					// Same as PDAs
+
+/obj/item/modular_computer/tablet/lease
+	desc = "A small portable microcomputer. This one has a gold and blue stripe, and a serial number stamped into the case."
+	icon_state = "tabletsol"
+	icon_state_unpowered = "tabletsol"

code/modules/modular_computers/computers/subtypes/dev_telescreen.dm

@@ -0,0 +1,59 @@
+/obj/item/modular_computer/telescreen
+	name = "telescreen"
+	desc = "A wall-mounted touchscreen computer."
+	icon = 'icons/obj/modular_telescreen.dmi'
+	icon_state = "telescreen"
+	icon_state_unpowered = "telescreen"
+	icon_state_menu = "menu"
+	icon_state_screensaver = "standby"
+	hardware_flag = PROGRAM_TELESCREEN
+	anchored = TRUE
+	density = 0
+	base_idle_power_usage = 75
+	base_active_power_usage = 300
+	max_hardware_size = 2
+	steel_sheet_cost = 10
+	light_strength = 4
+	max_damage = 300
+	broken_damage = 150
+	w_class = ITEMSIZE_HUGE
+
+/obj/item/modular_computer/telescreen/New()
+	..()
+	// Allows us to create "north bump" "south bump" etc. named objects, for more comfortable mapping.
+	name = "telescreen"
+
+/obj/item/modular_computer/telescreen/attackby(var/obj/item/weapon/W as obj, var/mob/user as mob)
+	if(W.is_crowbar())
+		if(anchored)
+			shutdown_computer()
+			anchored = FALSE
+			screen_on = FALSE
+			pixel_x = 0
+			pixel_y = 0
+			to_chat(user, "You unsecure \the [src].")
+		else
+			var/choice = input(user, "Where do you want to place \the [src]?", "Offset selection") in list("North", "South", "West", "East", "This tile", "Cancel")
+			var/valid = FALSE
+			switch(choice)
+				if("North")
+					valid = TRUE
+					pixel_y = 32
+				if("South")
+					valid = TRUE
+					pixel_y = -32
+				if("West")
+					valid = TRUE
+					pixel_x = -32
+				if("East")
+					valid = TRUE
+					pixel_x = 32
+				if("This tile")
+					valid = TRUE
+
+			if(valid)
+				anchored = 1
+				screen_on = TRUE
+				to_chat(user, "You secure \the [src].")
+			return
+	..()

code/modules/modular_computers/computers/subtypes/preset_console.dm

@@ -0,0 +1,123 @@
+/obj/item/modular_computer/console/preset/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/super(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card/wired(src)
+
+// Engineering
+/obj/item/modular_computer/console/preset/engineering/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/power_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/supermatter_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/alarm_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/atmos_control())
+	hard_drive.store_file(new/datum/computer_file/program/rcon_console())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+
+// Medical
+/obj/item/modular_computer/console/preset/medical/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/suit_sensors())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/wordprocessor())
+	set_autorun("sensormonitor")
+
+// Research
+/obj/item/modular_computer/console/preset/research/install_default_hardware()
+	..()
+	//ai_slot = new/obj/item/weapon/computer_hardware/ai_slot(src)
+
+/obj/item/modular_computer/console/preset/research/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/ntnetmonitor())
+	hard_drive.store_file(new/datum/computer_file/program/nttransfer())
+	hard_drive.store_file(new/datum/computer_file/program/chatclient())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	//hard_drive.store_file(new/datum/computer_file/program/aidiag())
+	hard_drive.store_file(new/datum/computer_file/program/email_client())
+	hard_drive.store_file(new/datum/computer_file/program/wordprocessor())
+
+// Administrator
+/obj/item/modular_computer/console/preset/sysadmin/install_default_hardware()
+	..()
+	//ai_slot = new/obj/item/weapon/computer_hardware/ai_slot(src)
+
+/obj/item/modular_computer/console/preset/sysadmin/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/ntnetmonitor())
+	hard_drive.store_file(new/datum/computer_file/program/nttransfer())
+	hard_drive.store_file(new/datum/computer_file/program/chatclient())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	//hard_drive.store_file(new/datum/computer_file/program/aidiag())
+	hard_drive.store_file(new/datum/computer_file/program/email_client())
+	hard_drive.store_file(new/datum/computer_file/program/email_administration())
+	hard_drive.store_file(new/datum/computer_file/program/wordprocessor())
+
+// Command
+/obj/item/modular_computer/console/preset/command/install_default_hardware()
+	..()
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+
+/obj/item/modular_computer/console/preset/command/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/chatclient())
+	hard_drive.store_file(new/datum/computer_file/program/card_mod())
+	hard_drive.store_file(new/datum/computer_file/program/comm())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/email_client())
+
+// Security
+/obj/item/modular_computer/console/preset/security/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/digitalwarrant())
+	hard_drive.store_file(new/datum/computer_file/program/wordprocessor())
+
+// Civilian
+/obj/item/modular_computer/console/preset/civilian/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/chatclient())
+	hard_drive.store_file(new/datum/computer_file/program/nttransfer())
+	hard_drive.store_file(new/datum/computer_file/program/newsbrowser())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/email_client())
+	hard_drive.store_file(new/datum/computer_file/program/wordprocessor())
+
+// ERT
+/obj/item/modular_computer/console/preset/ert/install_default_hardware()
+	..()
+	//ai_slot = new/obj/item/weapon/computer_hardware/ai_slot(src)
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+
+/obj/item/modular_computer/console/preset/ert/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/nttransfer())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor/ert())
+	hard_drive.store_file(new/datum/computer_file/program/alarm_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/comm())
+	//hard_drive.store_file(new/datum/computer_file/program/aidiag())
+
+// Mercenary
+/obj/item/modular_computer/console/preset/mercenary/
+	computer_emagged = TRUE
+
+/obj/item/modular_computer/console/preset/mercenary/install_default_hardware()
+	..()
+	//ai_slot = new/obj/item/weapon/computer_hardware/ai_slot(src)
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+
+/obj/item/modular_computer/console/preset/mercenary/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor/hacked())
+	hard_drive.store_file(new/datum/computer_file/program/alarm_monitor())
+	//hard_drive.store_file(new/datum/computer_file/program/aidiag())
+
+// Merchant
+/obj/item/modular_computer/console/preset/merchant/install_default_programs()
+	..()
+	//hard_drive.store_file(new/datum/computer_file/program/merchant())
+	hard_drive.store_file(new/datum/computer_file/program/wordprocessor())

code/modules/modular_computers/computers/subtypes/preset_laptop.dm

@@ -0,0 +1,32 @@
+/obj/item/modular_computer/laptop/preset/custom_loadout/cheap/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit/small(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card/(src)
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+	battery_module = new/obj/item/weapon/computer_hardware/battery_module/advanced(src)
+	battery_module.charge_to_full()
+
+/obj/item/modular_computer/laptop/preset/custom_loadout/advanced/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/advanced(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card/advanced(src)
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+	battery_module = new/obj/item/weapon/computer_hardware/battery_module/advanced(src)
+	battery_module.charge_to_full()
+
+/obj/item/modular_computer/laptop/preset/custom_loadout/standard/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card/(src)
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+	battery_module = new/obj/item/weapon/computer_hardware/battery_module/advanced(src)
+	battery_module.charge_to_full()

code/modules/modular_computers/computers/subtypes/preset_tablet.dm

@@ -0,0 +1,28 @@
+/obj/item/modular_computer/tablet/preset/custom_loadout/cheap/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit/small(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/micro(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card(src)
+	battery_module = new/obj/item/weapon/computer_hardware/battery_module/nano(src)
+	battery_module.charge_to_full()
+
+/obj/item/modular_computer/tablet/preset/custom_loadout/advanced/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit/small(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/small(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card/advanced(src)
+	nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(src)
+	card_slot = new/obj/item/weapon/computer_hardware/card_slot(src)
+	battery_module = new/obj/item/weapon/computer_hardware/battery_module(src)
+	battery_module.charge_to_full()
+
+/obj/item/modular_computer/tablet/preset/custom_loadout/standard/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit/small(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/small(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card(src)
+	battery_module = new/obj/item/weapon/computer_hardware/battery_module/micro(src)
+	battery_module.charge_to_full()

code/modules/modular_computers/computers/subtypes/preset_telescreen.dm

@@ -0,0 +1,14 @@
+/obj/item/modular_computer/telescreen/preset/install_default_hardware()
+	..()
+	processor_unit = new/obj/item/weapon/computer_hardware/processor_unit(src)
+	tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(src)
+	hard_drive = new/obj/item/weapon/computer_hardware/hard_drive(src)
+	network_card = new/obj/item/weapon/computer_hardware/network_card(src)
+
+/obj/item/modular_computer/telescreen/preset/generic/install_default_programs()
+	..()
+	hard_drive.store_file(new/datum/computer_file/program/chatclient())
+	hard_drive.store_file(new/datum/computer_file/program/alarm_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/camera_monitor())
+	hard_drive.store_file(new/datum/computer_file/program/email_client())
+	set_autorun("cammon")

code/modules/modular_computers/file_system/computer_file.dm

@@ -0,0 +1,39 @@
+var/global/file_uid = 0
+
+/datum/computer_file/
+	var/filename = "NewFile" 								// Placeholder. No spacebars
+	var/filetype = "XXX" 									// File full names are [filename].[filetype] so like NewFile.XXX in this case
+	var/size = 1											// File size in GQ. Integers only!
+	var/obj/item/weapon/computer_hardware/hard_drive/holder	// Holder that contains this file.
+	var/unsendable = 0										// Whether the file may be sent to someone via NTNet transfer or other means.
+	var/undeletable = 0										// Whether the file may be deleted. Setting to 1 prevents deletion/renaming/etc.
+	var/uid													// UID of this file
+
+/datum/computer_file/New()
+	..()
+	uid = file_uid
+	file_uid++
+
+/datum/computer_file/Destroy()
+	if(!holder)
+		return ..()
+
+	holder.remove_file(src)
+	// holder.holder is the computer that has drive installed. If we are Destroy()ing program that's currently running kill it.
+	if(holder.holder2 && holder.holder2.active_program == src)
+		holder.holder2.kill_program(1)
+	holder = null
+	..()
+
+// Returns independent copy of this file.
+/datum/computer_file/proc/clone(var/rename = 0)
+	var/datum/computer_file/temp = new type
+	temp.unsendable = unsendable
+	temp.undeletable = undeletable
+	temp.size = size
+	if(rename)
+		temp.filename = filename + "(Copy)"
+	else
+		temp.filename = filename
+	temp.filetype = filetype
+	return temp 

code/modules/modular_computers/file_system/data.dm

@@ -0,0 +1,19 @@
+// /data/ files store data in string format.
+// They don't contain other logic for now.
+/datum/computer_file/data
+	var/stored_data = "" 			// Stored data in string format.
+	filetype = "DAT"
+	var/block_size = 250
+	var/do_not_edit = 0				// Whether the user will be reminded that the file probably shouldn't be edited.
+
+/datum/computer_file/data/clone()
+	var/datum/computer_file/data/temp = ..()
+	temp.stored_data = stored_data
+	return temp
+
+// Calculates file size from amount of characters in saved string
+/datum/computer_file/data/proc/calculate_size()
+	size = max(1, round(length(stored_data) / block_size))
+
+/datum/computer_file/data/logfile
+	filetype = "LOG"

code/modules/modular_computers/file_system/news_article.dm

@@ -0,0 +1,24 @@
+// /data/ files store data in string format.
+// They don't contain other logic for now.
+/datum/computer_file/data/news_article
+	filetype = "XNML"
+	filename = "Unknown News Entry"
+	block_size = 5000 		// Results in smaller files
+	do_not_edit = 1			// Editing the file breaks most formatting due to some HTML tags not being accepted as input from average user.
+	var/server_file_path 	// File path to HTML file that will be loaded on server start. Example: '/news_articles/space_magazine_1.html'. Use the /news_articles/ folder!
+	var/archived			// Set to 1 for older stuff
+	var/cover				//filename of cover.
+
+/datum/computer_file/data/news_article/New(var/load_from_file = 0)
+	..()
+	if(server_file_path && load_from_file)
+		stored_data = file2text(server_file_path)
+	calculate_size()
+
+
+// NEWS DEFINITIONS BELOW THIS LINE
+/* KEPT HERE AS AN EXAMPLE
+/datum/computer_file/data/news_article/space/vol_one
+	filename = "SPACE Magazine vol. 1"
+	server_file_path = 'news_articles/space_magazine_1.html'
+*/

code/modules/modular_computers/file_system/program.dm

@@ -0,0 +1,210 @@
+// /program/ files are executable programs that do things.
+/datum/computer_file/program
+	filetype = "PRG"
+	filename = "UnknownProgram"				// File name. FILE NAME MUST BE UNIQUE IF YOU WANT THE PROGRAM TO BE DOWNLOADABLE FROM NTNET!
+	var/required_access = null				// List of required accesses to run/download the program.
+	var/requires_access_to_run = 1			// Whether the program checks for required_access when run.
+	var/requires_access_to_download = 1		// Whether the program checks for required_access when downloading.
+	var/datum/nano_module/NM = null			// If the program uses NanoModule, put it here and it will be automagically opened. Otherwise implement ui_interact.
+	var/nanomodule_path = null				// Path to nanomodule, make sure to set this if implementing new program.
+	var/program_state = PROGRAM_STATE_KILLED// PROGRAM_STATE_KILLED or PROGRAM_STATE_BACKGROUND or PROGRAM_STATE_ACTIVE - specifies whether this program is running.
+	var/obj/item/modular_computer/computer	// Device that runs this program.
+	var/filedesc = "Unknown Program"		// User-friendly name of this program.
+	var/extended_desc = "N/A"				// Short description of this program's function.
+	var/program_icon_state = null			// Program-specific screen icon state
+	var/program_key_state = "standby_key"	// Program-specific keyboard icon state
+	var/program_menu_icon = "newwin"		// Icon to use for program's link in main menu
+	var/requires_ntnet = 0					// Set to 1 for program to require nonstop NTNet connection to run. If NTNet connection is lost program crashes.
+	var/requires_ntnet_feature = 0			// Optional, if above is set to 1 checks for specific function of NTNet (currently NTNET_SOFTWAREDOWNLOAD, NTNET_PEERTOPEER, NTNET_SYSTEMCONTROL and NTNET_COMMUNICATION)
+	var/ntnet_status = 1					// NTNet status, updated every tick by computer running this program. Don't use this for checks if NTNet works, computers do that. Use this for calculations, etc.
+	var/usage_flags = PROGRAM_ALL			// Bitflags (PROGRAM_CONSOLE, PROGRAM_LAPTOP, PROGRAM_TABLET combination) or PROGRAM_ALL
+	var/network_destination = null			// Optional string that describes what NTNet server/system this program connects to. Used in default logging.
+	var/available_on_ntnet = 1				// Whether the program can be downloaded from NTNet. Set to 0 to disable.
+	var/available_on_syndinet = 0			// Whether the program can be downloaded from SyndiNet (accessible via emagging the computer). Set to 1 to enable.
+	var/computer_emagged = 0				// Set to 1 if computer that's running us was emagged. Computer updates this every Process() tick
+	var/ui_header = null					// Example: "something.gif" - a header image that will be rendered in computer's UI when this program is running at background. Images are taken from /nano/images/status_icons. Be careful not to use too large images!
+	var/ntnet_speed = 0						// GQ/s - current network connectivity transfer rate
+
+/datum/computer_file/program/New(var/obj/item/modular_computer/comp = null)
+	..()
+	if(comp && istype(comp))
+		computer = comp
+
+/datum/computer_file/program/Destroy()
+	computer = null
+	. = ..()
+
+/datum/computer_file/program/nano_host()
+	return computer.nano_host()
+
+/datum/computer_file/program/clone()
+	var/datum/computer_file/program/temp = ..()
+	temp.required_access = required_access
+	temp.nanomodule_path = nanomodule_path
+	temp.filedesc = filedesc
+	temp.program_icon_state = program_icon_state
+	temp.requires_ntnet = requires_ntnet
+	temp.requires_ntnet_feature = requires_ntnet_feature
+	temp.usage_flags = usage_flags
+	return temp
+
+// Relays icon update to the computer.
+/datum/computer_file/program/proc/update_computer_icon()
+	if(computer)
+		computer.update_icon()
+
+// Attempts to create a log in global ntnet datum. Returns 1 on success, 0 on fail.
+/datum/computer_file/program/proc/generate_network_log(var/text)
+	if(computer)
+		return computer.add_log(text)
+	return 0
+
+/datum/computer_file/program/proc/is_supported_by_hardware(var/hardware_flag = 0, var/loud = 0, var/mob/user = null)
+	if(!(hardware_flag & usage_flags))
+		if(loud && computer && user)
+			to_chat(user, "<span class='warning'>\The [computer] flashes: \"Hardware Error - Incompatible software\".</span>")
+		return 0
+	return 1
+
+/datum/computer_file/program/proc/get_signal(var/specific_action = 0)
+	if(computer)
+		return computer.get_ntnet_status(specific_action)
+	return 0
+
+// Called by Process() on device that runs us, once every tick.
+/datum/computer_file/program/proc/process_tick()
+	update_netspeed()
+	return 1
+
+/datum/computer_file/program/proc/update_netspeed()
+	ntnet_speed = 0
+	switch(ntnet_status)
+		if(1)
+			ntnet_speed = NTNETSPEED_LOWSIGNAL
+		if(2)
+			ntnet_speed = NTNETSPEED_HIGHSIGNAL
+		if(3)
+			ntnet_speed = NTNETSPEED_ETHERNET
+
+// Check if the user can run program. Only humans can operate computer. Automatically called in run_program()
+// User has to wear their ID or have it inhand for ID Scan to work.
+// Can also be called manually, with optional parameter being access_to_check to scan the user's ID
+/datum/computer_file/program/proc/can_run(var/mob/living/user, var/loud = 0, var/access_to_check)
+	// Defaults to required_access
+	if(!access_to_check)
+		access_to_check = required_access
+	if(!access_to_check) // No required_access, allow it.
+		return 1
+
+	// Admin override - allows operation of any computer as aghosted admin, as if you had any required access.
+	if(istype(user, /mob/observer/dead) && check_rights(R_ADMIN, 0, user))
+		return 1
+
+	if(!istype(user))
+		return 0
+
+	var/obj/item/weapon/card/id/I = user.GetIdCard()
+	if(!I)
+		if(loud)
+			to_chat(user, "<span class='notice'>\The [computer] flashes an \"RFID Error - Unable to scan ID\" warning.</span>")
+		return 0
+
+	if(access_to_check in I.access)
+		return 1
+	else if(loud)
+		to_chat(user, "<span class='notice'>\The [computer] flashes an \"Access Denied\" warning.</span>")
+
+// This attempts to retrieve header data for NanoUIs. If implementing completely new device of different type than existing ones
+// always include the device here in this proc. This proc basically relays the request to whatever is running the program.
+/datum/computer_file/program/proc/get_header_data()
+	if(computer)
+		return computer.get_header_data()
+	return list()
+
+// This is performed on program startup. May be overriden to add extra logic. Remember to include ..() call. Return 1 on success, 0 on failure.
+// When implementing new program based device, use this to run the program.
+/datum/computer_file/program/proc/run_program(var/mob/living/user)
+	if(can_run(user, 1) || !requires_access_to_run)
+		if(nanomodule_path)
+			NM = new nanomodule_path(src, new /datum/topic_manager/program(src), src)
+			NM.using_access = user.GetAccess()
+		if(requires_ntnet && network_destination)
+			generate_network_log("Connection opened to [network_destination].")
+		program_state = PROGRAM_STATE_ACTIVE
+		return 1
+	return 0
+
+// Use this proc to kill the program. Designed to be implemented by each program if it requires on-quit logic, such as the NTNRC client.
+/datum/computer_file/program/proc/kill_program(var/forced = 0)
+	program_state = PROGRAM_STATE_KILLED
+	if(network_destination)
+		generate_network_log("Connection to [network_destination] closed.")
+	if(NM)
+		qdel(NM)
+		NM = null
+	return 1
+
+// This is called every tick when the program is enabled. Ensure you do parent call if you override it. If parent returns 1 continue with UI initialisation.
+// It returns 0 if it can't run or if NanoModule was used instead. I suggest using NanoModules where applicable.
+/datum/computer_file/program/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1)
+	if(program_state != PROGRAM_STATE_ACTIVE) // Our program was closed. Close the ui if it exists.
+		if(ui)
+			ui.close()
+		return computer.ui_interact(user)
+	if(istype(NM))
+		NM.ui_interact(user, ui_key, null, force_open)
+		return 0
+	return 1
+
+
+// CONVENTIONS, READ THIS WHEN CREATING NEW PROGRAM AND OVERRIDING THIS PROC:
+// Topic calls are automagically forwarded from NanoModule this program contains.
+// Calls beginning with "PRG_" are reserved for programs handling.
+// Calls beginning with "PC_" are reserved for computer handling (by whatever runs the program)
+// ALWAYS INCLUDE PARENT CALL ..() OR DIE IN FIRE.
+/datum/computer_file/program/Topic(href, href_list)
+	if(..())
+		return 1
+	if(computer)
+		return computer.Topic(href, href_list)
+
+// Relays the call to nano module, if we have one
+/datum/computer_file/program/proc/check_eye(var/mob/user)
+	if(NM)
+		return NM.check_eye(user)
+	else
+		return -1
+
+/obj/item/modular_computer/initial_data()
+	return get_header_data()
+
+/obj/item/modular_computer/update_layout()
+	return TRUE
+
+/datum/nano_module/program
+	//available_to_ai = FALSE
+	var/datum/computer_file/program/program = null	// Program-Based computer program that runs this nano module. Defaults to null.
+
+/datum/nano_module/program/New(var/host, var/topic_manager, var/program)
+	..()
+	src.program = program
+
+/datum/topic_manager/program
+	var/datum/program
+
+/datum/topic_manager/program/New(var/datum/program)
+	..()
+	src.program = program
+
+// Calls forwarded to PROGRAM itself should begin with "PRG_"
+// Calls forwarded to COMPUTER running the program should begin with "PC_"
+/datum/topic_manager/program/Topic(href, href_list)
+	return program && program.Topic(href, href_list)
+
+/datum/computer_file/program/apply_visual(mob/M)
+	if(NM)
+		NM.apply_visual(M)
+
+/datum/computer_file/program/remove_visual(mob/M)
+	if(NM)
+		NM.remove_visual(M)

code/modules/modular_computers/file_system/program_events.dm

@@ -0,0 +1,18 @@
+// Events are sent to the program by the computer.
+// Always include a parent call when overriding an event.
+
+// Called when the ID card is removed from computer. ID is removed AFTER this proc.
+/datum/computer_file/program/proc/event_idremoved(var/background)
+	return
+
+// Called when the computer fails due to power loss. Override when program wants to specifically react to power loss.
+/datum/computer_file/program/proc/event_powerfailure(var/background)
+	kill_program(1)
+
+// Called when the network connectivity fails. Computer does necessary checks and only calls this when requires_ntnet_feature and similar variables are not met.
+/datum/computer_file/program/proc/event_networkfailure(var/background)
+	kill_program(1)
+	if(background)
+		computer.visible_message("<span class='warning'>\The [computer]'s screen displays an error: \"Network connectivity lost - process [filename].[filetype] (PID [rand(100,999)]) terminated.\"</span>", 1)
+	else
+		computer.visible_message("<span class='warning'>\The [computer]'s screen briefly freezes and then shows: \"FATAL NETWORK ERROR - NTNet connection lost. Please try again later. If problem persists, please contact your system administrator.\"</span>", 1)

code/modules/modular_computers/file_system/programs/antagonist/access_decrypter.dm

@@ -0,0 +1,129 @@
+/datum/computer_file/program/access_decrypter
+	filename = "nt_accrypt"
+	filedesc = "NTNet Access Decrypter"
+	program_icon_state = "hostile"
+	program_key_state = "security_key"
+	program_menu_icon = "unlocked"
+	extended_desc = "This highly advanced script can very slowly decrypt operational codes used in almost any network. These codes can be downloaded to an ID card to expand the available access. The system administrator will probably notice this."
+	size = 34
+	requires_ntnet = 1
+	available_on_ntnet = 0
+	available_on_syndinet = 1
+	nanomodule_path = /datum/nano_module/program/access_decrypter/
+	var/message = ""
+	var/running = FALSE
+	var/progress = 0
+	var/target_progress = 300
+	var/datum/access/target_access = null
+
+/datum/computer_file/program/access_decrypter/kill_program(var/forced)
+	reset()
+	..(forced)
+
+/datum/computer_file/program/access_decrypter/proc/reset()
+	running = FALSE
+	message = ""
+	progress = 0
+
+/datum/computer_file/program/access_decrypter/process_tick()
+	. = ..()
+	if(!running)
+		return
+	var/obj/item/weapon/computer_hardware/processor_unit/CPU = computer.processor_unit
+	var/obj/item/weapon/computer_hardware/card_slot/RFID = computer.card_slot
+	if(!istype(CPU) || !CPU.check_functionality() || !istype(RFID) || !RFID.check_functionality())
+		message = "A fatal hardware error has been detected."
+		return
+	if(!istype(RFID.stored_card))
+		message = "RFID card has been removed from the device. Operation aborted."
+		return
+
+	progress += CPU.max_idle_programs
+	if(progress >= target_progress)
+		reset()
+		RFID.stored_card.access |= target_access.id
+		if(ntnet_global.intrusion_detection_enabled)
+			ntnet_global.add_log("IDS WARNING - Unauthorised access to primary keycode database from device: [computer.network_card.get_network_tag()]  - downloaded access codes for: [target_access.desc].")
+			ntnet_global.intrusion_detection_alarm = 1
+		message = "Successfully decrypted and saved operational key codes. Downloaded access codes for: [target_access.desc]"
+		target_access = null
+
+/datum/computer_file/program/access_decrypter/Topic(href, href_list)
+	if(..())
+		return 1
+	if(href_list["PRG_reset"])
+		reset()
+		return 1
+	if(href_list["PRG_execute"])
+		if(running)
+			return 1
+		if(text2num(href_list["allowed"]))
+			return 1
+		var/obj/item/weapon/computer_hardware/processor_unit/CPU = computer.processor_unit
+		var/obj/item/weapon/computer_hardware/card_slot/RFID = computer.card_slot
+		if(!istype(CPU) || !CPU.check_functionality() || !istype(RFID) || !RFID.check_functionality())
+			message = "A fatal hardware error has been detected."
+			return
+		if(!istype(RFID.stored_card))
+			message = "RFID card is not present in the device. Operation aborted."
+			return
+		running = TRUE
+		target_access = get_access_by_id(href_list["PRG_execute"])
+		if(ntnet_global.intrusion_detection_enabled)
+			ntnet_global.add_log("IDS WARNING - Unauthorised access attempt to primary keycode database from device: [computer.network_card.get_network_tag()]")
+			ntnet_global.intrusion_detection_alarm = 1
+		return 1
+
+/datum/nano_module/program/access_decrypter
+	name = "NTNet Access Decrypter"
+	var/list/restricted_access_codes = list(access_change_ids, access_network) // access codes that are not hackable due to balance reasons
+
+/datum/nano_module/program/access_decrypter/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(!ntnet_global)
+		return
+	var/datum/computer_file/program/access_decrypter/PRG = program
+	var/list/data = list()
+	if(!istype(PRG))
+		return
+	data = PRG.get_header_data()
+
+	if(PRG.message)
+		data["message"] = PRG.message
+	else if(PRG.running)
+		data["running"] = 1
+		data["rate"] = PRG.computer.processor_unit.max_idle_programs
+
+		// Stolen from DOS traffic generator, generates strings of 1s and 0s
+		var/percentage = (PRG.progress / PRG.target_progress) * 100
+		var/list/strings[0]
+		for(var/j, j<10, j++)
+			var/string = ""
+			for(var/i, i<20, i++)
+				string = "[string][prob(percentage)]"
+			strings.Add(string)
+		data["dos_strings"] = strings
+	else if(program.computer.card_slot && program.computer.card_slot.stored_card)
+		var/obj/item/weapon/card/id/id_card = program.computer.card_slot.stored_card
+		var/list/regions = list()
+		for(var/i = 1; i <= 7; i++)
+			var/list/accesses = list()
+			for(var/access in get_region_accesses(i))
+				if (get_access_desc(access))
+					accesses.Add(list(list(
+						"desc" = replacetext(get_access_desc(access), " ", "&nbsp"),
+						"ref" = access,
+						"allowed" = (access in id_card.access) ? 1 : 0,
+						"blocked" = (access in restricted_access_codes) ? 1 : 0)))
+
+			regions.Add(list(list(
+				"name" = get_region_accesses_name(i),
+				"accesses" = accesses)))
+		data["regions"] = regions
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "access_decrypter.tmpl", "NTNet Access Decrypter", 550, 400, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)

code/modules/modular_computers/file_system/programs/antagonist/dos.dm

@@ -0,0 +1,108 @@
+/datum/computer_file/program/ntnet_dos
+	filename = "ntn_dos"
+	filedesc = "DoS Traffic Generator"
+	program_icon_state = "hostile"
+	program_key_state = "security_key"
+	program_menu_icon = "arrow-4-diag"
+	extended_desc = "This advanced script can perform denial of service attacks against NTNet quantum relays. The system administrator will probably notice this. Multiple devices can run this program together against same relay for increased effect"
+	size = 20
+	requires_ntnet = 1
+	available_on_ntnet = 0
+	available_on_syndinet = 1
+	nanomodule_path = /datum/nano_module/program/computer_dos/
+	var/obj/machinery/ntnet_relay/target = null
+	var/dos_speed = 0
+	var/error = ""
+	var/executed = 0
+
+/datum/computer_file/program/ntnet_dos/process_tick()
+	dos_speed = 0
+	switch(ntnet_status)
+		if(1)
+			dos_speed = NTNETSPEED_LOWSIGNAL * NTNETSPEED_DOS_AMPLIFICATION
+		if(2)
+			dos_speed = NTNETSPEED_HIGHSIGNAL * NTNETSPEED_DOS_AMPLIFICATION
+		if(3)
+			dos_speed = NTNETSPEED_ETHERNET * NTNETSPEED_DOS_AMPLIFICATION
+	if(target && executed)
+		target.dos_overload += dos_speed
+		if(!target.operable())
+			target.dos_sources.Remove(src)
+			target = null
+			error = "Connection to destination relay lost."
+
+/datum/computer_file/program/ntnet_dos/kill_program(var/forced)
+	if(target)
+		target.dos_sources.Remove(src)
+		target = null
+	executed = 0
+
+	..(forced)
+
+/datum/nano_module/program/computer_dos
+	name = "DoS Traffic Generator"
+
+/datum/nano_module/program/computer_dos/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(!ntnet_global)
+		return
+	var/datum/computer_file/program/ntnet_dos/PRG = program
+	var/list/data = list()
+	if(!istype(PRG))
+		return
+	data = PRG.get_header_data()
+
+	if(PRG.error)
+		data["error"] = PRG.error
+	else if(PRG.target && PRG.executed)
+		data["target"] = 1
+		data["speed"] = PRG.dos_speed
+
+		// This is mostly visual, generate some strings of 1s and 0s
+		// Probability of 1 is equal of completion percentage of DoS attack on this relay.
+		// Combined with UI updates this adds quite nice effect to the UI
+		var/percentage = PRG.target.dos_overload * 100 / PRG.target.dos_capacity
+		var/list/strings[0]
+		for(var/j, j<10, j++)
+			var/string = ""
+			for(var/i, i<20, i++)
+				string = "[string][prob(percentage)]"
+			strings.Add(string)
+		data["dos_strings"] = strings
+	else
+		var/list/relays[0]
+		for(var/obj/machinery/ntnet_relay/R in ntnet_global.relays)
+			relays.Add(R.uid)
+		data["relays"] = relays
+		data["focus"] = PRG.target ? PRG.target.uid : null
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "ntnet_dos.tmpl", "DoS Traffic Generator", 400, 250, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+/datum/computer_file/program/ntnet_dos/Topic(href, href_list)
+	if(..())
+		return 1
+	if(href_list["PRG_target_relay"])
+		for(var/obj/machinery/ntnet_relay/R in ntnet_global.relays)
+			if("[R.uid]" == href_list["PRG_target_relay"])
+				target = R
+		return 1
+	if(href_list["PRG_reset"])
+		if(target)
+			target.dos_sources.Remove(src)
+			target = null
+		executed = 0
+		error = ""
+		return 1
+	if(href_list["PRG_execute"])
+		if(target)
+			executed = 1
+			target.dos_sources.Add(src)
+			if(ntnet_global.intrusion_detection_enabled)
+				ntnet_global.add_log("IDS WARNING - Excess traffic flood targeting relay [target.uid] detected from device: [computer.network_card.get_network_tag()]")
+				ntnet_global.intrusion_detection_alarm = 1
+		return 1

code/modules/modular_computers/file_system/programs/antagonist/hacked_camera.dm

@@ -0,0 +1,39 @@
+/datum/computer_file/program/camera_monitor/hacked
+	filename = "camcrypt"
+	filedesc = "Camera Decryption Tool"
+	nanomodule_path = /datum/nano_module/camera_monitor/hacked
+	program_icon_state = "hostile"
+	program_key_state = "security_key"
+	program_menu_icon = "zoomin"
+	extended_desc = "This very advanced piece of software uses adaptive programming and large database of cipherkeys to bypass most encryptions used on camera networks. Be warned that system administrator may notice this."
+	size = 73 // Very large, a price for bypassing ID checks completely.
+	available_on_ntnet = 0
+	available_on_syndinet = 1
+
+/datum/computer_file/program/camera_monitor/hacked/process_tick()
+	..()
+	if(program_state != PROGRAM_STATE_ACTIVE) // Background programs won't trigger alarms.
+		return
+
+	var/datum/nano_module/camera_monitor/hacked/HNM = NM
+
+	// The program is active and connected to one of the station's networks. Has a very small chance to trigger IDS alarm every tick.
+	if(HNM && HNM.current_network && (HNM.current_network in using_map.station_networks) && prob(0.1))
+		if(ntnet_global.intrusion_detection_enabled)
+			ntnet_global.add_log("IDS WARNING - Unauthorised access detected to camera network [HNM.current_network] by device with NID [computer.network_card.get_network_tag()]")
+			ntnet_global.intrusion_detection_alarm = 1
+
+
+/datum/nano_module/camera_monitor/hacked
+	name = "Hacked Camera Monitoring Program"
+	//available_to_ai = FALSE
+
+/datum/nano_module/camera_monitor/hacked/can_access_network(var/mob/user, var/network_access)
+	return 1
+
+// The hacked variant has access to all commonly used networks.
+/datum/nano_module/camera_monitor/hacked/modify_networks_list(var/list/networks)
+	networks.Add(list(list("tag" = NETWORK_MERCENARY, "has_access" = 1)))
+	networks.Add(list(list("tag" = NETWORK_ERT, "has_access" = 1)))
+	networks.Add(list(list("tag" = NETWORK_CRESCENT, "has_access" = 1)))
+	return networks

code/modules/modular_computers/file_system/programs/antagonist/revelation.dm

@@ -0,0 +1,84 @@
+/datum/computer_file/program/revelation
+	filename = "revelation"
+	filedesc = "Revelation"
+	program_icon_state = "hostile"
+	program_key_state = "security_key"
+	program_menu_icon = "home"
+	extended_desc = "This virus can destroy hard drive of system it is executed on. It may be obfuscated to look like another non-malicious program. Once armed, it will destroy the system upon next execution."
+	size = 13
+	requires_ntnet = 0
+	available_on_ntnet = 0
+	available_on_syndinet = 1
+	nanomodule_path = /datum/nano_module/program/revelation/
+	var/armed = 0
+
+/datum/computer_file/program/revelation/run_program(var/mob/living/user)
+	. = ..(user)
+	if(armed)
+		activate()
+
+/datum/computer_file/program/revelation/proc/activate()
+	if(!computer)
+		return
+
+	computer.visible_message("<span class='notice'>\The [computer]'s screen brightly flashes and loud electrical buzzing is heard.</span>")
+	computer.enabled = 0
+	computer.update_icon()
+	var/datum/effect/effect/system/spark_spread/s = new /datum/effect/effect/system/spark_spread
+	s.set_up(10, 1, computer.loc)
+	s.start()
+
+	if(computer.hard_drive)
+		qdel(computer.hard_drive)
+
+	if(computer.battery_module && prob(25))
+		qdel(computer.battery_module)
+
+	if(computer.tesla_link && prob(50))
+		qdel(computer.tesla_link)
+
+/datum/computer_file/program/revelation/Topic(href, href_list)
+	if(..())
+		return 1
+	else if(href_list["PRG_arm"])
+		armed = !armed
+	else if(href_list["PRG_activate"])
+		activate()
+	else if(href_list["PRG_obfuscate"])
+		var/mob/living/user = usr
+		var/newname = sanitize(input(user, "Enter new program name: "))
+		if(!newname)
+			return
+		filedesc = newname
+		for(var/datum/computer_file/program/P in ntnet_global.available_station_software)
+			if(filedesc == P.filedesc)
+				program_menu_icon = P.program_menu_icon
+				break
+	return 1
+
+/datum/computer_file/program/revelation/clone()
+	var/datum/computer_file/program/revelation/temp = ..()
+	temp.armed = armed
+	return temp
+
+/datum/nano_module/program/revelation
+	name = "Revelation Virus"
+
+/datum/nano_module/program/revelation/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = list()
+	var/datum/computer_file/program/revelation/PRG = program
+	if(!istype(PRG))
+		return
+
+	data = PRG.get_header_data()
+
+	data["armed"] = PRG.armed
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "revelation.tmpl", "Revelation Virus", 400, 250, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+

code/modules/modular_computers/file_system/programs/command/card.dm

@@ -0,0 +1,233 @@
+/datum/computer_file/program/card_mod
+	filename = "cardmod"
+	filedesc = "ID card modification program"
+	nanomodule_path = /datum/nano_module/program/card_mod
+	program_icon_state = "id"
+	program_key_state = "id_key"
+	program_menu_icon = "key"
+	extended_desc = "Program for programming crew ID cards."
+	required_access = access_change_ids
+	requires_ntnet = 0
+	size = 8
+
+/datum/nano_module/program/card_mod
+	name = "ID card modification program"
+	var/mod_mode = 1
+	var/is_centcom = 0
+	var/show_assignments = 0
+
+/datum/nano_module/program/card_mod/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	data["src"] = "\ref[src]"
+	data["station_name"] = station_name()
+	data["manifest"] = data_core ? data_core.get_manifest(0) : null
+	data["assignments"] = show_assignments
+	if(program && program.computer)
+		data["have_id_slot"] = !!program.computer.card_slot
+		data["have_printer"] = !!program.computer.nano_printer
+		data["authenticated"] = program.can_run(user)
+		if(!program.computer.card_slot)
+			mod_mode = 0 //We can't modify IDs when there is no card reader
+	else
+		data["have_id_slot"] = 0
+		data["have_printer"] = 0
+		data["authenticated"] = 0
+	data["mmode"] = mod_mode
+	data["centcom_access"] = is_centcom
+
+	if(program && program.computer && program.computer.card_slot)
+		var/obj/item/weapon/card/id/id_card = program.computer.card_slot.stored_card
+		data["has_id"] = !!id_card
+		data["id_account_number"] = id_card ? id_card.associated_account_number : null
+		data["id_rank"] = id_card && id_card.assignment ? id_card.assignment : "Unassigned"
+		data["id_owner"] = id_card && id_card.registered_name ? id_card.registered_name : "-----"
+		data["id_name"] = id_card ? id_card.name : "-----"
+
+	data["command_jobs"] = format_jobs(command_positions)
+	data["engineering_jobs"] = format_jobs(engineering_positions)
+	data["medical_jobs"] = format_jobs(medical_positions)
+	data["science_jobs"] = format_jobs(science_positions)
+	data["security_jobs"] = format_jobs(security_positions)
+	data["cargo_jobs"] = format_jobs(cargo_positions)
+	data["civilian_jobs"] = format_jobs(civilian_positions)
+	data["centcom_jobs"] = format_jobs(get_all_centcom_jobs())
+
+	data["all_centcom_access"] = is_centcom ? get_accesses(1) : null
+	data["regions"] = get_accesses()
+
+	if(program.computer.card_slot && program.computer.card_slot.stored_card)
+		var/obj/item/weapon/card/id/id_card = program.computer.card_slot.stored_card
+		if(is_centcom)
+			var/list/all_centcom_access = list()
+			for(var/access in get_all_centcom_access())
+				all_centcom_access.Add(list(list(
+					"desc" = replacetext(get_centcom_access_desc(access), " ", "&nbsp"),
+					"ref" = access,
+					"allowed" = (access in id_card.access) ? 1 : 0)))
+			data["all_centcom_access"] = all_centcom_access
+		else
+			var/list/regions = list()
+			for(var/i = 1; i <= 7; i++)
+				var/list/accesses = list()
+				for(var/access in get_region_accesses(i))
+					if (get_access_desc(access))
+						accesses.Add(list(list(
+							"desc" = replacetext(get_access_desc(access), " ", "&nbsp"),
+							"ref" = access,
+							"allowed" = (access in id_card.access) ? 1 : 0)))
+
+				regions.Add(list(list(
+					"name" = get_region_accesses_name(i),
+					"accesses" = accesses)))
+			data["regions"] = regions
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "mod_identification_computer.tmpl", name, 600, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+
+/datum/nano_module/program/card_mod/proc/format_jobs(list/jobs)
+	var/obj/item/weapon/card/id/id_card = program.computer.card_slot ? program.computer.card_slot.stored_card : null
+	var/list/formatted = list()
+	for(var/job in jobs)
+		formatted.Add(list(list(
+			"display_name" = replacetext(job, " ", "&nbsp"),
+			"target_rank" = id_card && id_card.assignment ? id_card.assignment : "Unassigned",
+			"job" = job)))
+
+	return formatted
+
+/datum/nano_module/program/card_mod/proc/get_accesses(var/is_centcom = 0)
+	return null
+
+
+/datum/computer_file/program/card_mod/Topic(href, href_list)
+	if(..())
+		return 1
+
+	var/mob/user = usr
+	var/obj/item/weapon/card/id/user_id_card = user.GetIdCard()
+	var/obj/item/weapon/card/id/id_card
+	if (computer.card_slot)
+		id_card = computer.card_slot.stored_card
+
+	var/datum/nano_module/program/card_mod/module = NM
+	switch(href_list["action"])
+		if("switchm")
+			if(href_list["target"] == "mod")
+				module.mod_mode = 1
+			else if (href_list["target"] == "manifest")
+				module.mod_mode = 0
+		if("togglea")
+			if(module.show_assignments)
+				module.show_assignments = 0
+			else
+				module.show_assignments = 1
+		if("print")
+			if(computer && computer.nano_printer) //This option should never be called if there is no printer
+				if(module.mod_mode)
+					if(can_run(user, 1))
+						var/contents = {"<h4>Access Report</h4>
+									<u>Prepared By:</u> [user_id_card.registered_name ? user_id_card.registered_name : "Unknown"]<br>
+									<u>For:</u> [id_card.registered_name ? id_card.registered_name : "Unregistered"]<br>
+									<hr>
+									<u>Assignment:</u> [id_card.assignment]<br>
+									<u>Account Number:</u> #[id_card.associated_account_number]<br>
+									<u>Blood Type:</u> [id_card.blood_type]<br><br>
+									<u>Access:</u><br>
+								"}
+
+						var/known_access_rights = get_access_ids(ACCESS_TYPE_STATION|ACCESS_TYPE_CENTCOM)
+						for(var/A in id_card.access)
+							if(A in known_access_rights)
+								contents += "  [get_access_desc(A)]"
+
+						if(!computer.nano_printer.print_text(contents,"access report"))
+							to_chat(usr, "<span class='notice'>Hardware error: Printer was unable to print the file. It may be out of paper.</span>")
+							return
+						else
+							computer.visible_message("<span class='notice'>\The [computer] prints out paper.</span>")
+				else
+					var/contents = {"<h4>Crew Manifest</h4>
+									<br>
+									[data_core ? data_core.get_manifest(0) : ""]
+									"}
+					if(!computer.nano_printer.print_text(contents,text("crew manifest ([])", stationtime2text())))
+						to_chat(usr, "<span class='notice'>Hardware error: Printer was unable to print the file. It may be out of paper.</span>")
+						return
+					else
+						computer.visible_message("<span class='notice'>\The [computer] prints out paper.</span>")
+		if("eject")
+			if(computer && computer.card_slot)
+				if(id_card)
+					data_core.manifest_modify(id_card.registered_name, id_card.assignment)
+				computer.proc_eject_id(user)
+		if("terminate")
+			if(computer && can_run(user, 1))
+				id_card.assignment = "Terminated"
+				remove_nt_access(id_card)
+				callHook("terminate_employee", list(id_card))
+		if("edit")
+			if(computer && can_run(user, 1))
+				if(href_list["name"])
+					var/temp_name = sanitizeName(input("Enter name.", "Name", id_card.registered_name),allow_numbers=TRUE)
+					if(temp_name)
+						id_card.registered_name = temp_name
+					else
+						computer.visible_message("<span class='notice'>[computer] buzzes rudely.</span>")
+				else if(href_list["account"])
+					var/account_num = text2num(input("Enter account number.", "Account", id_card.associated_account_number))
+					id_card.associated_account_number = account_num
+		if("assign")
+			if(computer && can_run(user, 1) && id_card)
+				var/t1 = href_list["assign_target"]
+				if(t1 == "Custom")
+					var/temp_t = sanitize(input("Enter a custom job assignment.","Assignment", id_card.assignment), 45)
+					//let custom jobs function as an impromptu alt title, mainly for sechuds
+					if(temp_t)
+						id_card.assignment = temp_t
+				else
+					var/list/access = list()
+					if(module.is_centcom)
+						access = get_centcom_access(t1)
+					else
+						var/datum/job/jobdatum
+						for(var/jobtype in typesof(/datum/job))
+							var/datum/job/J = new jobtype
+							if(ckey(J.title) == ckey(t1))
+								jobdatum = J
+								break
+						if(!jobdatum)
+							to_chat(usr, "<span class='warning'>No log exists for this job: [t1]</span>")
+							return
+
+						access = jobdatum.get_access()
+
+					remove_nt_access(id_card)
+					apply_access(id_card, access)
+					id_card.assignment = t1
+					id_card.rank = t1
+
+				callHook("reassign_employee", list(id_card))
+		if("access")
+			if(href_list["allowed"] && computer && can_run(user, 1))
+				var/access_type = text2num(href_list["access_target"])
+				var/access_allowed = text2num(href_list["allowed"])
+				if(access_type in get_access_ids(ACCESS_TYPE_STATION|ACCESS_TYPE_CENTCOM))
+					id_card.access -= access_type
+					if(!access_allowed)
+						id_card.access += access_type
+	if(id_card)
+		id_card.name = text("[id_card.registered_name]'s ID Card ([id_card.assignment])")
+
+	SSnanoui.update_uis(NM)
+	return 1
+
+/datum/computer_file/program/card_mod/proc/remove_nt_access(var/obj/item/weapon/card/id/id_card)
+	id_card.access -= get_access_ids(ACCESS_TYPE_STATION|ACCESS_TYPE_CENTCOM)
+
+/datum/computer_file/program/card_mod/proc/apply_access(var/obj/item/weapon/card/id/id_card, var/list/accesses)
+	id_card.access |= accesses

code/modules/modular_computers/file_system/programs/command/comm.dm

@@ -0,0 +1,326 @@
+#define STATE_DEFAULT	1
+#define STATE_MESSAGELIST	2
+#define STATE_VIEWMESSAGE	3
+#define STATE_STATUSDISPLAY	4
+#define STATE_ALERT_LEVEL	5
+/datum/computer_file/program/comm
+	filename = "comm"
+	filedesc = "Command and Communications Program"
+	program_icon_state = "comm"
+	program_key_state = "med_key"
+	program_menu_icon = "flag"
+	nanomodule_path = /datum/nano_module/program/comm
+	extended_desc = "Used to command and control. Can relay long-range communications. This program can not be run on tablet computers."
+	required_access = access_heads
+	requires_ntnet = 1
+	size = 12
+	usage_flags = PROGRAM_CONSOLE | PROGRAM_LAPTOP
+	network_destination = "long-range communication array"
+	var/datum/comm_message_listener/message_core = new
+
+/datum/computer_file/program/comm/clone()
+	var/datum/computer_file/program/comm/temp = ..()
+	temp.message_core.messages = null
+	temp.message_core.messages = message_core.messages.Copy()
+	return temp
+
+/datum/nano_module/program/comm
+	name = "Command and Communications Program"
+	//available_to_ai = TRUE
+	var/current_status = STATE_DEFAULT
+	var/msg_line1 = ""
+	var/msg_line2 = ""
+	var/centcomm_message_cooldown = 0
+	var/announcment_cooldown = 0
+	var/datum/announcement/priority/crew_announcement = new
+	var/current_viewing_message_id = 0
+	var/current_viewing_message = null
+
+/datum/nano_module/program/comm/New()
+	..()
+	crew_announcement.newscast = 1
+
+/datum/nano_module/program/comm/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	if(program)
+		data["emagged"] = program.computer_emagged
+		data["net_comms"] = !!program.get_signal(NTNET_COMMUNICATION) //Double !! is needed to get 1 or 0 answer
+		data["net_syscont"] = !!program.get_signal(NTNET_SYSTEMCONTROL)
+		if(program.computer)
+			data["have_printer"] = !!program.computer.nano_printer
+		else
+			data["have_printer"] = 0
+	else
+		data["emagged"] = 0
+		data["net_comms"] = 1
+		data["net_syscont"] = 1
+		data["have_printer"] = 0
+
+	data["message_line1"] = msg_line1
+	data["message_line2"] = msg_line2
+	data["state"] = current_status
+	data["isAI"] = issilicon(usr)
+	data["authenticated"] = is_autenthicated(user)
+	data["current_security_level"] = security_level
+	data["current_security_level_title"] = num2seclevel(security_level)
+
+	data["def_SEC_LEVEL_DELTA"] = SEC_LEVEL_DELTA
+	data["def_SEC_LEVEL_YELLOW"] = SEC_LEVEL_YELLOW
+	data["def_SEC_LEVEL_ORANGE"] = SEC_LEVEL_ORANGE
+	data["def_SEC_LEVEL_VIOLET"] = SEC_LEVEL_VIOLET
+	data["def_SEC_LEVEL_BLUE"] = SEC_LEVEL_BLUE
+	data["def_SEC_LEVEL_GREEN"] = SEC_LEVEL_GREEN
+
+	var/datum/comm_message_listener/l = obtain_message_listener()
+	data["messages"] = l.messages
+	data["message_deletion_allowed"] = l != global_message_listener
+	data["message_current_id"] = current_viewing_message_id
+	if(current_viewing_message)
+		data["message_current"] = current_viewing_message
+
+	if(emergency_shuttle.location())
+		data["have_shuttle"] = 1
+		if(emergency_shuttle.online())
+			data["have_shuttle_called"] = 1
+		else
+			data["have_shuttle_called"] = 0
+	else
+		data["have_shuttle"] = 0
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "mod_communication.tmpl", name, 550, 420, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+
+/datum/nano_module/program/comm/proc/is_autenthicated(var/mob/user)
+	if(program)
+		return program.can_run(user)
+	return 1
+
+/datum/nano_module/program/comm/proc/obtain_message_listener()
+	if(program)
+		var/datum/computer_file/program/comm/P = program
+		return P.message_core
+	return global_message_listener
+
+/datum/nano_module/program/comm/Topic(href, href_list)
+	if(..())
+		return 1
+	var/mob/user = usr
+	var/ntn_comm = program ? !!program.get_signal(NTNET_COMMUNICATION) : 1
+	var/ntn_cont = program ? !!program.get_signal(NTNET_SYSTEMCONTROL) : 1
+	var/datum/comm_message_listener/l = obtain_message_listener()
+	switch(href_list["action"])
+		if("sw_menu")
+			. = 1
+			current_status = text2num(href_list["target"])
+		if("announce")
+			. = 1
+			if(is_autenthicated(user) && !issilicon(usr) && ntn_comm)
+				if(user)
+					var/obj/item/weapon/card/id/id_card = user.GetIdCard()
+					crew_announcement.announcer = GetNameAndAssignmentFromId(id_card)
+				else
+					crew_announcement.announcer = "Unknown"
+				if(announcment_cooldown)
+					to_chat(usr, "Please allow at least one minute to pass between announcements")
+					return TRUE
+				var/input = input(usr, "Please write a message to announce to the station crew.", "Priority Announcement") as null|text
+				if(!input || !can_still_topic())
+					return 1
+				crew_announcement.Announce(input)
+				announcment_cooldown = 1
+				spawn(600)//One minute cooldown
+					announcment_cooldown = 0
+		if("message")
+			. = 1
+			if(href_list["target"] == "emagged")
+				if(program)
+					if(is_autenthicated(user) && program.computer_emagged && !issilicon(usr) && ntn_comm)
+						if(centcomm_message_cooldown)
+							to_chat(usr, "<span class='warning'>Arrays recycling. Please stand by.</span>")
+							SSnanoui.update_uis(src)
+							return
+						var/input = sanitize(input(usr, "Please choose a message to transmit to \[ABNORMAL ROUTING CORDINATES\] via quantum entanglement.  Please be aware that this process is very expensive, and abuse will lead to... termination. Transmission does not guarantee a response. There is a 30 second delay before you may send another message, be clear, full and concise.", "To abort, send an empty message.", "") as null|text)
+						if(!input || !can_still_topic())
+							return 1
+						Syndicate_announce(input, usr)
+						to_chat(usr, "<span class='notice'>Message transmitted.</span>")
+						log_say("[key_name(usr)] has made an illegal announcement: [input]")
+						centcomm_message_cooldown = 1
+						spawn(300)//30 second cooldown
+							centcomm_message_cooldown = 0
+			else if(href_list["target"] == "regular")
+				if(is_autenthicated(user) && !issilicon(usr) && ntn_comm)
+					if(centcomm_message_cooldown)
+						to_chat(usr, "<span class='warning'>Arrays recycling. Please stand by.</span>")
+						SSnanoui.update_uis(src)
+						return
+					if(!is_relay_online())//Contact Centcom has a check, Syndie doesn't to allow for Traitor funs.
+						to_chat(usr, "<span class='warning'>No Emergency Bluespace Relay detected. Unable to transmit message.</span>")
+						return 1
+					var/input = sanitize(input("Please choose a message to transmit to Centcomm via quantum entanglement.  Please be aware that this process is very expensive, and abuse will lead to... termination.  Transmission does not guarantee a response. There is a 30 second delay before you may send another message, be clear, full and concise.", "To abort, send an empty message.", "") as null|text)
+					if(!input || !can_still_topic())
+						return 1
+					CentCom_announce(input, usr)
+					to_chat(usr, "<span class='notice'>Message transmitted.</span>")
+					log_say("[key_name(usr)] has made an IA Centcomm announcement: [input]")
+					centcomm_message_cooldown = 1
+					spawn(300) //30 second cooldown
+						centcomm_message_cooldown = 0
+		if("shuttle")
+			. = 1
+			if(is_autenthicated(user) && ntn_cont)
+				if(href_list["target"] == "call")
+					var/confirm = alert("Are you sure you want to call the shuttle?", name, "No", "Yes")
+					if(confirm == "Yes" && can_still_topic())
+						call_shuttle_proc(usr)
+
+				if(href_list["target"] == "cancel" && !issilicon(usr))
+					var/confirm = alert("Are you sure you want to cancel the shuttle?", name, "No", "Yes")
+					if(confirm == "Yes" && can_still_topic())
+						cancel_call_proc(usr)
+		if("setstatus")
+			. = 1
+			if(is_autenthicated(user) && ntn_cont)
+				switch(href_list["target"])
+					if("line1")
+						var/linput = reject_bad_text(sanitize(input("Line 1", "Enter Message Text", msg_line1) as text|null, 40), 40)
+						if(can_still_topic())
+							msg_line1 = linput
+					if("line2")
+						var/linput = reject_bad_text(sanitize(input("Line 2", "Enter Message Text", msg_line2) as text|null, 40), 40)
+						if(can_still_topic())
+							msg_line2 = linput
+					if("message")
+						post_status("message", msg_line1, msg_line2)
+					if("alert")
+						post_status("alert", href_list["alert"])
+					else
+						post_status(href_list["target"])
+		if("setalert")
+			. = 1
+			if(is_autenthicated(user) && !issilicon(usr) && ntn_cont && ntn_comm)
+				var/current_level = text2num(href_list["target"])
+				var/confirm = alert("Are you sure you want to change alert level to [num2seclevel(current_level)]?", name, "No", "Yes")
+				if(confirm == "Yes" && can_still_topic())
+					var/old_level = security_level
+					if(!current_level) current_level = SEC_LEVEL_GREEN
+					if(current_level < SEC_LEVEL_GREEN) current_level = SEC_LEVEL_GREEN
+					if(current_level > SEC_LEVEL_BLUE) current_level = SEC_LEVEL_BLUE //Cannot engage delta with this
+					set_security_level(current_level)
+					if(security_level != old_level)
+						log_game("[key_name(usr)] has changed the security level to [get_security_level()].")
+						message_admins("[key_name_admin(usr)] has changed the security level to [get_security_level()].")
+						switch(security_level)
+							if(SEC_LEVEL_GREEN)
+								feedback_inc("alert_comms_green",1)
+							if(SEC_LEVEL_YELLOW)
+								feedback_inc("alert_comms_yellow",1)
+							if(SEC_LEVEL_ORANGE)
+								feedback_inc("alert_comms_orange",1)
+							if(SEC_LEVEL_VIOLET)
+								feedback_inc("alert_comms_violet",1)
+							if(SEC_LEVEL_BLUE)
+								feedback_inc("alert_comms_blue",1)
+			else
+				to_chat(usr, "You press button, but red light flashes and nothing happens.")//This should never happen
+
+			current_status = STATE_DEFAULT
+		if("viewmessage")
+			. = 1
+			if(is_autenthicated(user) && ntn_comm)
+				current_viewing_message_id = text2num(href_list["target"])
+				for(var/list/m in l.messages)
+					if(m["id"] == current_viewing_message_id)
+						current_viewing_message = m
+				current_status = STATE_VIEWMESSAGE
+		if("delmessage")
+			. = 1
+			if(is_autenthicated(user) && ntn_comm && l != global_message_listener)
+				l.Remove(current_viewing_message)
+			current_status = STATE_MESSAGELIST
+		if("printmessage")
+			. = 1
+			if(is_autenthicated(user) && ntn_comm)
+				if(program && program.computer && program.computer.nano_printer)
+					if(!program.computer.nano_printer.print_text(current_viewing_message["contents"],current_viewing_message["title"]))
+						to_chat(usr, "<span class='notice'>Hardware error: Printer was unable to print the file. It may be out of paper.</span>")
+					else
+						program.computer.visible_message("<span class='notice'>\The [program.computer] prints out paper.</span>")
+
+
+/datum/nano_module/program/comm/proc/post_status(var/command, var/data1, var/data2)
+
+	var/datum/radio_frequency/frequency = radio_controller.return_frequency(1435)
+
+	if(!frequency) return
+
+
+	var/datum/signal/status_signal = new
+	status_signal.source = src
+	status_signal.transmission_method = 1
+	status_signal.data["command"] = command
+
+	switch(command)
+		if("message")
+			status_signal.data["msg1"] = data1
+			status_signal.data["msg2"] = data2
+			log_admin("STATUS: [key_name(usr)] set status screen message with [src]: [data1] [data2]")
+		if("alert")
+			status_signal.data["picture_state"] = data1
+
+	frequency.post_signal(src, status_signal)
+
+#undef STATE_DEFAULT
+#undef STATE_MESSAGELIST
+#undef STATE_VIEWMESSAGE
+#undef STATE_STATUSDISPLAY
+#undef STATE_ALERT_LEVEL
+
+/*
+General message handling stuff
+*/
+var/list/comm_message_listeners = list() //We first have to initialize list then we can use it.
+var/datum/comm_message_listener/global_message_listener = new //May be used by admins
+var/last_message_id = 0
+
+proc/get_comm_message_id()
+	last_message_id = last_message_id + 1
+	return last_message_id
+
+proc/post_comm_message(var/message_title, var/message_text)
+	var/list/message = list()
+	message["id"] = get_comm_message_id()
+	message["title"] = message_title
+	message["contents"] = message_text
+
+	for (var/datum/comm_message_listener/l in comm_message_listeners)
+		l.Add(message)
+
+	//Old console support
+	for (var/obj/machinery/computer/communications/comm in machines)
+		if (!(comm.stat & (BROKEN | NOPOWER)) && comm.prints_intercept)
+			var/obj/item/weapon/paper/intercept = new /obj/item/weapon/paper( comm.loc )
+			intercept.name = message_title
+			intercept.info = message_text
+
+			comm.messagetitle.Add(message_title)
+			comm.messagetext.Add(message_text)
+
+/datum/comm_message_listener
+	var/list/messages
+
+/datum/comm_message_listener/New()
+	..()
+	messages = list()
+	comm_message_listeners.Add(src)
+
+/datum/comm_message_listener/proc/Add(var/list/message)
+	messages[++messages.len] = message
+
+/datum/comm_message_listener/proc/Remove(var/list/message)
+	messages -= list(message)

code/modules/modular_computers/file_system/programs/engineering/alarm_monitor.dm

@@ -0,0 +1,134 @@
+/datum/computer_file/program/alarm_monitor
+	filename = "alarmmonitor"
+	filedesc = "Alarm Monitoring"
+	nanomodule_path = /datum/nano_module/alarm_monitor/engineering
+	ui_header = "alarm_green.gif"
+	program_icon_state = "alert-green"
+	program_key_state = "atmos_key"
+	program_menu_icon = "alert"
+	extended_desc = "This program provides visual interface for the alarm system."
+	requires_ntnet = 1
+	network_destination = "alarm monitoring network"
+	size = 5
+	var/has_alert = 0
+
+/datum/computer_file/program/alarm_monitor/process_tick()
+	..()
+	var/datum/nano_module/alarm_monitor/NMA = NM
+	if(istype(NMA) && NMA.has_major_alarms())
+		if(!has_alert)
+			program_icon_state = "alert-red"
+			ui_header = "alarm_red.gif"
+			update_computer_icon()
+			has_alert = 1
+	else
+		if(has_alert)
+			program_icon_state = "alert-green"
+			ui_header = "alarm_green.gif"
+			update_computer_icon()
+			has_alert = 0
+	return 1
+
+/datum/nano_module/alarm_monitor
+	name = "Alarm monitor"
+	var/list_cameras = 0						// Whether or not to list camera references. A future goal would be to merge this with the enginering/security camera console. Currently really only for AI-use.
+	var/list/datum/alarm_handler/alarm_handlers // The particular list of alarm handlers this alarm monitor should present to the user.
+	//available_to_ai = FALSE
+
+/datum/nano_module/alarm_monitor/New()
+	..()
+	alarm_handlers = list()
+
+/datum/nano_module/alarm_monitor/all/New()
+	..()
+	alarm_handlers = alarm_manager.all_handlers
+
+/datum/nano_module/alarm_monitor/engineering/New()
+	..()
+	alarm_handlers = list(atmosphere_alarm, camera_alarm, fire_alarm, power_alarm)
+
+/datum/nano_module/alarm_monitor/security/New()
+	..()
+	alarm_handlers = list(camera_alarm, motion_alarm)
+
+/datum/nano_module/alarm_monitor/proc/register_alarm(var/object, var/procName)
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		AH.register_alarm(object, procName)
+
+/datum/nano_module/alarm_monitor/proc/unregister_alarm(var/object)
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		AH.unregister_alarm(object)
+
+/datum/nano_module/alarm_monitor/proc/all_alarms()
+	var/list/all_alarms = new()
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		all_alarms += AH.visible_alarms()
+
+	return all_alarms
+
+/datum/nano_module/alarm_monitor/proc/major_alarms()
+	var/list/all_alarms = new()
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		all_alarms += AH.major_alarms()
+
+	return all_alarms
+
+// Modified version of above proc that uses slightly less resources, returns 1 if there is a major alarm, 0 otherwise.
+/datum/nano_module/alarm_monitor/proc/has_major_alarms()
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		if(AH.has_major_alarms())
+			return 1
+
+	return 0
+
+/datum/nano_module/alarm_monitor/proc/minor_alarms()
+	var/list/all_alarms = new()
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		all_alarms += AH.minor_alarms()
+
+	return all_alarms
+
+/datum/nano_module/alarm_monitor/Topic(ref, href_list)
+	if(..())
+		return 1
+	if(href_list["switchTo"])
+		var/obj/machinery/camera/C = locate(href_list["switchTo"]) in cameranet.cameras
+		if(!C)
+			return
+
+		usr.switch_to_camera(C)
+		return 1
+
+/datum/nano_module/alarm_monitor/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	var/categories[0]
+	for(var/datum/alarm_handler/AH in alarm_handlers)
+		categories[++categories.len] = list("category" = AH.category, "alarms" = list())
+		for(var/datum/alarm/A in AH.major_alarms())
+			var/cameras[0]
+			var/lost_sources[0]
+
+			if(isAI(user))
+				for(var/obj/machinery/camera/C in A.cameras())
+					cameras[++cameras.len] = C.nano_structure()
+			for(var/datum/alarm_source/AS in A.sources)
+				if(!AS.source)
+					lost_sources[++lost_sources.len] = AS.source_name
+
+			categories[categories.len]["alarms"] += list(list(
+					"name" = sanitize(A.alarm_name()),
+					"origin_lost" = A.origin == null,
+					"has_cameras" = cameras.len,
+					"cameras" = cameras,
+					"lost_sources" = lost_sources.len ? sanitize(english_list(lost_sources, nothing_text = "", and_text = ", ")) : ""))
+	data["categories"] = categories
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "alarm_monitor.tmpl", "Alarm Monitoring Console", 800, 800, state = state)
+		if(host.update_layout()) // This is necessary to ensure the status bar remains updated along with rest of the UI.
+			ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)

code/modules/modular_computers/file_system/programs/engineering/atmos_control.dm

@@ -0,0 +1,103 @@
+/datum/computer_file/program/atmos_control
+	filename = "atmoscontrol"
+	filedesc = "Atmosphere Control"
+	nanomodule_path = /datum/nano_module/atmos_control
+	program_icon_state = "atmos_control"
+	program_key_state = "atmos_key"
+	program_menu_icon = "shuffle"
+	extended_desc = "This program allows remote control of air alarms. This program can not be run on tablet computers."
+	required_access = access_atmospherics
+	requires_ntnet = 1
+	network_destination = "atmospheric control system"
+	requires_ntnet_feature = NTNET_SYSTEMCONTROL
+	usage_flags = PROGRAM_LAPTOP | PROGRAM_CONSOLE
+	size = 17
+
+/datum/nano_module/atmos_control
+	name = "Atmospherics Control"
+	var/obj/access = new()
+	var/emagged = 0
+	var/ui_ref
+	var/list/monitored_alarms = list()
+
+/datum/nano_module/atmos_control/New(atmos_computer, req_access, req_one_access, monitored_alarm_ids)
+	..()
+	access.req_access = req_access
+	access.req_one_access = req_one_access
+
+	if(monitored_alarm_ids)
+		for(var/obj/machinery/alarm/alarm in machines)
+			if(alarm.alarm_id && alarm.alarm_id in monitored_alarm_ids)
+				monitored_alarms += alarm
+		// machines may not yet be ordered at this point
+		monitored_alarms = dd_sortedObjectList(monitored_alarms)
+
+/datum/nano_module/atmos_control/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["alarm"])
+		if(ui_ref)
+			var/obj/machinery/alarm/alarm = locate(href_list["alarm"]) in (monitored_alarms.len ? monitored_alarms : machines)
+			if(alarm)
+				var/datum/topic_state/TS = generate_state(alarm)
+				alarm.ui_interact(usr, master_ui = ui_ref, state = TS)
+		return 1
+
+/datum/nano_module/atmos_control/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/master_ui = null, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+	var/alarms[0]
+	var/turf/T = get_turf(nano_host())
+
+	// TODO: Move these to a cache, similar to cameras
+	for(var/obj/machinery/alarm/alarm in (monitored_alarms.len ? monitored_alarms : machines))
+		if(!monitored_alarms.len && alarm.alarms_hidden)
+			continue
+		alarms[++alarms.len] = list(
+			"name" = sanitize(alarm.name),
+			"ref"= "\ref[alarm]",
+			"danger" = max(alarm.danger_level, alarm.alarm_area.atmosalm),
+			"x" = alarm.x,
+			"y" = alarm.y,
+			"z" = alarm.z)
+	data["alarms"] = alarms
+	data["map_levels"] = using_map.get_map_levels(T.z)
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "atmos_control.tmpl", src.name, 625, 625, state = state)
+		if(host.update_layout()) // This is necessary to ensure the status bar remains updated along with rest of the UI.
+			ui.auto_update_layout = 1
+		// adding a template with the key "mapContent" enables the map ui functionality
+		ui.add_template("mapContent", "atmos_control_map_content.tmpl")
+		// adding a template with the key "mapHeader" replaces the map header content
+		ui.add_template("mapHeader", "atmos_control_map_header.tmpl")
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(0)
+	ui_ref = ui
+
+/datum/nano_module/atmos_control/proc/generate_state(air_alarm)
+	var/datum/topic_state/air_alarm/state = new()
+	state.atmos_control = src
+	state.air_alarm = air_alarm
+	return state
+
+/datum/topic_state/air_alarm
+	var/datum/nano_module/atmos_control/atmos_control	= null
+	var/obj/machinery/alarm/air_alarm					= null
+
+/datum/topic_state/air_alarm/can_use_topic(var/src_object, var/mob/user)
+	if(has_access(user))
+		return STATUS_INTERACTIVE
+	return STATUS_UPDATE
+
+/datum/topic_state/air_alarm/href_list(var/mob/user)
+	var/list/extra_href = list()
+	extra_href["remote_connection"] = 1
+	extra_href["remote_access"] = has_access(user)
+
+	return extra_href
+
+/datum/topic_state/air_alarm/proc/has_access(var/mob/user)
+	return user && (isAI(user) || atmos_control.access.allowed(user) || atmos_control.emagged || air_alarm.rcon_setting == RCON_YES || (air_alarm.alarm_area.atmosalm && air_alarm.rcon_setting == RCON_AUTO))

code/modules/modular_computers/file_system/programs/engineering/power_monitor.dm

@@ -0,0 +1,113 @@
+/datum/computer_file/program/power_monitor
+	filename = "powermonitor"
+	filedesc = "Power Monitoring"
+	nanomodule_path = /datum/nano_module/power_monitor/
+	program_icon_state = "power_monitor"
+	program_key_state = "power_key"
+	program_menu_icon = "battery-3"
+	extended_desc = "This program connects to sensors to provide information about electrical systems"
+	ui_header = "power_norm.gif"
+	required_access = access_engine
+	requires_ntnet = 1
+	network_destination = "power monitoring system"
+	size = 9
+	var/has_alert = 0
+
+/datum/computer_file/program/power_monitor/process_tick()
+	..()
+	var/datum/nano_module/power_monitor/NMA = NM
+	if(istype(NMA) && NMA.has_alarm())
+		if(!has_alert)
+			program_icon_state = "power_monitor_warn"
+			ui_header = "power_warn.gif"
+			update_computer_icon()
+			has_alert = 1
+	else
+		if(has_alert)
+			program_icon_state = "power_monitor"
+			ui_header = "power_norm.gif"
+			update_computer_icon()
+			has_alert = 0
+
+/datum/nano_module/power_monitor
+	name = "Power monitor"
+	var/list/grid_sensors
+	var/active_sensor = null	//name_tag of the currently selected sensor
+
+/datum/nano_module/power_monitor/New()
+	..()
+	refresh_sensors()
+
+// Checks whether there is an active alarm, if yes, returns 1, otherwise returns 0.
+/datum/nano_module/power_monitor/proc/has_alarm()
+	for(var/obj/machinery/power/sensor/S in grid_sensors)
+		if(S.check_grid_warning())
+			return 1
+	return 0
+
+// If PC is not null header template is loaded. Use PC.get_header_data() to get relevant nanoui data from it. All data entries begin with "PC_...."
+// In future it may be expanded to other modular computer devices.
+/datum/nano_module/power_monitor/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	var/list/sensors = list()
+	// Focus: If it remains null if no sensor is selected and UI will display sensor list, otherwise it will display sensor reading.
+	var/obj/machinery/power/sensor/focus = null
+	var/turf/T = get_turf(nano_host())
+
+	// Build list of data from sensor readings.
+	for(var/obj/machinery/power/sensor/S in grid_sensors)
+		sensors.Add(list(list(
+		"name" = S.name_tag,
+		"alarm" = S.check_grid_warning()
+		)))
+		if(S.name_tag == active_sensor)
+			focus = S
+
+	data["all_sensors"] = sensors
+	if(focus)
+		data["focus"] = focus.return_reading_data()
+	data["map_levels"] = using_map.get_map_levels(T.z)
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "power_monitor.tmpl", "Power Monitoring Console", 800, 500, state = state)
+		if(host.update_layout()) // This is necessary to ensure the status bar remains updated along with rest of the UI.
+			ui.auto_update_layout = 1
+		// adding a template with the key "mapContent" enables the map ui functionality
+		ui.add_template("mapContent", "power_monitor_map_content.tmpl")
+		// adding a template with the key "mapHeader" replaces the map header content
+		ui.add_template("mapHeader", "power_monitor_map_header.tmpl")
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+// Refreshes list of active sensors kept on this computer.
+/datum/nano_module/power_monitor/proc/refresh_sensors()
+	grid_sensors = list()
+	var/turf/T = get_turf(nano_host())
+	var/list/levels = list()
+	if(!T) // Safety check
+		return
+	if(T)
+		levels += using_map.get_map_levels(T.z, FALSE)
+	for(var/obj/machinery/power/sensor/S in machines)
+		if(T && (S.loc.z == T.z) || (S.loc.z in levels) || (S.long_range)) // Consoles have range on their Z-Level. Sensors with long_range var will work between Z levels.
+			if(S.name_tag == "#UNKN#") // Default name. Shouldn't happen!
+				warning("Powernet sensor with unset ID Tag! [S.x]X [S.y]Y [S.z]Z")
+			else
+				grid_sensors += S
+
+// Allows us to process UI clicks, which are relayed in form of hrefs.
+/datum/nano_module/power_monitor/Topic(href, href_list)
+	if(..())
+		return 1
+	if( href_list["clear"] )
+		active_sensor = null
+		. = 1
+	if( href_list["refresh"] )
+		refresh_sensors()
+		. = 1
+	else if( href_list["setsensor"] )
+		active_sensor = href_list["setsensor"]
+		. = 1

code/modules/modular_computers/file_system/programs/engineering/rcon_console.dm

@@ -0,0 +1,132 @@
+/datum/computer_file/program/rcon_console
+	filename = "rconconsole"
+	filedesc = "RCON Remote Control"
+	nanomodule_path = /datum/nano_module/rcon
+	program_icon_state = "generic"
+	program_key_state = "rd_key"
+	program_menu_icon = "power"
+	extended_desc = "This program allows remote control of power distribution systems. This program can not be run on tablet computers."
+	required_access = access_engine
+	requires_ntnet = 1
+	network_destination = "RCON remote control system"
+	requires_ntnet_feature = NTNET_SYSTEMCONTROL
+	usage_flags = PROGRAM_LAPTOP | PROGRAM_CONSOLE
+	size = 19
+
+/datum/nano_module/rcon
+	name = "Power RCON"
+	var/list/known_SMESs = null
+	var/list/known_breakers = null
+	// Allows you to hide specific parts of the UI
+	var/hide_SMES = 0
+	var/hide_SMES_details = 0
+	var/hide_breakers = 0
+
+/datum/nano_module/rcon/ui_interact(mob/user, ui_key = "rcon", datum/nanoui/ui=null, force_open=1, var/datum/topic_state/state = default_state)
+	FindDevices() // Update our devices list
+	var/list/data = host.initial_data()
+
+	// SMES DATA (simplified view)
+	var/list/smeslist[0]
+	for(var/obj/machinery/power/smes/buildable/SMES in known_SMESs)
+		smeslist.Add(list(list(
+		"charge" = round(SMES.Percentage()),
+		"input_set" = SMES.input_attempt,
+		"input_val" = round(SMES.input_level/1000, 0.1),
+		"output_set" = SMES.output_attempt,
+		"output_val" = round(SMES.output_level/1000, 0.1),
+		"output_load" = round(SMES.output_used/1000, 0.1),
+		"RCON_tag" = SMES.RCon_tag
+		)))
+
+	data["smes_info"] = sortByKey(smeslist, "RCON_tag")
+
+	// BREAKER DATA (simplified view)
+	var/list/breakerlist[0]
+	for(var/obj/machinery/power/breakerbox/BR in known_breakers)
+		breakerlist.Add(list(list(
+		"RCON_tag" = BR.RCon_tag,
+		"enabled" = BR.on
+		)))
+	data["breaker_info"] = breakerlist
+	data["hide_smes"] = hide_SMES
+	data["hide_smes_details"] = hide_SMES_details
+	data["hide_breakers"] = hide_breakers
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "rcon.tmpl", "RCON Console", 600, 400, state = state)
+		if(host.update_layout()) // This is necessary to ensure the status bar remains updated along with rest of the UI.
+			ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+// Proc: Topic()
+// Parameters: 2 (href, href_list - allows us to process UI clicks)
+// Description: Allows us to process UI clicks, which are relayed in form of hrefs.
+/datum/nano_module/rcon/Topic(href, href_list)
+	if(..())
+		return
+
+	if(href_list["smes_in_toggle"])
+		var/obj/machinery/power/smes/buildable/SMES = GetSMESByTag(href_list["smes_in_toggle"])
+		if(SMES)
+			SMES.toggle_input()
+	if(href_list["smes_out_toggle"])
+		var/obj/machinery/power/smes/buildable/SMES = GetSMESByTag(href_list["smes_out_toggle"])
+		if(SMES)
+			SMES.toggle_output()
+	if(href_list["smes_in_set"])
+		var/obj/machinery/power/smes/buildable/SMES = GetSMESByTag(href_list["smes_in_set"])
+		if(SMES)
+			var/inputset = (input(usr, "Enter new input level (0-[SMES.input_level_max/1000] kW)", "SMES Input Power Control", SMES.input_level/1000) as num) * 1000
+			SMES.set_input(inputset)
+	if(href_list["smes_out_set"])
+		var/obj/machinery/power/smes/buildable/SMES = GetSMESByTag(href_list["smes_out_set"])
+		if(SMES)
+			var/outputset = (input(usr, "Enter new output level (0-[SMES.output_level_max/1000] kW)", "SMES Output Power Control", SMES.output_level/1000) as num) * 1000
+			SMES.set_output(outputset)
+
+	if(href_list["toggle_breaker"])
+		var/obj/machinery/power/breakerbox/toggle = null
+		for(var/obj/machinery/power/breakerbox/breaker in known_breakers)
+			if(breaker.RCon_tag == href_list["toggle_breaker"])
+				toggle = breaker
+		if(toggle)
+			if(toggle.update_locked)
+				to_chat(usr, "The breaker box was recently toggled. Please wait before toggling it again.")
+			else
+				toggle.auto_toggle()
+	if(href_list["hide_smes"])
+		hide_SMES = !hide_SMES
+	if(href_list["hide_smes_details"])
+		hide_SMES_details = !hide_SMES_details
+	if(href_list["hide_breakers"])
+		hide_breakers = !hide_breakers
+
+
+// Proc: GetSMESByTag()
+// Parameters: 1 (tag - RCON tag of SMES we want to look up)
+// Description: Looks up and returns SMES which has matching RCON tag
+/datum/nano_module/rcon/proc/GetSMESByTag(var/tag)
+	if(!tag)
+		return
+
+	for(var/obj/machinery/power/smes/buildable/S in known_SMESs)
+		if(S.RCon_tag == tag)
+			return S
+
+// Proc: FindDevices()
+// Parameters: None
+// Description: Refreshes local list of known devices.
+/datum/nano_module/rcon/proc/FindDevices()
+	known_SMESs = new /list()
+	for(var/obj/machinery/power/smes/buildable/SMES in machines)
+		if(SMES.RCon_tag && (SMES.RCon_tag != "NO_TAG") && SMES.RCon)
+			known_SMESs.Add(SMES)
+
+	known_breakers = new /list()
+	for(var/obj/machinery/power/breakerbox/breaker in machines)
+		if(breaker.RCon_tag != "NO_TAG")
+			known_breakers.Add(breaker)

code/modules/modular_computers/file_system/programs/engineering/supermatter_monitor.dm

@@ -0,0 +1,132 @@
+/datum/computer_file/program/supermatter_monitor
+	filename = "supmon"
+	filedesc = "Supermatter Monitoring"
+	nanomodule_path = /datum/nano_module/supermatter_monitor/
+	program_icon_state = "smmon_0"
+	program_key_state = "tech_key"
+	program_menu_icon = "notice"
+	extended_desc = "This program connects to specially calibrated supermatter sensors to provide information on the status of supermatter-based engines."
+	ui_header = "smmon_0.gif"
+	required_access = access_engine
+	requires_ntnet = 1
+	network_destination = "supermatter monitoring system"
+	size = 5
+	var/last_status = 0
+
+/datum/computer_file/program/supermatter_monitor/process_tick()
+	..()
+	var/datum/nano_module/supermatter_monitor/NMS = NM
+	var/new_status = istype(NMS) ? NMS.get_status() : 0
+	if(last_status != new_status)
+		last_status = new_status
+		ui_header = "smmon_[last_status].gif"
+		program_icon_state = "smmon_[last_status]"
+		if(istype(computer))
+			computer.update_icon()
+
+/datum/nano_module/supermatter_monitor
+	name = "Supermatter monitor"
+	var/list/supermatters
+	var/obj/machinery/power/supermatter/active = null		// Currently selected supermatter crystal.
+
+/datum/nano_module/supermatter_monitor/Destroy()
+	. = ..()
+	active = null
+	supermatters = null
+
+/datum/nano_module/supermatter_monitor/New()
+	..()
+	refresh()
+
+// Refreshes list of active supermatter crystals
+/datum/nano_module/supermatter_monitor/proc/refresh()
+	supermatters = list()
+	var/turf/T = get_turf(nano_host())
+	if(!T)
+		return
+	var/valid_z_levels = (GetConnectedZlevels(T.z) & using_map.station_levels)
+	for(var/obj/machinery/power/supermatter/S in machines)
+		// Delaminating, not within coverage, not on a tile.
+		if(S.grav_pulling || S.exploded || !(S.z in valid_z_levels) || !istype(S.loc, /turf/))
+			continue
+		supermatters.Add(S)
+
+	if(!(active in supermatters))
+		active = null
+
+/datum/nano_module/supermatter_monitor/proc/get_status()
+	. = SUPERMATTER_INACTIVE
+	for(var/obj/machinery/power/supermatter/S in supermatters)
+		. = max(., S.get_status())
+
+/datum/nano_module/supermatter_monitor/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	if(istype(active))
+		var/turf/T = get_turf(active)
+		if(!T)
+			active = null
+			return
+		var/datum/gas_mixture/air = T.return_air()
+		if(!istype(air))
+			active = null
+			return
+
+		data["active"] = 1
+		data["SM_integrity"] = active.get_integrity()
+		data["SM_power"] = active.power
+		data["SM_ambienttemp"] = air.temperature
+		data["SM_ambientpressure"] = air.return_pressure()
+		//data["SM_EPR"] = active.get_epr()
+		if(air.total_moles)
+			data["SM_gas_O2"] = round(100*air.gas["oxygen"]/air.total_moles,0.01)
+			data["SM_gas_CO2"] = round(100*air.gas["carbon_dioxide"]/air.total_moles,0.01)
+			data["SM_gas_N2"] = round(100*air.gas["nitrogen"]/air.total_moles,0.01)
+			data["SM_gas_PH"] = round(100*air.gas["phoron"]/air.total_moles,0.01)
+			data["SM_gas_N2O"] = round(100*air.gas["sleeping_agent"]/air.total_moles,0.01)
+		else
+			data["SM_gas_O2"] = 0
+			data["SM_gas_CO2"] = 0
+			data["SM_gas_N2"] = 0
+			data["SM_gas_PH"] = 0
+			data["SM_gas_N2O"] = 0
+	else
+		var/list/SMS = list()
+		for(var/obj/machinery/power/supermatter/S in supermatters)
+			var/area/A = get_area(S)
+			if(!A)
+				continue
+
+			SMS.Add(list(list(
+			"area_name" = A.name,
+			"integrity" = S.get_integrity(),
+			"uid" = S.uid
+			)))
+
+		data["active"] = 0
+		data["supermatters"] = SMS
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "supermatter_monitor.tmpl", "Supermatter Monitoring", 600, 400, state = state)
+		if(host.update_layout())
+			ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+/datum/nano_module/supermatter_monitor/Topic(href, href_list)
+	if(..())
+		return 1
+	if( href_list["clear"] )
+		active = null
+		return 1
+	if( href_list["refresh"] )
+		refresh()
+		return 1
+	if( href_list["set"] )
+		var/newuid = text2num(href_list["set"])
+		for(var/obj/machinery/power/supermatter/S in supermatters)
+			if(S.uid == newuid)
+				active = S
+		return 1

code/modules/modular_computers/file_system/programs/generic/camera.dm

@@ -0,0 +1,186 @@
+// Returns which access is relevant to passed network. Used by the program.
+/proc/get_camera_access(var/network)
+	if(!network)
+		return 0
+	. = using_map.get_network_access(network)
+	if(.)
+		return
+
+	switch(network)
+		if(NETWORK_THUNDER)
+			return 0
+		if(NETWORK_ENGINE,NETWORK_ENGINEERING,NETWORK_ENGINEERING_OUTPOST,NETWORK_ALARM_ATMOS,NETWORK_ALARM_FIRE,NETWORK_ALARM_POWER)
+			return access_engine
+		if(NETWORK_MEDICAL)
+			return access_medical
+		if(NETWORK_RESEARCH,NETWORK_RESEARCH_OUTPOST)
+			return access_research
+		if(NETWORK_MINE,NETWORK_CARGO )
+			return access_mailsorting // Cargo office - all cargo staff should have access here.
+		if(NETWORK_COMMAND,NETWORK_TELECOM)
+			return access_heads
+		if(NETWORK_ERT)
+			return access_cent_specops
+
+	return access_security // Default for all other networks
+
+/datum/computer_file/program/camera_monitor
+	filename = "cammon"
+	filedesc = "Camera Monitoring"
+	nanomodule_path = /datum/nano_module/camera_monitor
+	program_icon_state = "cameras"
+	program_key_state = "generic_key"
+	program_menu_icon = "search"
+	extended_desc = "This program allows remote access to the camera system. Some camera networks may have additional access requirements."
+	size = 12
+	available_on_ntnet = 1
+	requires_ntnet = 1
+
+/datum/nano_module/camera_monitor
+	name = "Camera Monitoring program"
+	var/obj/machinery/camera/current_camera = null
+	var/current_network = null
+
+/datum/nano_module/camera_monitor/ui_interact(mob/user, ui_key = "main", datum/nanoui/ui = null, force_open = 1, state = default_state)
+	var/list/data = host.initial_data()
+
+	data["current_camera"] = current_camera ? current_camera.nano_structure() : null
+	data["current_network"] = current_network
+
+	var/list/all_networks[0]
+	for(var/network in using_map.station_networks)
+		all_networks.Add(list(list(
+							"tag" = network,
+							"has_access" = can_access_network(user, get_camera_access(network))
+							)))
+
+	all_networks = modify_networks_list(all_networks)
+
+	data["networks"] = all_networks
+
+	if(current_network)
+		data["cameras"] = camera_repository.cameras_in_network(current_network)
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "mod_sec_camera.tmpl", "Camera Monitoring", 900, 800)
+		// ui.auto_update_layout = 1 // Disabled as with suit sensors monitor - breaks the UI map. Re-enable once it's fixed somehow.
+
+		ui.add_template("mapContent", "sec_camera_map_content.tmpl")
+		ui.add_template("mapHeader", "mod_sec_camera_map_header.tmpl")
+		ui.set_initial_data(data)
+		ui.open()
+
+// Intended to be overriden by subtypes to manually add non-station networks to the list.
+/datum/nano_module/camera_monitor/proc/modify_networks_list(var/list/networks)
+	return networks
+
+/datum/nano_module/camera_monitor/proc/can_access_network(var/mob/user, var/network_access)
+	// No access passed, or 0 which is considered no access requirement. Allow it.
+	if(!network_access)
+		return 1
+
+	return check_access(user, access_security) || check_access(user, network_access)
+
+/datum/nano_module/camera_monitor/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["switch_camera"])
+		var/obj/machinery/camera/C = locate(href_list["switch_camera"]) in cameranet.cameras
+		if(!C)
+			return
+		if(!(current_network in C.network))
+			return
+
+		switch_to_camera(usr, C)
+		return 1
+
+	else if(href_list["switch_network"])
+		// Either security access, or access to the specific camera network's department is required in order to access the network.
+		if(can_access_network(usr, get_camera_access(href_list["switch_network"])))
+			current_network = href_list["switch_network"]
+		else
+			to_chat(usr, "\The [nano_host()] shows an \"Network Access Denied\" error message.")
+		return 1
+
+	else if(href_list["reset"])
+		reset_current()
+		usr.reset_view(current_camera)
+		return 1
+
+/datum/nano_module/camera_monitor/proc/switch_to_camera(var/mob/user, var/obj/machinery/camera/C)
+	//don't need to check if the camera works for AI because the AI jumps to the camera location and doesn't actually look through cameras.
+	if(isAI(user))
+		var/mob/living/silicon/ai/A = user
+		// Only allow non-carded AIs to view because the interaction with the eye gets all wonky otherwise.
+		if(!A.is_in_chassis())
+			return 0
+
+		A.eyeobj.setLoc(get_turf(C))
+		A.client.eye = A.eyeobj
+		return 1
+
+	set_current(C)
+	user.machine = nano_host()
+	user.reset_view(C)
+	return 1
+
+/datum/nano_module/camera_monitor/proc/set_current(var/obj/machinery/camera/C)
+	if(current_camera == C)
+		return
+
+	if(current_camera)
+		reset_current()
+
+	current_camera = C
+	if(current_camera)
+		var/mob/living/L = current_camera.loc
+		if(istype(L))
+			L.tracking_initiated()
+
+/datum/nano_module/camera_monitor/proc/reset_current()
+	if(current_camera)
+		var/mob/living/L = current_camera.loc
+		if(istype(L))
+			L.tracking_cancelled()
+	current_camera = null
+
+/datum/nano_module/camera_monitor/check_eye(var/mob/user as mob)
+	if(!current_camera)
+		return 0
+	var/viewflag = current_camera.check_eye(user)
+	if ( viewflag < 0 ) //camera doesn't work
+		reset_current()
+	return viewflag
+
+
+// ERT Variant of the program
+/datum/computer_file/program/camera_monitor/ert
+	filename = "ntcammon"
+	filedesc = "Advanced Camera Monitoring"
+	extended_desc = "This program allows remote access to the camera system. Some camera networks may have additional access requirements. This version has an integrated database with additional encrypted keys."
+	size = 14
+	nanomodule_path = /datum/nano_module/camera_monitor/ert
+	available_on_ntnet = 0
+
+/datum/nano_module/camera_monitor/ert
+	name = "Advanced Camera Monitoring Program"
+	//available_to_ai = FALSE
+
+// The ERT variant has access to ERT and crescent cams, but still checks for accesses. ERT members should be able to use it.
+/datum/nano_module/camera_monitor/ert/modify_networks_list(var/list/networks)
+	..()
+	networks.Add(list(list("tag" = NETWORK_ERT, "has_access" = 1)))
+	networks.Add(list(list("tag" = NETWORK_CRESCENT, "has_access" = 1)))
+	return networks
+
+/datum/nano_module/camera_monitor/apply_visual(mob/M)
+	if(current_camera)
+		current_camera.apply_visual(M)
+	else
+		remove_visual(M)
+
+/datum/nano_module/camera_monitor/remove_visual(mob/M)
+	if(current_camera)
+		current_camera.remove_visual(M)

code/modules/modular_computers/file_system/programs/generic/configurator.dm

@@ -0,0 +1,64 @@
+// This is special hardware configuration program.
+// It is to be used only with modular computers.
+// It allows you to toggle components of your device.
+
+/datum/computer_file/program/computerconfig
+	filename = "compconfig"
+	filedesc = "Computer Configuration Tool"
+	extended_desc = "This program allows configuration of computer's hardware"
+	program_icon_state = "generic"
+	program_key_state = "generic_key"
+	program_menu_icon = "gear"
+	unsendable = 1
+	undeletable = 1
+	size = 4
+	available_on_ntnet = 0
+	requires_ntnet = 0
+	nanomodule_path = /datum/nano_module/program/computer_configurator/
+
+/datum/nano_module/program/computer_configurator
+	name = "NTOS Computer Configuration Tool"
+	var/obj/item/modular_computer/movable = null
+
+/datum/nano_module/program/computer_configurator/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(program)
+		movable = program.computer
+	if(!istype(movable))
+		movable = null
+
+	// No computer connection, we can't get data from that.
+	if(!movable)
+		return 0
+
+	var/list/data = list()
+
+	if(program)
+		data = program.get_header_data()
+
+	var/list/hardware = movable.get_all_components()
+
+	data["disk_size"] = movable.hard_drive.max_capacity
+	data["disk_used"] = movable.hard_drive.used_capacity
+	data["power_usage"] = movable.last_power_usage
+	data["battery_exists"] = movable.battery_module ? 1 : 0
+	if(movable.battery_module)
+		data["battery_rating"] = movable.battery_module.battery.maxcharge
+		data["battery_percent"] = round(movable.battery_module.battery.percent())
+
+	var/list/all_entries[0]
+	for(var/obj/item/weapon/computer_hardware/H in hardware)
+		all_entries.Add(list(list(
+		"name" = H.name,
+		"desc" = H.desc,
+		"enabled" = H.enabled,
+		"critical" = H.critical,
+		"powerusage" = H.power_usage
+		)))
+
+	data["hardware"] = all_entries
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "laptop_configuration.tmpl", "NTOS Configuration Utility", 575, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()

code/modules/modular_computers/file_system/programs/generic/email_client.dm

@@ -0,0 +1,499 @@
+/datum/computer_file/program/email_client
+	filename = "emailc"
+	filedesc = "Email Client"
+	extended_desc = "This program may be used to log in into your email account."
+	program_icon_state = "generic"
+	program_key_state = "generic_key"
+	program_menu_icon = "mail-closed"
+	size = 7
+	requires_ntnet = 1
+	available_on_ntnet = 1
+	var/stored_login = ""
+	var/stored_password = ""
+
+	nanomodule_path = /datum/nano_module/email_client
+
+// Persistency. Unless you log out, or unless your password changes, this will pre-fill the login data when restarting the program
+/datum/computer_file/program/email_client/kill_program()
+	if(NM)
+		var/datum/nano_module/email_client/NME = NM
+		if(NME.current_account)
+			stored_login = NME.stored_login
+			stored_password = NME.stored_password
+		else
+			stored_login = ""
+			stored_password = ""
+	. = ..()
+
+/datum/computer_file/program/email_client/run_program()
+	. = ..()
+	if(NM)
+		var/datum/nano_module/email_client/NME = NM
+		NME.stored_login = stored_login
+		NME.stored_password = stored_password
+		NME.log_in()
+		NME.error = ""
+		NME.check_for_new_messages(1)
+
+/datum/computer_file/program/email_client/proc/new_mail_notify()
+	computer.visible_message("\The [computer] beeps softly, indicating a new email has been received.", 1)
+
+/datum/computer_file/program/email_client/process_tick()
+	..()
+	var/datum/nano_module/email_client/NME = NM
+	if(!istype(NME))
+		return
+	NME.relayed_process(ntnet_speed)
+
+	var/check_count = NME.check_for_new_messages()
+	if(check_count)
+		if(check_count == 2)
+			new_mail_notify()
+		ui_header = "ntnrc_new.gif"
+	else
+		ui_header = "ntnrc_idle.gif"
+
+/datum/nano_module/email_client/
+	name = "Email Client"
+	var/stored_login = ""
+	var/stored_password = ""
+	var/error = ""
+
+	var/msg_title = ""
+	var/msg_body = ""
+	var/msg_recipient = ""
+	var/datum/computer_file/msg_attachment = null
+	var/folder = "Inbox"
+	var/addressbook = FALSE
+	var/new_message = FALSE
+
+	var/last_message_count = 0	// How many messages were there during last check.
+	var/read_message_count = 0	// How many messages were there when user has last accessed the UI.
+
+	var/datum/computer_file/downloading = null
+	var/download_progress = 0
+	var/download_speed = 0
+
+	var/datum/computer_file/data/email_account/current_account = null
+	var/datum/computer_file/data/email_message/current_message = null
+
+/datum/nano_module/email_client/proc/log_in()
+	for(var/datum/computer_file/data/email_account/account in ntnet_global.email_accounts)
+		if(!account.can_login)
+			continue
+		if(account.login == stored_login)
+			if(account.password == stored_password)
+				if(account.suspended)
+					error = "This account has been suspended. Please contact the system administrator for assistance."
+					return 0
+				current_account = account
+				return 1
+			else
+				error = "Invalid Password"
+				return 0
+	error = "Invalid Login"
+	return 0
+
+// Returns 0 if no new messages were received, 1 if there is an unread message but notification has already been sent.
+// and 2 if there is a new message that appeared in this tick (and therefore notification should be sent by the program).
+/datum/nano_module/email_client/proc/check_for_new_messages(var/messages_read = FALSE)
+	if(!current_account)
+		return 0
+
+	var/list/allmails = current_account.all_emails()
+
+	if(allmails.len > last_message_count)
+		. = 2
+	else if(allmails.len > read_message_count)
+		. = 1
+	else
+		. = 0
+
+	last_message_count = allmails.len
+	if(messages_read)
+		read_message_count = allmails.len
+
+
+/datum/nano_module/email_client/proc/log_out()
+	current_account = null
+	downloading = null
+	download_progress = 0
+	last_message_count = 0
+	read_message_count = 0
+
+/datum/nano_module/email_client/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	// Password has been changed by other client connected to this email account
+	if(current_account)
+		if(current_account.password != stored_password)
+			log_out()
+			error = "Invalid Password"
+		// Banned.
+		if(current_account.suspended)
+			log_out()
+			error = "This account has been suspended. Please contact the system administrator for assistance."
+
+	if(error)
+		data["error"] = error
+	else if(downloading)
+		data["downloading"] = 1
+		data["down_filename"] = "[downloading.filename].[downloading.filetype]"
+		data["down_progress"] = download_progress
+		data["down_size"] = downloading.size
+		data["down_speed"] = download_speed
+
+	else if(istype(current_account))
+		data["current_account"] = current_account.login
+		if(addressbook)
+			var/list/all_accounts = list()
+			for(var/datum/computer_file/data/email_account/account in ntnet_global.email_accounts)
+				if(!account.can_login)
+					continue
+				all_accounts.Add(list(list(
+					"login" = account.login
+				)))
+			data["addressbook"] = 1
+			data["accounts"] = all_accounts
+		else if(new_message)
+			data["new_message"] = 1
+			data["msg_title"] = msg_title
+			data["msg_body"] = pencode2html(msg_body)
+			data["msg_recipient"] = msg_recipient
+			if(msg_attachment)
+				data["msg_hasattachment"] = 1
+				data["msg_attachment_filename"] = "[msg_attachment.filename].[msg_attachment.filetype]"
+				data["msg_attachment_size"] = msg_attachment.size
+		else if (current_message)
+			data["cur_title"] = current_message.title
+			data["cur_body"] = pencode2html(current_message.stored_data)
+			data["cur_timestamp"] = current_message.timestamp
+			data["cur_source"] = current_message.source
+			data["cur_uid"] = current_message.uid
+			if(istype(current_message.attachment))
+				data["cur_hasattachment"] = 1
+				data["cur_attachment_filename"] = "[current_message.attachment.filename].[current_message.attachment.filetype]"
+				data["cur_attachment_size"] = current_message.attachment.size
+		else
+			data["label_inbox"] = "Inbox ([current_account.inbox.len])"
+			data["label_spam"] = "Spam ([current_account.spam.len])"
+			data["label_deleted"] = "Deleted ([current_account.deleted.len])"
+			var/list/message_source
+			if(folder == "Inbox")
+				message_source = current_account.inbox
+			else if(folder == "Spam")
+				message_source = current_account.spam
+			else if(folder == "Deleted")
+				message_source = current_account.deleted
+
+			if(message_source)
+				data["folder"] = folder
+				var/list/all_messages = list()
+				for(var/datum/computer_file/data/email_message/message in message_source)
+					all_messages.Add(list(list(
+						"title" = message.title,
+						"body" = pencode2html(message.stored_data),
+						"source" = message.source,
+						"timestamp" = message.timestamp,
+						"uid" = message.uid
+					)))
+				data["messages"] = all_messages
+				data["messagecount"] = all_messages.len
+	else
+		data["stored_login"] = stored_login
+		data["stored_password"] = stars(stored_password, 0)
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "email_client.tmpl", "Email Client", 600, 450, state = state)
+		if(host.update_layout())
+			ui.auto_update_layout = 1
+		ui.set_auto_update(1)
+		ui.set_initial_data(data)
+		ui.open()
+
+/datum/nano_module/email_client/proc/find_message_by_fuid(var/fuid)
+	if(!istype(current_account))
+		return
+
+	// href_list works with strings, so this makes it a bit easier for us
+	if(istext(fuid))
+		fuid = text2num(fuid)
+
+	for(var/datum/computer_file/data/email_message/message in current_account.all_emails())
+		if(message.uid == fuid)
+			return message
+
+/datum/nano_module/email_client/proc/clear_message()
+	new_message = FALSE
+	msg_title = ""
+	msg_body = ""
+	msg_recipient = ""
+	msg_attachment = null
+	current_message = null
+
+/datum/nano_module/email_client/proc/relayed_process(var/netspeed)
+	download_speed = netspeed
+	if(!downloading)
+		return
+	download_progress = min(download_progress + netspeed, downloading.size)
+	if(download_progress >= downloading.size)
+		var/obj/item/modular_computer/MC = nano_host()
+		if(!istype(MC) || !MC.hard_drive || !MC.hard_drive.check_functionality())
+			error = "Error uploading file. Are you using a functional and NTOSv2-compliant device?"
+			downloading = null
+			download_progress = 0
+			return 1
+
+		if(MC.hard_drive.store_file(downloading))
+			error = "File successfully downloaded to local device."
+		else
+			error = "Error saving file: I/O Error: The hard drive may be full or nonfunctional."
+		downloading = null
+		download_progress = 0
+	return 1
+
+
+/datum/nano_module/email_client/Topic(href, href_list)
+	if(..())
+		return 1
+	var/mob/living/user = usr
+	check_for_new_messages(1)		// Any actual interaction (button pressing) is considered as acknowledging received message, for the purpose of notification icons.
+	if(href_list["login"])
+		log_in()
+		return 1
+
+	if(href_list["logout"])
+		log_out()
+		return 1
+
+	if(href_list["reset"])
+		error = ""
+		return 1
+
+	if(href_list["new_message"])
+		new_message = TRUE
+		return 1
+
+	if(href_list["cancel"])
+		if(addressbook)
+			addressbook = FALSE
+		else
+			clear_message()
+		return 1
+
+	if(href_list["addressbook"])
+		addressbook = TRUE
+		return 1
+
+	if(href_list["set_recipient"])
+		msg_recipient = sanitize(href_list["set_recipient"])
+		addressbook = FALSE
+		return 1
+
+	if(href_list["edit_title"])
+		var/newtitle = sanitize(input(user,"Enter title for your message:", "Message title", msg_title), 100)
+		if(newtitle)
+			msg_title = newtitle
+		return 1
+
+	// This uses similar editing mechanism as the FileManager program, therefore it supports various paper tags and remembers formatting.
+	if(href_list["edit_body"])
+		var/oldtext = html_decode(msg_body)
+		oldtext = replacetext(oldtext, "\[editorbr\]", "\n")
+
+		var/newtext = sanitize(replacetext(input(usr, "Enter your message. You may use most tags from paper formatting", "Message Editor", oldtext) as message|null, "\n", "\[editorbr\]"), 20000)
+		if(newtext)
+			msg_body = newtext
+		return 1
+
+	if(href_list["edit_recipient"])
+		var/newrecipient = sanitize(input(user,"Enter recipient's email address:", "Recipient", msg_recipient), 100)
+		if(newrecipient)
+			msg_recipient = newrecipient
+		return 1
+
+	if(href_list["edit_login"])
+		var/newlogin = sanitize(input(user,"Enter login", "Login", stored_login), 100)
+		if(newlogin)
+			stored_login = newlogin
+		return 1
+
+	if(href_list["edit_password"])
+		var/newpass = sanitize(input(user,"Enter password", "Password"), 100)
+		if(newpass)
+			stored_password = newpass
+		return 1
+
+	if(href_list["delete"])
+		if(!istype(current_account))
+			return 1
+		var/datum/computer_file/data/email_message/M = find_message_by_fuid(href_list["delete"])
+		if(!istype(M))
+			return 1
+		if(folder == "Deleted")
+			current_account.deleted.Remove(M)
+			qdel(M)
+		else
+			current_account.deleted.Add(M)
+			current_account.inbox.Remove(M)
+			current_account.spam.Remove(M)
+		if(current_message == M)
+			current_message = null
+		return 1
+
+	if(href_list["send"])
+		if(!current_account)
+			return 1
+		if((msg_title == "") || (msg_body == "") || (msg_recipient == ""))
+			error = "Error sending mail: Title or message body is empty!"
+			return 1
+
+		var/datum/computer_file/data/email_message/message = new()
+		message.title = msg_title
+		message.stored_data = msg_body
+		message.source = current_account.login
+		message.attachment = msg_attachment
+		if(!current_account.send_mail(msg_recipient, message))
+			error = "Error sending email: this address doesn't exist."
+			return 1
+		else
+			error = "Email successfully sent."
+			clear_message()
+			return 1
+
+	if(href_list["set_folder"])
+		folder = href_list["set_folder"]
+		return 1
+
+	if(href_list["reply"])
+		var/datum/computer_file/data/email_message/M = find_message_by_fuid(href_list["reply"])
+		if(!istype(M))
+			return 1
+
+		new_message = TRUE
+		msg_recipient = M.source
+		msg_title = "Re: [M.title]"
+		msg_body = "\[editorbr\]\[editorbr\]\[editorbr\]\[br\]==============================\[br\]\[editorbr\]"
+		msg_body += "Received by [current_account.login] at [M.timestamp]\[br\]\[editorbr\][M.stored_data]"
+		return 1
+
+	if(href_list["view"])
+		var/datum/computer_file/data/email_message/M = find_message_by_fuid(href_list["view"])
+		if(istype(M))
+			current_message = M
+		return 1
+
+	if(href_list["changepassword"])
+		var/oldpassword = sanitize(input(user,"Please enter your old password:", "Password Change"), 100)
+		if(!oldpassword)
+			return 1
+		var/newpassword1 = sanitize(input(user,"Please enter your new password:", "Password Change"), 100)
+		if(!newpassword1)
+			return 1
+		var/newpassword2 = sanitize(input(user,"Please re-enter your new password:", "Password Change"), 100)
+		if(!newpassword2)
+			return 1
+
+		if(!istype(current_account))
+			error = "Please log in before proceeding."
+			return 1
+
+		if(current_account.password != oldpassword)
+			error = "Incorrect original password"
+			return 1
+
+		if(newpassword1 != newpassword2)
+			error = "The entered passwords do not match."
+			return 1
+
+		current_account.password = newpassword1
+		stored_password = newpassword1
+		error = "Your password has been successfully changed!"
+		return 1
+
+	// The following entries are Modular Computer framework only, and therefore won't do anything in other cases (like AI View)
+
+	if(href_list["save"])
+		// Fully dependant on modular computers here.
+		var/obj/item/modular_computer/MC = nano_host()
+
+		if(!istype(MC) || !MC.hard_drive || !MC.hard_drive.check_functionality())
+			error = "Error exporting file. Are you using a functional and NTOS-compliant device?"
+			return 1
+
+		var/filename = sanitize(input(user,"Please specify file name:", "Message export"), 100)
+		if(!filename)
+			return 1
+
+		var/datum/computer_file/data/email_message/M = find_message_by_fuid(href_list["save"])
+		var/datum/computer_file/data/mail = istype(M) ? M.export() : null
+		if(!istype(mail))
+			return 1
+		mail.filename = filename
+		if(!MC.hard_drive || !MC.hard_drive.store_file(mail))
+			error = "Internal I/O error when writing file, the hard drive may be full."
+		else
+			error = "Email exported successfully"
+		return 1
+
+	if(href_list["addattachment"])
+		var/obj/item/modular_computer/MC = nano_host()
+		msg_attachment = null
+
+		if(!istype(MC) || !MC.hard_drive || !MC.hard_drive.check_functionality())
+			error = "Error uploading file. Are you using a functional and NTOSv2-compliant device?"
+			return 1
+
+		var/list/filenames = list()
+		for(var/datum/computer_file/CF in MC.hard_drive.stored_files)
+			if(CF.unsendable)
+				continue
+			filenames.Add(CF.filename)
+		var/picked_file = input(user, "Please pick a file to send as attachment (max 32GQ)") as null|anything in filenames
+
+		if(!picked_file)
+			return 1
+
+		if(!istype(MC) || !MC.hard_drive || !MC.hard_drive.check_functionality())
+			error = "Error uploading file. Are you using a functional and NTOSv2-compliant device?"
+			return 1
+
+		for(var/datum/computer_file/CF in MC.hard_drive.stored_files)
+			if(CF.unsendable)
+				continue
+			if(CF.filename == picked_file)
+				msg_attachment = CF.clone()
+				break
+		if(!istype(msg_attachment))
+			msg_attachment = null
+			error = "Unknown error when uploading attachment."
+			return 1
+
+		if(msg_attachment.size > 32)
+			error = "Error uploading attachment: File exceeds maximal permitted file size of 32GQ."
+			msg_attachment = null
+		else
+			error = "File [msg_attachment.filename].[msg_attachment.filetype] has been successfully uploaded."
+		return 1
+
+	if(href_list["downloadattachment"])
+		if(!current_account || !current_message || !current_message.attachment)
+			return 1
+		var/obj/item/modular_computer/MC = nano_host()
+		if(!istype(MC) || !MC.hard_drive || !MC.hard_drive.check_functionality())
+			error = "Error downloading file. Are you using a functional and NTOSv2-compliant device?"
+			return 1
+
+		downloading = current_message.attachment.clone()
+		download_progress = 0
+		return 1
+
+	if(href_list["canceldownload"])
+		downloading = null
+		download_progress = 0
+		return 1
+
+	if(href_list["remove_attachment"])
+		msg_attachment = null
+		return 1

code/modules/modular_computers/file_system/programs/generic/file_browser.dm

@@ -0,0 +1,207 @@
+/datum/computer_file/program/filemanager
+	filename = "filemanager"
+	filedesc = "NTOS File Manager"
+	extended_desc = "This program allows management of files."
+	program_icon_state = "generic"
+	program_key_state = "generic_key"
+	program_menu_icon = "folder-collapsed"
+	size = 8
+	requires_ntnet = 0
+	available_on_ntnet = 0
+	undeletable = 1
+	nanomodule_path = /datum/nano_module/program/computer_filemanager/
+	var/open_file
+	var/error
+
+/datum/computer_file/program/filemanager/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["PRG_openfile"])
+		. = 1
+		open_file = href_list["PRG_openfile"]
+	if(href_list["PRG_newtextfile"])
+		. = 1
+		var/newname = sanitize(input(usr, "Enter file name or leave blank to cancel:", "File rename"))
+		if(!newname)
+			return 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/data/F = new/datum/computer_file/data()
+		F.filename = newname
+		F.filetype = "TXT"
+		HDD.store_file(F)
+	if(href_list["PRG_deletefile"])
+		. = 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/file = HDD.find_file_by_name(href_list["PRG_deletefile"])
+		if(!file || file.undeletable)
+			return 1
+		HDD.remove_file(file)
+	if(href_list["PRG_usbdeletefile"])
+		. = 1
+		var/obj/item/weapon/computer_hardware/hard_drive/RHDD = computer.portable_drive
+		if(!RHDD)
+			return 1
+		var/datum/computer_file/file = RHDD.find_file_by_name(href_list["PRG_usbdeletefile"])
+		if(!file || file.undeletable)
+			return 1
+		RHDD.remove_file(file)
+	if(href_list["PRG_closefile"])
+		. = 1
+		open_file = null
+		error = null
+	if(href_list["PRG_clone"])
+		. = 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/F = HDD.find_file_by_name(href_list["PRG_clone"])
+		if(!F || !istype(F))
+			return 1
+		var/datum/computer_file/C = F.clone(1)
+		HDD.store_file(C)
+	if(href_list["PRG_rename"])
+		. = 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/file = HDD.find_file_by_name(href_list["PRG_rename"])
+		if(!file || !istype(file))
+			return 1
+		var/newname = sanitize(input(usr, "Enter new file name:", "File rename", file.filename))
+		if(file && newname)
+			file.filename = newname
+	if(href_list["PRG_edit"])
+		. = 1
+		if(!open_file)
+			return 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/data/F = HDD.find_file_by_name(open_file)
+		if(!F || !istype(F))
+			return 1
+		if(F.do_not_edit && (alert("WARNING: This file is not compatible with editor. Editing it may result in permanently corrupted formatting or damaged data consistency. Edit anyway?", "Incompatible File", "No", "Yes") == "No"))
+			return 1
+
+		var/oldtext = html_decode(F.stored_data)
+		oldtext = replacetext(oldtext, "\[br\]", "\n")
+
+		var/newtext = sanitize(replacetext(input(usr, "Editing file [open_file]. You may use most tags used in paper formatting:", "Text Editor", oldtext) as message|null, "\n", "\[br\]"), MAX_TEXTFILE_LENGTH)
+		if(!newtext)
+			return
+
+		if(F)
+			var/datum/computer_file/data/backup = F.clone()
+			HDD.remove_file(F)
+			F.stored_data = newtext
+			F.calculate_size()
+			// We can't store the updated file, it's probably too large. Print an error and restore backed up version.
+			// This is mostly intended to prevent people from losing texts they spent lot of time working on due to running out of space.
+			// They will be able to copy-paste the text from error screen and store it in notepad or something.
+			if(!HDD.store_file(F))
+				error = "I/O error: Unable to overwrite file. Hard drive is probably full. You may want to backup your changes before closing this window:<br><br>[html_decode(F.stored_data)]<br><br>"
+				HDD.store_file(backup)
+	if(href_list["PRG_printfile"])
+		. = 1
+		if(!open_file)
+			return 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/data/F = HDD.find_file_by_name(open_file)
+		if(!F || !istype(F))
+			return 1
+		if(!computer.nano_printer)
+			error = "Missing Hardware: Your computer does not have required hardware to complete this operation."
+			return 1
+		if(!computer.nano_printer.print_text(pencode2html(F.stored_data)))
+			error = "Hardware error: Printer was unable to print the file. It may be out of paper."
+			return 1
+	if(href_list["PRG_copytousb"])
+		. = 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		var/obj/item/weapon/computer_hardware/hard_drive/portable/RHDD = computer.portable_drive
+		if(!HDD || !RHDD)
+			return 1
+		var/datum/computer_file/F = HDD.find_file_by_name(href_list["PRG_copytousb"])
+		if(!F || !istype(F))
+			return 1
+		var/datum/computer_file/C = F.clone(0)
+		RHDD.store_file(C)
+	if(href_list["PRG_copyfromusb"])
+		. = 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		var/obj/item/weapon/computer_hardware/hard_drive/portable/RHDD = computer.portable_drive
+		if(!HDD || !RHDD)
+			return 1
+		var/datum/computer_file/F = RHDD.find_file_by_name(href_list["PRG_copyfromusb"])
+		if(!F || !istype(F))
+			return 1
+		var/datum/computer_file/C = F.clone(0)
+		HDD.store_file(C)
+	if(.)
+		SSnanoui.update_uis(NM)
+
+/datum/nano_module/program/computer_filemanager
+	name = "NTOS File Manager"
+
+/datum/nano_module/program/computer_filemanager/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+	var/datum/computer_file/program/filemanager/PRG
+	PRG = program
+
+	var/obj/item/weapon/computer_hardware/hard_drive/HDD
+	var/obj/item/weapon/computer_hardware/hard_drive/portable/RHDD
+	if(PRG.error)
+		data["error"] = PRG.error
+	if(PRG.open_file)
+		var/datum/computer_file/data/file
+
+		if(!PRG.computer || !PRG.computer.hard_drive)
+			data["error"] = "I/O ERROR: Unable to access hard drive."
+		else
+			HDD = PRG.computer.hard_drive
+			file = HDD.find_file_by_name(PRG.open_file)
+			if(!istype(file))
+				data["error"] = "I/O ERROR: Unable to open file."
+			else
+				data["filedata"] = pencode2html(file.stored_data)
+				data["filename"] = "[file.filename].[file.filetype]"
+	else
+		if(!PRG.computer || !PRG.computer.hard_drive)
+			data["error"] = "I/O ERROR: Unable to access hard drive."
+		else
+			HDD = PRG.computer.hard_drive
+			RHDD = PRG.computer.portable_drive
+			var/list/files[0]
+			for(var/datum/computer_file/F in HDD.stored_files)
+				files.Add(list(list(
+					"name" = F.filename,
+					"type" = F.filetype,
+					"size" = F.size,
+					"undeletable" = F.undeletable
+				)))
+			data["files"] = files
+			if(RHDD)
+				data["usbconnected"] = 1
+				var/list/usbfiles[0]
+				for(var/datum/computer_file/F in RHDD.stored_files)
+					usbfiles.Add(list(list(
+						"name" = F.filename,
+						"type" = F.filetype,
+						"size" = F.size,
+						"undeletable" = F.undeletable
+					)))
+				data["usbfiles"] = usbfiles
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "file_manager.tmpl", "NTOS File Manager", 575, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()

code/modules/modular_computers/file_system/programs/generic/game.dm

@@ -0,0 +1,152 @@
+// This file is used as a reference for Modular Computers Development guide on the wiki. It contains a lot of excess comments, as it is intended as explanation
+// for someone who may not be as experienced in coding. When making changes, please try to keep it this way.
+
+// An actual program definition.
+/datum/computer_file/program/game
+	filename = "arcadec"					// File name, as shown in the file browser program.
+	filedesc = "Unknown Game"				// User-Friendly name. In this case, we will generate a random name in constructor.
+	program_icon_state = "game"				// Icon state of this program's screen.
+	program_menu_icon = "script"
+	extended_desc = "Fun for the whole family! Probably not an AAA title, but at least you can download it on the corporate network.."		// A nice description.
+	size = 5								// Size in GQ. Integers only. Smaller sizes should be used for utility/low use programs (like this one), while large sizes are for important programs.
+	requires_ntnet = 0						// This particular program does not require NTNet network conectivity...
+	available_on_ntnet = 1					// ... but we want it to be available for download.
+	nanomodule_path = /datum/nano_module/arcade_classic/	// Path of relevant nano module. The nano module is defined further in the file.
+	var/picked_enemy_name
+
+// Blatantly stolen and shortened version from arcade machines. Generates a random enemy name
+/datum/computer_file/program/game/proc/random_enemy_name()
+	var/name_part1 = pick("the Automatic ", "Farmer ", "Lord ", "Professor ", "the Cuban ", "the Evil ", "the Dread King ", "the Space ", "Lord ", "the Great ", "Duke ", "General ")
+	var/name_part2 = pick("Melonoid", "Murdertron", "Sorcerer", "Ruin", "Jeff", "Ectoplasm", "Crushulon", "Uhangoid", "Vhakoid", "Peteoid", "Slime", "Lizard Man", "Unicorn")
+	return "[name_part1] [name_part2]"
+
+// When the program is first created, we generate a new enemy name and name ourselves accordingly.
+/datum/computer_file/program/game/New()
+	..()
+	picked_enemy_name = random_enemy_name()
+	filedesc = "Defeat [picked_enemy_name]"
+
+// Important in order to ensure that copied versions will have the same enemy name.
+/datum/computer_file/program/game/clone()
+	var/datum/computer_file/program/game/G = ..()
+	G.picked_enemy_name = picked_enemy_name
+	return G
+
+// When running the program, we also want to pass our enemy name to the nano module.
+/datum/computer_file/program/game/run_program()
+	. = ..()
+	if(. && NM)
+		var/datum/nano_module/arcade_classic/NMC = NM
+		NMC.enemy_name = picked_enemy_name
+
+
+// Nano module the program uses.
+// This can be either /datum/nano_module/ or /datum/nano_module/program. The latter is intended for nano modules that are suposed to be exclusively used with modular computers,
+// and should generally not be used, as such nano modules are hard to use on other places.
+/datum/nano_module/arcade_classic/
+	name = "Classic Arcade"
+	var/player_mana			// Various variables specific to the nano module. In this case, the nano module is a simple arcade game, so the variables store health and other stats.
+	var/player_health
+	var/enemy_mana
+	var/enemy_health
+	var/enemy_name = "Greytide Horde"
+	var/gameover
+	var/information
+
+/datum/nano_module/arcade_classic/New()
+	..()
+	new_game()
+
+// ui_interact handles transfer of data to NanoUI. Keep in mind that data you pass from here is actually sent to the client. In other words, don't send anything you don't want a client
+// to see, and don't send unnecessarily large amounts of data (due to laginess).
+/datum/nano_module/arcade_classic/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	data["player_health"] = player_health
+	data["player_mana"] = player_mana
+	data["enemy_health"] = enemy_health
+	data["enemy_mana"] = enemy_mana
+	data["enemy_name"] = enemy_name
+	data["gameover"] = gameover
+	data["information"] = information
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "arcade_classic.tmpl", "Defeat [enemy_name]", 500, 350, state = state)
+		if(host.update_layout())
+			ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+
+// Three helper procs i've created. These are unique to this particular nano module. If you are creating your own nano module, you'll most likely create similar procs too.
+/datum/nano_module/arcade_classic/proc/enemy_play()
+	if((enemy_mana < 5) && prob(60))
+		var/steal = rand(2, 3)
+		player_mana -= steal
+		enemy_mana += steal
+		information += "[enemy_name] steals [steal] of your power!"
+	else if((enemy_health < 15) && (enemy_mana > 3) && prob(80))
+		var/healamt = min(rand(3, 5), enemy_mana)
+		enemy_mana -= healamt
+		enemy_health += healamt
+		information += "[enemy_name] heals for [healamt] health!"
+	else
+		var/dam = rand(3,6)
+		player_health -= dam
+		information += "[enemy_name] attacks for [dam] damage!"
+
+/datum/nano_module/arcade_classic/proc/check_gameover()
+	if((player_health <= 0) || player_mana <= 0)
+		if(enemy_health <= 0)
+			information += "You have defeated [enemy_name], but you have died in the fight!"
+		else
+			information += "You have been defeated by [enemy_name]!"
+		gameover = 1
+		return TRUE
+	else if(enemy_health <= 0)
+		gameover = 1
+		information += "Congratulations! You have defeated [enemy_name]!"
+		return TRUE
+	return FALSE
+
+/datum/nano_module/arcade_classic/proc/new_game()
+	player_mana = 10
+	player_health = 30
+	enemy_mana = 20
+	enemy_health = 45
+	gameover = FALSE
+	information = "A new game has started!"
+
+
+
+/datum/nano_module/arcade_classic/Topic(href, href_list)
+	if(..())		// Always begin your Topic() calls with a parent call!
+		return 1
+	if(href_list["new_game"])
+		new_game()
+		return 1	// Returning 1 (TRUE) in Topic automatically handles UI updates.
+	if(gameover)	// If the game has already ended, we don't want the following three topic calls to be processed at all.
+		return 1	// Instead of adding checks into each of those three, we can easily add this one check here to reduce on code copy-paste.
+	if(href_list["attack"])
+		var/damage = rand(2, 6)
+		information = "You attack for [damage] damage."
+		enemy_health -= damage
+		enemy_play()
+		check_gameover()
+		return 1
+	if(href_list["heal"])
+		var/healfor = rand(6, 8)
+		var/cost = rand(1, 3)
+		information = "You heal yourself for [healfor] damage, using [cost] energy in the process."
+		player_health += healfor
+		player_mana -= cost
+		enemy_play()
+		check_gameover()
+		return 1
+	if(href_list["regain_mana"])
+		var/regen = rand(4, 7)
+		information = "You rest of a while, regaining [regen] energy."
+		player_mana += regen
+		enemy_play()
+		check_gameover()
+		return 1

code/modules/modular_computers/file_system/programs/generic/news_browser.dm

@@ -0,0 +1,131 @@
+/datum/computer_file/program/newsbrowser
+	filename = "newsbrowser"
+	filedesc = "NTNet/ExoNet News Browser"
+	extended_desc = "This program may be used to view and download news articles from the network."
+	program_icon_state = "generic"
+	program_key_state = "generic_key"
+	program_menu_icon = "contact"
+	size = 4
+	requires_ntnet = 1
+	available_on_ntnet = 1
+
+	nanomodule_path = /datum/nano_module/program/computer_newsbrowser/
+	var/datum/computer_file/data/news_article/loaded_article
+	var/download_progress = 0
+	var/download_netspeed = 0
+	var/downloading = 0
+	var/message = ""
+	var/show_archived = 0
+
+/datum/computer_file/program/newsbrowser/process_tick()
+	if(!downloading)
+		return
+	download_netspeed = 0
+	// Speed defines are found in misc.dm
+	switch(ntnet_status)
+		if(1)
+			download_netspeed = NTNETSPEED_LOWSIGNAL
+		if(2)
+			download_netspeed = NTNETSPEED_HIGHSIGNAL
+		if(3)
+			download_netspeed = NTNETSPEED_ETHERNET
+	download_progress += download_netspeed
+	if(download_progress >= loaded_article.size)
+		downloading = 0
+		requires_ntnet = 0 // Turn off NTNet requirement as we already loaded the file into local memory.
+	SSnanoui.update_uis(NM)
+
+/datum/computer_file/program/newsbrowser/kill_program()
+	..()
+	requires_ntnet = 1
+	loaded_article = null
+	download_progress = 0
+	downloading = 0
+	show_archived = 0
+
+/datum/computer_file/program/newsbrowser/Topic(href, href_list)
+	if(..())
+		return 1
+	if(href_list["PRG_openarticle"])
+		. = 1
+		if(downloading || loaded_article)
+			return 1
+
+		for(var/datum/computer_file/data/news_article/N in ntnet_global.available_news)
+			if(N.uid == text2num(href_list["PRG_openarticle"]))
+				loaded_article = N.clone()
+				downloading = 1
+				break
+	if(href_list["PRG_reset"])
+		. = 1
+		downloading = 0
+		download_progress = 0
+		requires_ntnet = 1
+		loaded_article = null
+	if(href_list["PRG_clearmessage"])
+		. = 1
+		message = ""
+	if(href_list["PRG_savearticle"])
+		. = 1
+		if(downloading || !loaded_article)
+			return
+
+		var/savename = sanitize(input(usr, "Enter file name or leave blank to cancel:", "Save article", loaded_article.filename))
+		if(!savename)
+			return 1
+		var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+		if(!HDD)
+			return 1
+		var/datum/computer_file/data/news_article/N = loaded_article.clone()
+		N.filename = savename
+		HDD.store_file(N)
+	if(href_list["PRG_toggle_archived"])
+		. = 1
+		show_archived = !show_archived
+	if(.)
+		SSnanoui.update_uis(NM)
+
+
+/datum/nano_module/program/computer_newsbrowser
+	name = "NTNet/ExoNet News Browser"
+
+/datum/nano_module/program/computer_newsbrowser/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+
+	var/datum/computer_file/program/newsbrowser/PRG
+	var/list/data = list()
+	if(program)
+		data = program.get_header_data()
+		PRG = program
+	else
+		return
+
+	data["message"] = PRG.message
+	if(PRG.loaded_article && !PRG.downloading) 	// Viewing an article.
+		data["title"] = PRG.loaded_article.filename
+		data["cover"] = PRG.loaded_article.cover
+		data["article"] = PRG.loaded_article.stored_data
+	else if(PRG.downloading)					// Downloading an article.
+		data["download_running"] = 1
+		data["download_progress"] = PRG.download_progress
+		data["download_maxprogress"] = PRG.loaded_article.size
+		data["download_rate"] = PRG.download_netspeed
+	else										// Viewing list of articles
+		var/list/all_articles[0]
+		for(var/datum/computer_file/data/news_article/F in ntnet_global.available_news)
+			if(!PRG.show_archived && F.archived)
+				continue
+			all_articles.Add(list(list(
+				"name" = F.filename,
+				"size" = F.size,
+				"uid" = F.uid,
+				"archived" = F.archived
+			)))
+		data["all_articles"] = all_articles
+		data["showing_archived"] = PRG.show_archived
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "news_browser.tmpl", "NTNet/ExoNet News Browser", 575, 750, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()

code/modules/modular_computers/file_system/programs/generic/ntdownloader.dm

@@ -0,0 +1,200 @@
+/datum/computer_file/program/ntnetdownload
+	filename = "ntndownloader"
+	filedesc = "NTNet Software Download Tool"
+	program_icon_state = "generic"
+	program_key_state = "generic_key"
+	program_menu_icon = "arrowthickstop-1-s"
+	extended_desc = "This program allows downloads of software from official NT repositories"
+	unsendable = 1
+	undeletable = 1
+	size = 4
+	requires_ntnet = 1
+	requires_ntnet_feature = NTNET_SOFTWAREDOWNLOAD
+	available_on_ntnet = 0
+	nanomodule_path = /datum/nano_module/program/computer_ntnetdownload/
+	ui_header = "downloader_finished.gif"
+	var/datum/computer_file/program/downloaded_file = null
+	var/hacked_download = 0
+	var/download_completion = 0 //GQ of downloaded data.
+	var/download_netspeed = 0
+	var/downloaderror = ""
+	var/list/downloads_queue[0]
+
+/datum/computer_file/program/ntnetdownload/kill_program()
+	..()
+	downloaded_file = null
+	download_completion = 0
+	download_netspeed = 0
+	downloaderror = ""
+	ui_header = "downloader_finished.gif"
+
+
+/datum/computer_file/program/ntnetdownload/proc/begin_file_download(var/filename)
+	if(downloaded_file)
+		return 0
+
+	var/datum/computer_file/program/PRG = ntnet_global.find_ntnet_file_by_name(filename)
+
+	if(!check_file_download(filename))
+		return 0
+
+	ui_header = "downloader_running.gif"
+
+	if(PRG in ntnet_global.available_station_software)
+		generate_network_log("Began downloading file [PRG.filename].[PRG.filetype] from NTNet Software Repository.")
+		hacked_download = 0
+	else if(PRG in ntnet_global.available_antag_software)
+		generate_network_log("Began downloading file **ENCRYPTED**.[PRG.filetype] from unspecified server.")
+		hacked_download = 1
+	else
+		generate_network_log("Began downloading file [PRG.filename].[PRG.filetype] from unspecified server.")
+		hacked_download = 0
+
+	downloaded_file = PRG.clone()
+
+/datum/computer_file/program/ntnetdownload/proc/check_file_download(var/filename)
+	//returns 1 if file can be downloaded, returns 0 if download prohibited
+	var/datum/computer_file/program/PRG = ntnet_global.find_ntnet_file_by_name(filename)
+
+	if(!PRG || !istype(PRG))
+		return 0
+
+	// Attempting to download antag only program, but without having emagged computer. No.
+	if(PRG.available_on_syndinet && !computer_emagged)
+		return 0
+
+	if(!computer || !computer.hard_drive || !computer.hard_drive.try_store_file(PRG))
+		return 0
+
+	return 1
+
+/datum/computer_file/program/ntnetdownload/proc/abort_file_download()
+	if(!downloaded_file)
+		return
+	generate_network_log("Aborted download of file [hacked_download ? "**ENCRYPTED**" : downloaded_file.filename].[downloaded_file.filetype].")
+	downloaded_file = null
+	download_completion = 0
+	ui_header = "downloader_finished.gif"
+
+/datum/computer_file/program/ntnetdownload/proc/complete_file_download()
+	if(!downloaded_file)
+		return
+	generate_network_log("Completed download of file [hacked_download ? "**ENCRYPTED**" : downloaded_file.filename].[downloaded_file.filetype].")
+	if(!computer || !computer.hard_drive || !computer.hard_drive.store_file(downloaded_file))
+		// The download failed
+		downloaderror = "I/O ERROR - Unable to save file. Check whether you have enough free space on your hard drive and whether your hard drive is properly connected. If the issue persists contact your system administrator for assistance."
+	downloaded_file = null
+	download_completion = 0
+	ui_header = "downloader_finished.gif"
+
+/datum/computer_file/program/ntnetdownload/process_tick()
+	if(!downloaded_file)
+		return
+	if(download_completion >= downloaded_file.size)
+		complete_file_download()
+		if(downloads_queue.len > 0)
+			begin_file_download(downloads_queue[1])
+			downloads_queue.Remove(downloads_queue[1])
+
+	// Download speed according to connectivity state. NTNet server is assumed to be on unlimited speed so we're limited by our local connectivity
+	download_netspeed = 0
+	// Speed defines are found in misc.dm
+	switch(ntnet_status)
+		if(1)
+			download_netspeed = NTNETSPEED_LOWSIGNAL
+		if(2)
+			download_netspeed = NTNETSPEED_HIGHSIGNAL
+		if(3)
+			download_netspeed = NTNETSPEED_ETHERNET
+	download_completion += download_netspeed
+
+/datum/computer_file/program/ntnetdownload/Topic(href, href_list)
+	if(..())
+		return 1
+	if(href_list["PRG_downloadfile"])
+		if(!downloaded_file)
+			begin_file_download(href_list["PRG_downloadfile"])
+		else if(check_file_download(href_list["PRG_downloadfile"]) && !downloads_queue.Find(href_list["PRG_downloadfile"]) && downloaded_file.filename != href_list["PRG_downloadfile"])
+			downloads_queue += href_list["PRG_downloadfile"]
+		return 1
+	if(href_list["PRG_removequeued"])
+		downloads_queue.Remove(href_list["PRG_removequeued"])
+		return 1
+	if(href_list["PRG_reseterror"])
+		if(downloaderror)
+			download_completion = 0
+			download_netspeed = 0
+			downloaded_file = null
+			downloaderror = ""
+		return 1
+	return 0
+
+/datum/nano_module/program/computer_ntnetdownload
+	name = "Network Downloader"
+	var/obj/item/modular_computer/my_computer = null
+
+/datum/nano_module/program/computer_ntnetdownload/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(program)
+		my_computer = program.computer
+
+	if(!istype(my_computer))
+		return
+
+	var/list/data = list()
+	var/datum/computer_file/program/ntnetdownload/prog = program
+	// For now limited to execution by the downloader program
+	if(!prog || !istype(prog))
+		return
+	if(program)
+		data = program.get_header_data()
+
+	// This IF cuts on data transferred to client, so i guess it's worth it.
+	if(prog.downloaderror) // Download errored. Wait until user resets the program.
+		data["error"] = prog.downloaderror
+	if(prog.downloaded_file) // Download running. Wait please..
+		data["downloadname"] = prog.downloaded_file.filename
+		data["downloaddesc"] = prog.downloaded_file.filedesc
+		data["downloadsize"] = prog.downloaded_file.size
+		data["downloadspeed"] = prog.download_netspeed
+		data["downloadcompletion"] = round(prog.download_completion, 0.1)
+
+	data["disk_size"] = my_computer.hard_drive.max_capacity
+	data["disk_used"] = my_computer.hard_drive.used_capacity
+	var/list/all_entries[0]
+	for(var/datum/computer_file/program/P in ntnet_global.available_station_software)
+		// Only those programs our user can run will show in the list
+		if(!P.can_run(user) && P.requires_access_to_download)
+			continue
+		all_entries.Add(list(list(
+		"filename" = P.filename,
+		"filedesc" = P.filedesc,
+		"fileinfo" = P.extended_desc,
+		"size" = P.size,
+		"icon" = P.program_menu_icon
+		)))
+	data["hackedavailable"] = 0
+	if(prog.computer_emagged) // If we are running on emagged computer we have access to some "bonus" software
+		var/list/hacked_programs[0]
+		for(var/datum/computer_file/program/P in ntnet_global.available_antag_software)
+			data["hackedavailable"] = 1
+			hacked_programs.Add(list(list(
+			"filename" = P.filename,
+			"filedesc" = P.filedesc,
+			"fileinfo" = P.extended_desc,
+			"size" = P.size,
+			"icon" = P.program_menu_icon
+			)))
+		data["hacked_programs"] = hacked_programs
+
+	data["downloadable_programs"] = all_entries
+
+	if(prog.downloads_queue.len > 0)
+		data["downloads_queue"] = prog.downloads_queue
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "ntnet_downloader.tmpl", "NTNet Download Program", 575, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)

code/modules/modular_computers/file_system/programs/generic/ntnrc_client.dm

@@ -0,0 +1,232 @@
+/datum/computer_file/program/chatclient
+	filename = "ntnrc_client"
+	filedesc = "NTNet Relay Chat Client"
+	program_icon_state = "command"
+	program_key_state = "med_key"
+	program_menu_icon = "comment"
+	extended_desc = "This program allows communication over NTNRC network"
+	size = 8
+	requires_ntnet = 1
+	requires_ntnet_feature = NTNET_COMMUNICATION
+	network_destination = "NTNRC server"
+	ui_header = "ntnrc_idle.gif"
+	available_on_ntnet = 1
+	nanomodule_path = /datum/nano_module/program/computer_chatclient/
+	var/last_message = null				// Used to generate the toolbar icon
+	var/username
+	var/datum/ntnet_conversation/channel = null
+	var/operator_mode = 0		// Channel operator mode
+	var/netadmin_mode = 0		// Administrator mode (invisible to other users + bypasses passwords)
+
+/datum/computer_file/program/chatclient/New()
+	username = "DefaultUser[rand(100, 999)]"
+
+/datum/computer_file/program/chatclient/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["PRG_speak"])
+		. = 1
+		if(!channel)
+			return 1
+		var/mob/living/user = usr
+		var/message = sanitize(input(user, "Enter message or leave blank to cancel: "), 512)
+		if(!message || !channel)
+			return
+		channel.add_message(message, username)
+
+	if(href_list["PRG_joinchannel"])
+		. = 1
+		var/datum/ntnet_conversation/C
+		for(var/datum/ntnet_conversation/chan in ntnet_global.chat_channels)
+			if(chan.id == text2num(href_list["PRG_joinchannel"]))
+				C = chan
+				break
+
+		if(!C)
+			return 1
+
+		if(netadmin_mode)
+			channel = C		// Bypasses normal leave/join and passwords. Technically makes the user invisible to others.
+			return 1
+
+		if(C.password)
+			var/mob/living/user = usr
+			var/password = sanitize(input(user,"Access Denied. Enter password:"))
+			if(C && (password == C.password))
+				C.add_client(src)
+				channel = C
+			return 1
+		C.add_client(src)
+		channel = C
+	if(href_list["PRG_leavechannel"])
+		. = 1
+		if(channel)
+			channel.remove_client(src)
+		channel = null
+	if(href_list["PRG_newchannel"])
+		. = 1
+		var/mob/living/user = usr
+		var/channel_title = sanitizeSafe(input(user,"Enter channel name or leave blank to cancel:"), 64)
+		if(!channel_title)
+			return
+		var/datum/ntnet_conversation/C = new/datum/ntnet_conversation()
+		C.add_client(src)
+		C.operator = src
+		channel = C
+		C.title = channel_title
+	if(href_list["PRG_toggleadmin"])
+		. = 1
+		if(netadmin_mode)
+			netadmin_mode = 0
+			if(channel)
+				channel.remove_client(src) // We shouldn't be in channel's user list, but just in case...
+				channel = null
+			return 1
+		var/mob/living/user = usr
+		if(can_run(usr, 1, access_network))
+			if(channel)
+				var/response = alert(user, "Really engage admin-mode? You will be disconnected from your current channel!", "NTNRC Admin mode", "Yes", "No")
+				if(response == "Yes")
+					if(channel)
+						channel.remove_client(src)
+						channel = null
+				else
+					return
+			netadmin_mode = 1
+	if(href_list["PRG_changename"])
+		. = 1
+		var/mob/living/user = usr
+		var/newname = sanitize(input(user,"Enter new nickname or leave blank to cancel:"), 20)
+		if(!newname)
+			return 1
+		if(channel)
+			channel.add_status_message("[username] is now known as [newname].")
+		username = newname
+
+	if(href_list["PRG_savelog"])
+		. = 1
+		if(!channel)
+			return
+		var/mob/living/user = usr
+		var/logname = input(user,"Enter desired logfile name (.log) or leave blank to cancel:")
+		if(!logname || !channel)
+			return 1
+		var/datum/computer_file/data/logfile = new/datum/computer_file/data/logfile()
+		// Now we will generate HTML-compliant file that can actually be viewed/printed.
+		logfile.filename = logname
+		logfile.stored_data = "\[b\]Logfile dump from NTNRC channel [channel.title]\[/b\]\[BR\]"
+		for(var/logstring in channel.messages)
+			logfile.stored_data += "[logstring]\[BR\]"
+		logfile.stored_data += "\[b\]Logfile dump completed.\[/b\]"
+		logfile.calculate_size()
+		if(!computer || !computer.hard_drive || !computer.hard_drive.store_file(logfile))
+			if(!computer)
+				// This program shouldn't even be runnable without computer.
+				CRASH("Var computer is null!")
+				return 1
+			if(!computer.hard_drive)
+				computer.visible_message("\The [computer] shows an \"I/O Error - Hard drive connection error\" warning.")
+			else	// In 99.9% cases this will mean our HDD is full
+				computer.visible_message("\The [computer] shows an \"I/O Error - Hard drive may be full. Please free some space and try again. Required space: [logfile.size]GQ\" warning.")
+	if(href_list["PRG_renamechannel"])
+		. = 1
+		if(!operator_mode || !channel)
+			return 1
+		var/mob/living/user = usr
+		var/newname = sanitize(input(user, "Enter new channel name or leave blank to cancel:"), 64)
+		if(!newname || !channel)
+			return
+		channel.add_status_message("Channel renamed from [channel.title] to [newname] by operator.")
+		channel.title = newname
+	if(href_list["PRG_deletechannel"])
+		. = 1
+		if(channel && ((channel.operator == src) || netadmin_mode))
+			qdel(channel)
+			channel = null
+	if(href_list["PRG_setpassword"])
+		. = 1
+		if(!channel || ((channel.operator != src) && !netadmin_mode))
+			return 1
+
+		var/mob/living/user = usr
+		var/newpassword = sanitize(input(user, "Enter new password for this channel. Leave blank to cancel, enter 'nopassword' to remove password completely:"))
+		if(!channel || !newpassword || ((channel.operator != src) && !netadmin_mode))
+			return 1
+
+		if(newpassword == "nopassword")
+			channel.password = ""
+		else
+			channel.password = newpassword
+
+/datum/computer_file/program/chatclient/process_tick()
+	..()
+	if(program_state != PROGRAM_STATE_KILLED)
+		ui_header = "ntnrc_idle.gif"
+		if(channel)
+			// Remember the last message. If there is no message in the channel remember null.
+			last_message = channel.messages.len ? channel.messages[channel.messages.len - 1] : null
+		else
+			last_message = null
+		return 1
+	if(channel && channel.messages && channel.messages.len)
+		ui_header = last_message == channel.messages[channel.messages.len - 1] ? "ntnrc_idle.gif" : "ntnrc_new.gif"
+	else
+		ui_header = "ntnrc_idle.gif"
+
+/datum/computer_file/program/chatclient/kill_program(var/forced = 0)
+	if(channel)
+		channel.remove_client(src)
+		channel = null
+	..(forced)
+
+/datum/nano_module/program/computer_chatclient
+	name = "NTNet Relay Chat Client"
+
+/datum/nano_module/program/computer_chatclient/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(!ntnet_global || !ntnet_global.chat_channels)
+		return
+
+	var/list/data = list()
+	if(program)
+		data = program.get_header_data()
+
+	var/datum/computer_file/program/chatclient/C = program
+	if(!istype(C))
+		return
+
+	data["adminmode"] = C.netadmin_mode
+	if(C.channel)
+		data["title"] = C.channel.title
+		var/list/messages[0]
+		for(var/M in C.channel.messages)
+			messages.Add(list(list(
+				"msg" = M
+			)))
+		data["messages"] = messages
+		var/list/clients[0]
+		for(var/datum/computer_file/program/chatclient/cl in C.channel.clients)
+			clients.Add(list(list(
+				"name" = cl.username
+			)))
+		data["clients"] = clients
+		C.operator_mode = (C.channel.operator == C) ? 1 : 0
+		data["is_operator"] = C.operator_mode || C.netadmin_mode
+
+	else // Channel selection screen
+		var/list/all_channels[0]
+		for(var/datum/ntnet_conversation/conv in ntnet_global.chat_channels)
+			if(conv && conv.title)
+				all_channels.Add(list(list(
+					"chan" = conv.title,
+					"id" = conv.id
+				)))
+		data["all_channels"] = all_channels
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "ntnet_chat.tmpl", "NTNet Relay Chat Client", 575, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)

code/modules/modular_computers/file_system/programs/generic/nttransfer.dm

@@ -0,0 +1,185 @@
+var/global/nttransfer_uid = 0
+
+/datum/computer_file/program/nttransfer
+	filename = "nttransfer"
+	filedesc = "NTNet P2P Transfer Client"
+	extended_desc = "This program allows for simple file transfer via direct peer to peer connection."
+	program_icon_state = "comm_logs"
+	program_key_state = "generic_key"
+	program_menu_icon = "transferthick-e-w"
+	size = 7
+	requires_ntnet = 1
+	requires_ntnet_feature = NTNET_PEERTOPEER
+	network_destination = "other device via P2P tunnel"
+	available_on_ntnet = 1
+	nanomodule_path = /datum/nano_module/program/computer_nttransfer/
+
+	var/error = ""										// Error screen
+	var/server_password = ""							// Optional password to download the file.
+	var/datum/computer_file/provided_file = null		// File which is provided to clients.
+	var/datum/computer_file/downloaded_file = null		// File which is being downloaded
+	var/list/connected_clients = list()					// List of connected clients.
+	var/datum/computer_file/program/nttransfer/remote	// Client var, specifies who are we downloading from.
+	var/download_completion = 0							// Download progress in GQ
+	var/actual_netspeed = 0								// Displayed in the UI, this is the actual transfer speed.
+	var/unique_token 									// UID of this program
+	var/upload_menu = 0									// Whether we show the program list and upload menu
+
+/datum/computer_file/program/nttransfer/New()
+	unique_token = nttransfer_uid
+	nttransfer_uid++
+	..()
+
+/datum/computer_file/program/nttransfer/process_tick()
+	..()
+	// Server mode
+	if(provided_file)
+		for(var/datum/computer_file/program/nttransfer/C in connected_clients)
+			// Transfer speed is limited by device which uses slower connectivity.
+			// We can have multiple clients downloading at same time, but let's assume we use some sort of multicast transfer
+			// so they can all run on same speed.
+			C.actual_netspeed = min(C.ntnet_speed, ntnet_speed)
+			C.download_completion += C.actual_netspeed
+			if(C.download_completion >= provided_file.size)
+				C.finish_download()
+	else if(downloaded_file) // Client mode
+		if(!remote)
+			crash_download("Connection to remote server lost")
+
+/datum/computer_file/program/nttransfer/kill_program(var/forced = 0)
+	if(downloaded_file) // Client mode, clean up variables for next use
+		finalize_download()
+
+	if(provided_file) // Server mode, disconnect all clients
+		for(var/datum/computer_file/program/nttransfer/P in connected_clients)
+			P.crash_download("Connection terminated by remote server")
+		downloaded_file = null
+	..(forced)
+
+// Finishes download and attempts to store the file on HDD
+/datum/computer_file/program/nttransfer/proc/finish_download()
+	if(!computer || !computer.hard_drive || !computer.hard_drive.store_file(downloaded_file))
+		error = "I/O Error:  Unable to save file. Check your hard drive and try again."
+	finalize_download()
+
+//  Crashes the download and displays specific error message
+/datum/computer_file/program/nttransfer/proc/crash_download(var/message)
+	error = message ? message : "An unknown error has occured during download"
+	finalize_download()
+
+// Cleans up variables for next use
+/datum/computer_file/program/nttransfer/proc/finalize_download()
+	if(remote)
+		remote.connected_clients.Remove(src)
+	downloaded_file = null
+	remote = null
+	download_completion = 0
+
+
+/datum/nano_module/program/computer_nttransfer
+	name = "NTNet P2P Transfer Client"
+
+/datum/nano_module/program/computer_nttransfer/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(!program)
+		return
+	var/datum/computer_file/program/nttransfer/PRG = program
+	if(!istype(PRG))
+		return
+
+	var/list/data = program.get_header_data()
+
+	if(PRG.error)
+		data["error"] = PRG.error
+	else if(PRG.downloaded_file)
+		data["downloading"] = 1
+		data["download_size"] = PRG.downloaded_file.size
+		data["download_progress"] = PRG.download_completion
+		data["download_netspeed"] = PRG.actual_netspeed
+		data["download_name"] = "[PRG.downloaded_file.filename].[PRG.downloaded_file.filetype]"
+	else if (PRG.provided_file)
+		data["uploading"] = 1
+		data["upload_uid"] = PRG.unique_token
+		data["upload_clients"] = PRG.connected_clients.len
+		data["upload_haspassword"] = PRG.server_password ? 1 : 0
+		data["upload_filename"] = "[PRG.provided_file.filename].[PRG.provided_file.filetype]"
+	else if (PRG.upload_menu)
+		var/list/all_files[0]
+		for(var/datum/computer_file/F in PRG.computer.hard_drive.stored_files)
+			all_files.Add(list(list(
+			"uid" = F.uid,
+			"filename" = "[F.filename].[F.filetype]",
+			"size" = F.size
+			)))
+		data["upload_filelist"] = all_files
+	else
+		var/list/all_servers[0]
+		for(var/datum/computer_file/program/nttransfer/P in ntnet_global.fileservers)
+			if(!P.provided_file)
+				continue
+			all_servers.Add(list(list(
+			"uid" = P.unique_token,
+			"filename" = "[P.provided_file.filename].[P.provided_file.filetype]",
+			"size" = P.provided_file.size,
+			"haspassword" = P.server_password ? 1 : 0
+			)))
+		data["servers"] = all_servers
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "ntnet_transfer.tmpl", "NTNet P2P Transfer Client", 575, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+/datum/computer_file/program/nttransfer/Topic(href, href_list)
+	if(..())
+		return 1
+	if(href_list["PRG_downloadfile"])
+		for(var/datum/computer_file/program/nttransfer/P in ntnet_global.fileservers)
+			if("[P.unique_token]" == href_list["PRG_downloadfile"])
+				remote = P
+				break
+		if(!remote || !remote.provided_file)
+			return
+		if(remote.server_password)
+			var/pass = sanitize(input(usr, "Code 401 Unauthorized. Please enter password:", "Password required"))
+			if(pass != remote.server_password)
+				error = "Incorrect Password"
+				return
+		downloaded_file = remote.provided_file.clone()
+		remote.connected_clients.Add(src)
+		return 1
+	if(href_list["PRG_reset"])
+		error = ""
+		upload_menu = 0
+		finalize_download()
+		if(src in ntnet_global.fileservers)
+			ntnet_global.fileservers.Remove(src)
+		for(var/datum/computer_file/program/nttransfer/T in connected_clients)
+			T.crash_download("Remote server has forcibly closed the connection")
+		provided_file = null
+		return 1
+	if(href_list["PRG_setpassword"])
+		var/pass = sanitize(input(usr, "Enter new server password. Leave blank to cancel, input 'none' to disable password.", "Server security", "none"))
+		if(!pass)
+			return
+		if(pass == "none")
+			server_password = ""
+			return
+		server_password = pass
+		return 1
+	if(href_list["PRG_uploadfile"])
+		for(var/datum/computer_file/F in computer.hard_drive.stored_files)
+			if("[F.uid]" == href_list["PRG_uploadfile"])
+				if(F.unsendable)
+					error = "I/O Error: File locked."
+					return
+				provided_file = F
+				ntnet_global.fileservers.Add(src)
+				return
+		error = "I/O Error: Unable to locate file on hard drive."
+		return 1
+	if(href_list["PRG_uploadmenu"])
+		upload_menu = 1
+	return 0

code/modules/modular_computers/file_system/programs/generic/wordprocessor.dm

@@ -0,0 +1,235 @@
+/datum/computer_file/program/wordprocessor
+	filename = "wordprocessor"
+	filedesc = "NanoWord"
+	extended_desc = "This program allows the editing and preview of text documents."
+	program_icon_state = "word"
+	program_key_state = "atmos_key"
+	size = 4
+	requires_ntnet = 0
+	available_on_ntnet = 1
+	nanomodule_path = /datum/nano_module/program/computer_wordprocessor/
+	var/browsing
+	var/open_file
+	var/loaded_data
+	var/error
+	var/is_edited
+
+/datum/computer_file/program/wordprocessor/proc/get_file(var/filename)
+	var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+	if(!HDD)
+		return
+	var/datum/computer_file/data/F = HDD.find_file_by_name(filename)
+	if(!istype(F))
+		return
+	return F
+
+/datum/computer_file/program/wordprocessor/proc/open_file(var/filename)
+	var/datum/computer_file/data/F = get_file(filename)
+	if(F)
+		open_file = F.filename
+		loaded_data = F.stored_data
+		return 1
+
+/datum/computer_file/program/wordprocessor/proc/save_file(var/filename)
+	var/datum/computer_file/data/F = get_file(filename)
+	if(!F) //try to make one if it doesn't exist
+		F = create_file(filename, loaded_data)
+		return !isnull(F)
+	var/datum/computer_file/data/backup = F.clone()
+	var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+	if(!HDD)
+		return
+	HDD.remove_file(F)
+	F.stored_data = loaded_data
+	F.calculate_size()
+	if(!HDD.store_file(F))
+		HDD.store_file(backup)
+		return 0
+	is_edited = 0
+	return 1
+
+/datum/computer_file/program/wordprocessor/proc/create_file(var/newname, var/data = "")
+	if(!newname)
+		return
+	var/obj/item/weapon/computer_hardware/hard_drive/HDD = computer.hard_drive
+	if(!HDD)
+		return
+	if(get_file(newname))
+		return
+	var/datum/computer_file/data/F = new/datum/computer_file/data()
+	F.filename = newname
+	F.filetype = "TXT"
+	F.stored_data = data
+	F.calculate_size()
+	if(HDD.store_file(F))
+		return F
+
+/datum/computer_file/program/wordprocessor/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["PRG_txtrpeview"])
+		show_browser(usr,"<HTML><HEAD><TITLE>[open_file]</TITLE></HEAD>[pencode2html(loaded_data)]</BODY></HTML>", "window=[open_file]")
+		return 1
+
+	if(href_list["PRG_taghelp"])
+		to_chat(usr, "<span class='notice'>The hologram of a googly-eyed paper clip helpfully tells you:</span>")
+		var/help = {"
+		\[br\] : Creates a linebreak.
+		\[center\] - \[/center\] : Centers the text.
+		\[h1\] - \[/h1\] : First level heading.
+		\[h2\] - \[/h2\] : Second level heading.
+		\[h3\] - \[/h3\] : Third level heading.
+		\[b\] - \[/b\] : Bold.
+		\[i\] - \[/i\] : Italic.
+		\[u\] - \[/u\] : Underlined.
+		\[small\] - \[/small\] : Decreases the size of the text.
+		\[large\] - \[/large\] : Increases the size of the text.
+		\[field\] : Inserts a blank text field, which can be filled later. Useful for forms.
+		\[date\] : Current station date.
+		\[time\] : Current station time.
+		\[list\] - \[/list\] : Begins and ends a list.
+		\[*\] : A list item.
+		\[hr\] : Horizontal rule.
+		\[table\] - \[/table\] : Creates table using \[row\] and \[cell\] tags.
+		\[grid\] - \[/grid\] : Table without visible borders, for layouts.
+		\[row\] - New table row.
+		\[cell\] - New table cell.
+		\[logo\] - Inserts NT logo image.
+		\[redlogo\] - Inserts red NT logo image.
+		\[sglogo\] - Inserts Solgov insignia image."}
+
+		to_chat(usr, help)
+		return 1
+
+	if(href_list["PRG_closebrowser"])
+		browsing = 0
+		return 1
+
+	if(href_list["PRG_backtomenu"])
+		error = null
+		return 1
+
+	if(href_list["PRG_loadmenu"])
+		browsing = 1
+		return 1
+
+	if(href_list["PRG_openfile"])
+		. = 1
+		if(is_edited)
+			if(alert("Would you like to save your changes first?",,"Yes","No") == "Yes")
+				save_file(open_file)
+		browsing = 0
+		if(!open_file(href_list["PRG_openfile"]))
+			error = "I/O error: Unable to open file '[href_list["PRG_openfile"]]'."
+
+	if(href_list["PRG_newfile"])
+		. = 1
+		if(is_edited)
+			if(alert("Would you like to save your changes first?",,"Yes","No") == "Yes")
+				save_file(open_file)
+
+		var/newname = sanitize(input(usr, "Enter file name:", "New File") as text|null)
+		if(!newname)
+			return 1
+		var/datum/computer_file/data/F = create_file(newname)
+		if(F)
+			open_file = F.filename
+			loaded_data = ""
+			return 1
+		else
+			error = "I/O error: Unable to create file '[href_list["PRG_saveasfile"]]'."
+
+	if(href_list["PRG_saveasfile"])
+		. = 1
+		var/newname = sanitize(input(usr, "Enter file name:", "Save As") as text|null)
+		if(!newname)
+			return 1
+		var/datum/computer_file/data/F = create_file(newname, loaded_data)
+		if(F)
+			open_file = F.filename
+		else
+			error = "I/O error: Unable to create file '[href_list["PRG_saveasfile"]]'."
+		return 1
+
+	if(href_list["PRG_savefile"])
+		. = 1
+		if(!open_file)
+			open_file = sanitize(input(usr, "Enter file name:", "Save As") as text|null)
+			if(!open_file)
+				return 0
+		if(!save_file(open_file))
+			error = "I/O error: Unable to save file '[open_file]'."
+		return 1
+
+	if(href_list["PRG_editfile"])
+		var/oldtext = html_decode(loaded_data)
+		oldtext = replacetext(oldtext, "\[br\]", "\n")
+
+		var/newtext = sanitize(replacetext(input(usr, "Editing file '[open_file]'. You may use most tags used in paper formatting:", "Text Editor", oldtext) as message|null, "\n", "\[br\]"), MAX_TEXTFILE_LENGTH)
+		if(!newtext)
+			return
+		loaded_data = newtext
+		is_edited = 1
+		return 1
+
+	if(href_list["PRG_printfile"])
+		. = 1
+		if(!computer.nano_printer)
+			error = "Missing Hardware: Your computer does not have the required hardware to complete this operation."
+			return 1
+		if(!computer.nano_printer.print_text(pencode2html(loaded_data)))
+			error = "Hardware error: Printer was unable to print the file. It may be out of paper."
+			return 1
+
+/datum/nano_module/program/computer_wordprocessor
+	name = "Word Processor"
+
+/datum/nano_module/program/computer_wordprocessor/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+	var/datum/computer_file/program/wordprocessor/PRG
+	PRG = program
+
+	var/obj/item/weapon/computer_hardware/hard_drive/HDD
+	var/obj/item/weapon/computer_hardware/hard_drive/portable/RHDD
+	if(PRG.error)
+		data["error"] = PRG.error
+	if(PRG.browsing)
+		data["browsing"] = PRG.browsing
+		if(!PRG.computer || !PRG.computer.hard_drive)
+			data["error"] = "I/O ERROR: Unable to access hard drive."
+		else
+			HDD = PRG.computer.hard_drive
+			var/list/files[0]
+			for(var/datum/computer_file/F in HDD.stored_files)
+				if(F.filetype == "TXT")
+					files.Add(list(list(
+						"name" = F.filename,
+						"size" = F.size
+					)))
+			data["files"] = files
+
+			RHDD = PRG.computer.portable_drive
+			if(RHDD)
+				data["usbconnected"] = 1
+				var/list/usbfiles[0]
+				for(var/datum/computer_file/F in RHDD.stored_files)
+					if(F.filetype == "TXT")
+						usbfiles.Add(list(list(
+							"name" = F.filename,
+							"size" = F.size,
+						)))
+				data["usbfiles"] = usbfiles
+	else if(PRG.open_file)
+		data["filedata"] = pencode2html(PRG.loaded_data)
+		data["filename"] = PRG.is_edited ? "[PRG.open_file]*" : PRG.open_file
+	else
+		data["filedata"] = pencode2html(PRG.loaded_data)
+		data["filename"] = "UNNAMED"
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "word_processor.tmpl", "Word Processor", 575, 700, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()

code/modules/modular_computers/file_system/programs/medical/suit_sensors.dm

@@ -0,0 +1,69 @@
+/datum/computer_file/program/suit_sensors
+	filename = "sensormonitor"
+	filedesc = "Suit Sensors Monitoring"
+	nanomodule_path = /datum/nano_module/crew_monitor
+	program_icon_state = "crew"
+	program_key_state = "med_key"
+	program_menu_icon = "heart"
+	extended_desc = "This program connects to life signs monitoring system to provide basic information on crew health."
+	required_access = access_medical
+	requires_ntnet = 1
+	network_destination = "crew lifesigns monitoring system"
+	size = 11
+
+
+
+
+
+/datum/nano_module/crew_monitor
+	name = "Crew monitor"
+
+/datum/nano_module/crew_monitor/Topic(href, href_list)
+	if(..()) return 1
+	var/turf/T = get_turf(nano_host())	// TODO: Allow setting any using_map.contact_levels from the interface.
+	if (!T || !(T.z in using_map.player_levels))
+		usr << "<span class='warning'>Unable to establish a connection</span>: You're too far away from the station!"
+		return 0
+	if(href_list["track"])
+		if(isAI(usr))
+			var/mob/living/silicon/ai/AI = usr
+			var/mob/living/carbon/human/H = locate(href_list["track"]) in mob_list
+			if(hassensorlevel(H, SUIT_SENSOR_TRACKING))
+				AI.ai_actual_track(H)
+		return 1
+
+/datum/nano_module/crew_monitor/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+	var/turf/T = get_turf(nano_host())
+
+	data["isAI"] = isAI(user)
+	data["map_levels"] = using_map.get_map_levels(T.z, FALSE)
+	data["crewmembers"] = list()
+	for(var/z in (data["map_levels"] | T.z))  // Always show crew from the current Z even if we can't show a map
+		data["crewmembers"] += crew_repository.health_data(z)
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if(!ui)
+		ui = new(user, src, ui_key, "crew_monitor.tmpl", "Crew Monitoring Computer", 900, 800, state = state)
+
+		// adding a template with the key "mapContent" enables the map ui functionality
+		ui.add_template("mapContent", "crew_monitor_map_content.tmpl")
+		// adding a template with the key "mapHeader" replaces the map header content
+		ui.add_template("mapHeader", "crew_monitor_map_header.tmpl")
+		if(!(ui.map_z_level in data["map_levels"]))
+			ui.set_map_z_level(data["map_levels"][1])
+
+		ui.set_initial_data(data)
+		ui.open()
+
+		// should make the UI auto-update; doesn't seem to?
+		ui.set_auto_update(1)
+
+/*/datum/nano_module/crew_monitor/proc/scan()
+	for(var/mob/living/carbon/human/H in mob_list)
+		if(istype(H.w_uniform, /obj/item/clothing/under))
+			var/obj/item/clothing/under/C = H.w_uniform
+			if (C.has_sensor)
+				tracked |= C
+	return 1
+*/

code/modules/modular_computers/file_system/programs/research/email_administration.dm

@@ -0,0 +1,144 @@
+/datum/computer_file/program/email_administration
+	filename = "emailadmin"
+	filedesc = "Email Administration Utility"
+	extended_desc = "This program may be used to administrate NTNet's emailing service."
+	program_icon_state = "comm_monitor"
+	program_key_state = "generic_key"
+	program_menu_icon = "mail-open"
+	size = 12
+	requires_ntnet = 1
+	available_on_ntnet = 1
+	nanomodule_path = /datum/nano_module/email_administration
+	required_access = access_network
+
+
+
+
+/datum/nano_module/email_administration/
+	name = "Email Client"
+	var/datum/computer_file/data/email_account/current_account = null
+	var/datum/computer_file/data/email_message/current_message = null
+	var/error = ""
+
+/datum/nano_module/email_administration/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	if(error)
+		data["error"] = error
+	else if(istype(current_message))
+		data["msg_title"] = current_message.title
+		data["msg_body"] = pencode2html(current_message.stored_data)
+		data["msg_timestamp"] = current_message.timestamp
+		data["msg_source"] = current_message.source
+	else if(istype(current_account))
+		data["current_account"] = current_account.login
+		data["cur_suspended"] = current_account.suspended
+		var/list/all_messages = list()
+		for(var/datum/computer_file/data/email_message/message in (current_account.inbox | current_account.spam | current_account.deleted))
+			all_messages.Add(list(list(
+				"title" = message.title,
+				"source" = message.source,
+				"timestamp" = message.timestamp,
+				"uid" = message.uid
+			)))
+		data["messages"] = all_messages
+		data["messagecount"] = all_messages.len
+	else
+		var/list/all_accounts = list()
+		for(var/datum/computer_file/data/email_account/account in ntnet_global.email_accounts)
+			if(!account.can_login)
+				continue
+			all_accounts.Add(list(list(
+				"login" = account.login,
+				"uid" = account.uid
+			)))
+		data["accounts"] = all_accounts
+		data["accountcount"] = all_accounts.len
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "email_administration.tmpl", "Email Administration Utility", 600, 450, state = state)
+		if(host.update_layout())
+			ui.auto_update_layout = 1
+		ui.set_auto_update(1)
+		ui.set_initial_data(data)
+		ui.open()
+
+
+/datum/nano_module/email_administration/Topic(href, href_list)
+	if(..())
+		return 1
+
+	var/mob/user = usr
+	if(!istype(user))
+		return 1
+
+	// High security - can only be operated when the user has an ID with access on them.
+	var/obj/item/weapon/card/id/I = user.GetIdCard()
+	if(!istype(I) || !(access_network in I.access))
+		return 1
+
+	if(href_list["back"])
+		if(error)
+			error = ""
+		else if(current_message)
+			current_message = null
+		else
+			current_account = null
+		return 1
+
+	if(href_list["ban"])
+		if(!current_account)
+			return 1
+
+		current_account.suspended = !current_account.suspended
+		ntnet_global.add_log_with_ids_check("EMAIL LOG: SA-EDIT Account [current_account.login] has been [current_account.suspended ? "" : "un" ]suspended by SA [I.registered_name] ([I.assignment]).")
+		error = "Account [current_account.login] has been [current_account.suspended ? "" : "un" ]suspended."
+		return 1
+
+	if(href_list["changepass"])
+		if(!current_account)
+			return 1
+
+		var/newpass = sanitize(input(user,"Enter new password for account [current_account.login]", "Password"), 100)
+		if(!newpass)
+			return 1
+		current_account.password = newpass
+		ntnet_global.add_log_with_ids_check("EMAIL LOG: SA-EDIT Password for account [current_account.login] has been changed by SA [I.registered_name] ([I.assignment]).")
+		return 1
+
+	if(href_list["viewmail"])
+		if(!current_account)
+			return 1
+
+		for(var/datum/computer_file/data/email_message/received_message in (current_account.inbox | current_account.spam | current_account.deleted))
+			if(received_message.uid == text2num(href_list["viewmail"]))
+				current_message = received_message
+				break
+		return 1
+
+	if(href_list["viewaccount"])
+		for(var/datum/computer_file/data/email_account/email_account in ntnet_global.email_accounts)
+			if(email_account.uid == text2num(href_list["viewaccount"]))
+				current_account = email_account
+				break
+		return 1
+
+	if(href_list["newaccount"])
+		var/newdomain = sanitize(input(user,"Pick domain:", "Domain name") as null|anything in using_map.usable_email_tlds)
+		if(!newdomain)
+			return 1
+		var/newlogin = sanitize(input(user,"Pick account name (@[newdomain]):", "Account name"), 100)
+		if(!newlogin)
+			return 1
+
+		var/complete_login = "[newlogin]@[newdomain]"
+		if(ntnet_global.does_email_exist(complete_login))
+			error = "Error creating account: An account with same address already exists."
+			return 1
+
+		var/datum/computer_file/data/email_account/new_account = new/datum/computer_file/data/email_account()
+		new_account.login = complete_login
+		new_account.password = GenerateKey()
+		error = "Email [new_account.login] has been created, with generated password [new_account.password]"
+		return 1

code/modules/modular_computers/file_system/programs/research/ntmonitor.dm

@@ -0,0 +1,102 @@
+/datum/computer_file/program/ntnetmonitor
+	filename = "ntmonitor"
+	filedesc = "NTNet Diagnostics and Monitoring"
+	program_icon_state = "comm_monitor"
+	program_key_state = "generic_key"
+	program_menu_icon = "wrench"
+	extended_desc = "This program monitors the local NTNet network, provides access to logging systems, and allows for configuration changes"
+	size = 12
+	requires_ntnet = 1
+	required_access = access_network
+	available_on_ntnet = 1
+	nanomodule_path = /datum/nano_module/computer_ntnetmonitor/
+
+/datum/nano_module/computer_ntnetmonitor
+	name = "NTNet Diagnostics and Monitoring"
+	//available_to_ai = TRUE
+
+/datum/nano_module/computer_ntnetmonitor/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	if(!ntnet_global)
+		return
+	var/list/data = host.initial_data()
+
+	data["ntnetstatus"] = ntnet_global.check_function()
+	data["ntnetrelays"] = ntnet_global.relays.len
+	data["idsstatus"] = ntnet_global.intrusion_detection_enabled
+	data["idsalarm"] = ntnet_global.intrusion_detection_alarm
+
+	data["config_softwaredownload"] = ntnet_global.setting_softwaredownload
+	data["config_peertopeer"] = ntnet_global.setting_peertopeer
+	data["config_communication"] = ntnet_global.setting_communication
+	data["config_systemcontrol"] = ntnet_global.setting_systemcontrol
+
+	data["ntnetlogs"] = ntnet_global.logs
+	data["ntnetmaxlogs"] = ntnet_global.setting_maxlogcount
+
+	data["banned_nids"] = list(ntnet_global.banned_nids)
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "ntnet_monitor.tmpl", "NTNet Diagnostics and Monitoring Tool", 575, 700, state = state)
+		if(host.update_layout())
+			ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+/datum/nano_module/computer_ntnetmonitor/Topic(href, href_list, state)
+	var/mob/user = usr
+	if(..())
+		return 1
+	if(href_list["resetIDS"])
+		if(ntnet_global)
+			ntnet_global.resetIDS()
+		return 1
+	if(href_list["toggleIDS"])
+		if(ntnet_global)
+			ntnet_global.toggleIDS()
+		return 1
+	if(href_list["toggleWireless"])
+		if(!ntnet_global)
+			return 1
+
+		// NTNet is disabled. Enabling can be done without user prompt
+		if(ntnet_global.setting_disabled)
+			ntnet_global.setting_disabled = 0
+			return 1
+
+		// NTNet is enabled and user is about to shut it down. Let's ask them if they really want to do it, as wirelessly connected computers won't connect without NTNet being enabled (which may prevent people from turning it back on)
+		if(!user)
+			return 1
+		var/response = alert(user, "Really disable NTNet wireless? If your computer is connected wirelessly you won't be able to turn it back on! This will affect all connected wireless devices.", "NTNet shutdown", "Yes", "No")
+		if(response == "Yes")
+			ntnet_global.setting_disabled = 1
+		return 1
+	if(href_list["purgelogs"])
+		if(ntnet_global)
+			ntnet_global.purge_logs()
+		return 1
+	if(href_list["updatemaxlogs"])
+		var/logcount = text2num(input(user,"Enter amount of logs to keep in memory ([MIN_NTNET_LOGS]-[MAX_NTNET_LOGS]):"))
+		if(ntnet_global)
+			ntnet_global.update_max_log_count(logcount)
+		return 1
+	if(href_list["toggle_function"])
+		if(!ntnet_global)
+			return 1
+		ntnet_global.toggle_function(href_list["toggle_function"])
+		return 1
+	if(href_list["ban_nid"])
+		if(!ntnet_global)
+			return 1
+		var/nid = input(user,"Enter NID of device which you want to block from the network:", "Enter NID") as null|num
+		if(nid && CanUseTopic(user, state))
+			ntnet_global.banned_nids |= nid
+		return 1
+	if(href_list["unban_nid"])
+		if(!ntnet_global)
+			return 1
+		var/nid = input(user,"Enter NID of device which you want to unblock from the network:", "Enter NID") as null|num
+		if(nid && CanUseTopic(user, state))
+			ntnet_global.banned_nids -= nid
+		return 1 

code/modules/modular_computers/file_system/programs/security/digitalwarrant.dm

@@ -0,0 +1,143 @@
+var/warrant_uid = 0
+/datum/datacore/var/list/warrants[] = list()
+/datum/data/record/warrant
+	var/warrant_id
+
+/datum/data/record/warrant/New()
+	..()
+	warrant_id = warrant_uid++
+
+
+/datum/computer_file/program/digitalwarrant
+	filename = "digitalwarrant"
+	filedesc = "Warrant Assistant"
+	extended_desc = "Official NTsec program for creation and handling of warrants."
+	size = 8
+	program_icon_state = "warrant"
+	program_key_state = "security_key"
+	program_menu_icon = "star"
+	requires_ntnet = 1
+	available_on_ntnet = 1
+	required_access = access_security
+	usage_flags = PROGRAM_ALL
+	nanomodule_path = /datum/nano_module/program/digitalwarrant/
+
+/datum/nano_module/program/digitalwarrant/
+	name = "Warrant Assistant"
+	var/datum/data/record/warrant/activewarrant
+
+/datum/nano_module/program/digitalwarrant/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1, var/datum/topic_state/state = default_state)
+	var/list/data = host.initial_data()
+
+	if(activewarrant)
+		data["warrantname"] = activewarrant.fields["namewarrant"]
+		data["warrantcharges"] = activewarrant.fields["charges"]
+		data["warrantauth"] = activewarrant.fields["auth"]
+		data["type"] = activewarrant.fields["arrestsearch"]
+	else
+		var/list/allwarrants = list()
+		for(var/datum/data/record/warrant/W in data_core.warrants)
+			allwarrants.Add(list(list(
+			"warrantname" = W.fields["namewarrant"],
+			"charges" = "[copytext(W.fields["charges"],1,min(length(W.fields["charges"]) + 1, 50))]...",
+			"auth" = W.fields["auth"],
+			"id" = W.warrant_id,
+			"arrestsearch" = W.fields["arrestsearch"]
+		)))
+		data["allwarrants"] = allwarrants
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "digitalwarrant.tmpl", name, 500, 350, state = state)
+		ui.auto_update_layout = 1
+		ui.set_initial_data(data)
+		ui.open()
+
+/datum/nano_module/program/digitalwarrant/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["sw_menu"])
+		activewarrant = null
+
+	if(href_list["editwarrant"])
+		. = 1
+		for(var/datum/data/record/warrant/W in data_core.warrants)
+			if(W.warrant_id == text2num(href_list["editwarrant"]))
+				activewarrant = W
+				break
+
+	// The following actions will only be possible if the user has an ID with security access equipped. This is in line with modular computer framework's authentication methods,
+	// which also use RFID scanning to allow or disallow access to some functions. Anyone can view warrants, editing requires ID. This also prevents situations where you show a tablet
+	// to someone who is to be arrested, which allows them to change the stuff there.
+
+	var/mob/user = usr
+	if(!istype(user))
+		return
+	var/obj/item/weapon/card/id/I = user.GetIdCard()
+	if(!istype(I) || !I.registered_name || !(access_security in I.access))
+		to_chat(user, "Authentication error: Unable to locate ID with apropriate access to allow this operation.")
+		return
+
+	if(href_list["addwarrant"])
+		. = 1
+		var/datum/data/record/warrant/W = new()
+		var/temp = sanitize(input(usr, "Do you want to create a search-, or an arrest warrant?") as null|anything in list("search","arrest"))
+		if(CanInteract(user, default_state))
+			if(temp == "arrest")
+				W.fields["namewarrant"] = "Unknown"
+				W.fields["charges"] = "No charges present"
+				W.fields["auth"] = "Unauthorized"
+				W.fields["arrestsearch"] = "arrest"
+			if(temp == "search")
+				W.fields["namewarrant"] = "No location given"
+				W.fields["charges"] = "No reason given"
+				W.fields["auth"] = "Unauthorized"
+				W.fields["arrestsearch"] = "search"
+			activewarrant = W
+
+	if(href_list["savewarrant"])
+		. = 1
+		data_core.warrants |= activewarrant
+		activewarrant = null
+
+	if(href_list["deletewarrant"])
+		. = 1
+		data_core.warrants -= activewarrant
+		activewarrant = null
+
+	if(href_list["editwarrantname"])
+		. = 1
+		var/namelist = list()
+		for(var/datum/data/record/t in data_core.general)
+			namelist += t.fields["name"]
+		var/new_name = sanitize(input(usr, "Please input name") as null|anything in namelist)
+		if(CanInteract(user, default_state))
+			if (!new_name)
+				return
+			activewarrant.fields["namewarrant"] = new_name
+
+	if(href_list["editwarrantnamecustom"])
+		. = 1
+		var/new_name = sanitize(input("Please input name") as null|text)
+		if(CanInteract(user, default_state))
+			if (!new_name)
+				return
+			activewarrant.fields["namewarrant"] = new_name
+
+	if(href_list["editwarrantcharges"])
+		. = 1
+		var/new_charges = sanitize(input("Please input charges", "Charges", activewarrant.fields["charges"]) as null|text)
+		if(CanInteract(user, default_state))
+			if (!new_charges)
+				return
+			activewarrant.fields["charges"] = new_charges
+
+	if(href_list["editwarrantauth"])
+		. = 1
+
+		activewarrant.fields["auth"] = "[I.registered_name] - [I.assignment ? I.assignment : "(Unknown)"]"
+
+	if(href_list["back"])
+		. = 1
+		activewarrant = null

code/modules/modular_computers/hardware/_hardware.dm

@@ -0,0 +1,87 @@
+/obj/item/weapon/computer_hardware/
+	name = "Hardware"
+	desc = "Unknown Hardware."
+	icon = 'icons/obj/modular_components.dmi'
+	var/obj/item/modular_computer/holder2 = null
+	var/power_usage = 0 			// If the hardware uses extra power, change this.
+	var/enabled = 1					// If the hardware is turned off set this to 0.
+	var/critical = 1				// Prevent disabling for important component, like the HDD.
+	var/hardware_size = 1			// Limits which devices can contain this component. 1: Tablets/Laptops/Consoles, 2: Laptops/Consoles, 3: Consoles only
+	var/damage = 0					// Current damage level
+	var/max_damage = 100			// Maximal damage level.
+	var/damage_malfunction = 20		// "Malfunction" threshold. When damage exceeds this value the hardware piece will semi-randomly fail and do !!FUN!! things
+	var/damage_failure = 50			// "Failure" threshold. When damage exceeds this value the hardware piece will not work at all.
+	var/malfunction_probability = 10// Chance of malfunction when the component is damaged
+
+/obj/item/weapon/computer_hardware/attackby(var/obj/item/W as obj, var/mob/living/user as mob)
+	// Multitool. Runs diagnostics
+	if(istype(W, /obj/item/device/multitool))
+		to_chat(user, "***** DIAGNOSTICS REPORT *****")
+		diagnostics(user)
+		to_chat(user, "******************************")
+		return 1
+	// Nanopaste. Repair all damage if present for a single unit.
+	var/obj/item/stack/S = W
+	if(istype(S, /obj/item/stack/nanopaste))
+		if(!damage)
+			to_chat(user, "\The [src] doesn't seem to require repairs.")
+			return 1
+		if(S.use(1))
+			to_chat(user, "You apply a bit of \the [W] to \the [src]. It immediately repairs all damage.")
+			damage = 0
+		return 1
+	// Cable coil. Works as repair method, but will probably require multiple applications and more cable.
+	if(istype(S, /obj/item/stack/cable_coil))
+		if(!damage)
+			to_chat(user, "\The [src] doesn't seem to require repairs.")
+			return 1
+		if(S.use(1))
+			to_chat(user, "You patch up \the [src] with a bit of \the [W].")
+			take_damage(-10)
+		return 1
+	return ..()
+
+
+// Called on multitool click, prints diagnostic information to the user.
+/obj/item/weapon/computer_hardware/proc/diagnostics(var/mob/user)
+	to_chat(user, "Hardware Integrity Test... (Corruption: [damage]/[max_damage]) [damage > damage_failure ? "FAIL" : damage > damage_malfunction ? "WARN" : "PASS"]")
+
+/obj/item/weapon/computer_hardware/New(var/obj/L)
+	w_class = hardware_size
+	if(istype(L, /obj/item/modular_computer))
+		holder2 = L
+		return
+
+/obj/item/weapon/computer_hardware/Destroy()
+	holder2 = null
+	return ..()
+
+// Handles damage checks
+/obj/item/weapon/computer_hardware/proc/check_functionality()
+	// Turned off
+	if(!enabled)
+		return 0
+	// Too damaged to work at all.
+	if(damage > damage_failure)
+		return 0
+	// Still working. Well, sometimes...
+	if(damage > damage_malfunction)
+		if(prob(malfunction_probability))
+			return 0
+	// Good to go.
+	return 1
+
+/obj/item/weapon/computer_hardware/examine(var/mob/user)
+	. = ..()
+	if(damage > damage_failure)
+		to_chat(user, "<span class='danger'>It seems to be severely damaged!</span>")
+	else if(damage > damage_malfunction)
+		to_chat(user, "<span class='notice'>It seems to be damaged!</span>")
+	else if(damage)
+		to_chat(user, "It seems to be slightly damaged.")
+
+// Damages the component. Contains necessary checks. Negative damage "heals" the component.
+/obj/item/weapon/computer_hardware/proc/take_damage(var/amount)
+	damage += round(amount) 					// We want nice rounded numbers here.
+	damage = between(0, damage, max_damage)		// Clamp the value.
+

code/modules/modular_computers/hardware/battery_module.dm

@@ -0,0 +1,79 @@
+// This device is wrapper for actual power cell. I have decided to not use power cells directly as even low-end cells available on station
+// have tremendeous capacity in comparsion. Higher tier cells would provide your device with nearly infinite battery life, which is something i want to avoid.
+/obj/item/weapon/computer_hardware/battery_module
+	name = "standard battery"
+	desc = "A standard power cell, commonly seen in high-end portable microcomputers or low-end laptops. It's rating is 750."
+	icon_state = "battery_normal"
+	critical = 1
+	malfunction_probability = 1
+	origin_tech = list(TECH_POWER = 1, TECH_ENGINEERING = 1)
+	var/battery_rating = 750
+	var/obj/item/weapon/cell/battery = null
+
+/obj/item/weapon/computer_hardware/battery_module/advanced
+	name = "advanced battery"
+	desc = "An advanced power cell, often used in most laptops. It is too large to be fitted into smaller devices. It's rating is 1100."
+	icon_state = "battery_advanced"
+	origin_tech = list(TECH_POWER = 2, TECH_ENGINEERING = 2)
+	hardware_size = 2
+	battery_rating = 1100
+
+/obj/item/weapon/computer_hardware/battery_module/super
+	name = "super battery"
+	desc = "A very advanced power cell, often used in high-end devices, or as uninterruptable power supply for important consoles or servers. It's rating is 1500."
+	icon_state = "battery_super"
+	origin_tech = list(TECH_POWER = 3, TECH_ENGINEERING = 3)
+	hardware_size = 2
+	battery_rating = 1500
+
+/obj/item/weapon/computer_hardware/battery_module/ultra
+	name = "ultra battery"
+	desc = "A very advanced large power cell. It's often used as uninterruptable power supply for critical consoles or servers. It's rating is 2000."
+	icon_state = "battery_ultra"
+	origin_tech = list(TECH_POWER = 5, TECH_ENGINEERING = 4)
+	hardware_size = 3
+	battery_rating = 2000
+
+/obj/item/weapon/computer_hardware/battery_module/micro
+	name = "micro battery"
+	desc = "A small power cell, commonly seen in most portable microcomputers. It's rating is 500."
+	icon_state = "battery_micro"
+	origin_tech = list(TECH_POWER = 2, TECH_ENGINEERING = 2)
+	battery_rating = 500
+
+/obj/item/weapon/computer_hardware/battery_module/nano
+	name = "nano battery"
+	desc = "A tiny power cell, commonly seen in low-end portable microcomputers. It's rating is 300."
+	icon_state = "battery_nano"
+	origin_tech = list(TECH_POWER = 1, TECH_ENGINEERING = 1)
+	battery_rating = 300
+
+// This is not intended to be obtainable in-game. Intended for adminbus and debugging purposes.
+/obj/item/weapon/computer_hardware/battery_module/lambda
+	name = "lambda coil"
+	desc = "A very complex power source compatible with various computers. It is capable of providing power for nearly unlimited duration."
+	icon_state = "battery_lambda"
+	hardware_size = 1
+	battery_rating = 30000
+
+/obj/item/weapon/computer_hardware/battery_module/lambda/New()
+	..()
+	battery = new/obj/item/weapon/cell/infinite(src)
+
+/obj/item/weapon/computer_hardware/battery_module/diagnostics(var/mob/user)
+	..()
+	to_chat(user, "Internal battery charge: [battery.charge]/[battery.maxcharge] CU")
+
+/obj/item/weapon/computer_hardware/battery_module/New()
+	battery = new/obj/item/weapon/cell(src)
+	battery.maxcharge = battery_rating
+	battery.charge = 0
+	..()
+
+/obj/item/weapon/computer_hardware/battery_module/Destroy()
+	qdel_null(battery)
+	return ..()
+
+/obj/item/weapon/computer_hardware/battery_module/proc/charge_to_full()
+	if(battery)
+		battery.charge = battery.maxcharge

code/modules/modular_computers/hardware/card_slot.dm

@@ -0,0 +1,18 @@
+/obj/item/weapon/computer_hardware/card_slot
+	name = "RFID card slot"
+	desc = "Slot that allows this computer to write data on RFID cards. Necessary for some programs to run properly."
+	power_usage = 10 //W
+	critical = 0
+	icon_state = "cardreader"
+	hardware_size = 1
+	origin_tech = list(TECH_DATA = 2)
+
+	var/obj/item/weapon/card/id/stored_card = null
+
+/obj/item/weapon/computer_hardware/card_slot/Destroy()
+	if(holder2 && (holder2.card_slot == src))
+		holder2.card_slot = null
+	if(stored_card)
+		stored_card.forceMove(get_turf(holder2))
+	holder2 = null
+	return ..()

code/modules/modular_computers/hardware/hard_drive.dm

@@ -0,0 +1,167 @@
+/obj/item/weapon/computer_hardware/hard_drive/
+	name = "basic hard drive"
+	desc = "A small power efficient solid state drive, with 128GQ of storage capacity for use in basic computers where power efficiency is desired."
+	power_usage = 25					// SSD or something with low power usage
+	icon_state = "hdd_normal"
+	hardware_size = 1
+	origin_tech = list(TECH_DATA = 1, TECH_ENGINEERING = 1)
+	var/max_capacity = 128
+	var/used_capacity = 0
+	var/list/stored_files = list()		// List of stored files on this drive. DO NOT MODIFY DIRECTLY!
+
+/obj/item/weapon/computer_hardware/hard_drive/advanced
+	name = "advanced hard drive"
+	desc = "A small hybrid hard drive with 256GQ of storage capacity for use in higher grade computers where balance between power efficiency and capacity is desired."
+	max_capacity = 256
+	origin_tech = list(TECH_DATA = 2, TECH_ENGINEERING = 2)
+	power_usage = 50 					// Hybrid, medium capacity and medium power storage
+	icon_state = "hdd_advanced"
+	hardware_size = 2
+
+/obj/item/weapon/computer_hardware/hard_drive/super
+	name = "super hard drive"
+	desc = "A small hard drive with 512GQ of storage capacity for use in cluster storage solutions where capacity is more important than power efficiency."
+	max_capacity = 512
+	origin_tech = list(TECH_DATA = 3, TECH_ENGINEERING = 3)
+	power_usage = 100					// High-capacity but uses lots of power, shortening battery life. Best used with APC link.
+	icon_state = "hdd_super"
+	hardware_size = 2
+
+/obj/item/weapon/computer_hardware/hard_drive/cluster
+	name = "cluster hard drive"
+	desc = "A large storage cluster consisting of multiple hard drives for usage in high capacity storage systems. Has capacity of 2048 GQ."
+	power_usage = 500
+	origin_tech = list(TECH_DATA = 4, TECH_ENGINEERING = 4)
+	max_capacity = 2048
+	icon_state = "hdd_cluster"
+	hardware_size = 3
+
+// For tablets, etc. - highly power efficient.
+/obj/item/weapon/computer_hardware/hard_drive/small
+	name = "small hard drive"
+	desc = "A small highly efficient solid state drive for portable devices."
+	power_usage = 10
+	origin_tech = list(TECH_DATA = 2, TECH_ENGINEERING = 2)
+	max_capacity = 64
+	icon_state = "hdd_small"
+	hardware_size = 1
+
+/obj/item/weapon/computer_hardware/hard_drive/micro
+	name = "micro hard drive"
+	desc = "A small micro hard drive for portable devices."
+	power_usage = 2
+	origin_tech = list(TECH_DATA = 1, TECH_ENGINEERING = 1)
+	max_capacity = 32
+	icon_state = "hdd_micro"
+	hardware_size = 1
+
+/obj/item/weapon/computer_hardware/hard_drive/diagnostics(var/mob/user)
+	..()
+	// 999 is a byond limit that is in place. It's unlikely someone will reach that many files anyway, since you would sooner run out of space.
+	to_chat(user, "NT-NFS File Table Status: [stored_files.len]/999")
+	to_chat(user, "Storage capacity: [used_capacity]/[max_capacity]GQ")
+
+// Use this proc to add file to the drive. Returns 1 on success and 0 on failure. Contains necessary sanity checks.
+/obj/item/weapon/computer_hardware/hard_drive/proc/store_file(var/datum/computer_file/F)
+	if(!F || !istype(F))
+		return 0
+
+	if(!can_store_file(F.size))
+		return 0
+
+	if(!check_functionality())
+		return 0
+
+	if(!stored_files)
+		return 0
+
+	// This file is already stored. Don't store it again.
+	if(F in stored_files)
+		return 0
+
+	F.holder = src
+	stored_files.Add(F)
+	recalculate_size()
+	return 1
+
+// Use this proc to add file to the drive. Returns 1 on success and 0 on failure. Contains necessary sanity checks.
+/obj/item/weapon/computer_hardware/hard_drive/proc/install_default_programs()
+	store_file(new/datum/computer_file/program/computerconfig(src)) 		// Computer configuration utility, allows hardware control and displays more info than status bar
+	store_file(new/datum/computer_file/program/ntnetdownload(src))			// NTNet Downloader Utility, allows users to download more software from NTNet repository
+	store_file(new/datum/computer_file/program/filemanager(src))			// File manager, allows text editor functions and basic file manipulation.
+
+
+// Use this proc to remove file from the drive. Returns 1 on success and 0 on failure. Contains necessary sanity checks.
+/obj/item/weapon/computer_hardware/hard_drive/proc/remove_file(var/datum/computer_file/F)
+	if(!F || !istype(F))
+		return 0
+
+	if(!stored_files)
+		return 0
+
+	if(!check_functionality())
+		return 0
+
+	if(F in stored_files)
+		stored_files -= F
+		recalculate_size()
+		return 1
+	else
+		return 0
+
+// Loops through all stored files and recalculates used_capacity of this drive
+/obj/item/weapon/computer_hardware/hard_drive/proc/recalculate_size()
+	var/total_size = 0
+	for(var/datum/computer_file/F in stored_files)
+		total_size += F.size
+
+	used_capacity = total_size
+
+// Checks whether file can be stored on the hard drive.
+/obj/item/weapon/computer_hardware/hard_drive/proc/can_store_file(var/size = 1)
+	// In the unlikely event someone manages to create that many files.
+	// BYOND is acting weird with numbers above 999 in loops (infinite loop prevention)
+	if(stored_files.len >= 999)
+		return 0
+	if(used_capacity + size > max_capacity)
+		return 0
+	else
+		return 1
+
+// Checks whether we can store the file. We can only store unique files, so this checks whether we wouldn't get a duplicity by adding a file.
+/obj/item/weapon/computer_hardware/hard_drive/proc/try_store_file(var/datum/computer_file/F)
+	if(!F || !istype(F))
+		return 0
+	var/name = F.filename + "." + F.filetype
+	for(var/datum/computer_file/file in stored_files)
+		if((file.filename + "." + file.filetype) == name)
+			return 0
+	return can_store_file(F.size)
+
+
+
+// Tries to find the file by filename. Returns null on failure
+/obj/item/weapon/computer_hardware/hard_drive/proc/find_file_by_name(var/filename)
+	if(!check_functionality())
+		return null
+
+	if(!filename)
+		return null
+
+	if(!stored_files)
+		return null
+
+	for(var/datum/computer_file/F in stored_files)
+		if(F.filename == filename)
+			return F
+	return null
+
+/obj/item/weapon/computer_hardware/hard_drive/Destroy()
+	if(holder2 && (holder2.hard_drive == src))
+		holder2.hard_drive = null
+	stored_files = null
+	return ..()
+
+/obj/item/weapon/computer_hardware/hard_drive/New()
+	install_default_programs()
+	..()

code/modules/modular_computers/hardware/nano_printer.dm

@@ -0,0 +1,77 @@
+/obj/item/weapon/computer_hardware/nano_printer
+	name = "nano printer"
+	desc = "Small integrated printer with paper recycling module."
+	power_usage = 50
+	origin_tech = list(TECH_DATA = 2, TECH_ENGINEERING = 2)
+	critical = 0
+	icon_state = "printer"
+	hardware_size = 1
+	var/stored_paper = 5
+	var/max_paper = 10
+
+/obj/item/weapon/computer_hardware/nano_printer/diagnostics(var/mob/user)
+	..()
+	to_chat(user, "Paper buffer level: [stored_paper]/[max_paper]")
+
+/obj/item/weapon/computer_hardware/nano_printer/proc/print_text(var/text_to_print, var/paper_title = null)
+	if(!stored_paper)
+		return 0
+	if(!enabled)
+		return 0
+	if(!check_functionality())
+		return 0
+
+	var/obj/item/weapon/paper/P = new/obj/item/weapon/paper(get_turf(holder2))
+
+	// Damaged printer causes the resulting paper to be somewhat harder to read.
+	if(damage > damage_malfunction)
+		P.info = stars(text_to_print, 100-malfunction_probability)
+	else
+		P.info = text_to_print
+	if(paper_title)
+		P.name = paper_title
+	P.update_icon()
+
+	stored_paper--
+	return 1
+
+/obj/item/weapon/computer_hardware/nano_printer/attackby(obj/item/W as obj, mob/user as mob)
+	if(istype(W, /obj/item/weapon/paper))
+		if(stored_paper >= max_paper)
+			to_chat(user, "You try to add \the [W] into \the [src], but its paper bin is full.")
+			return
+
+		to_chat(user, "You insert \the [W] into [src].")
+		qdel(W)
+		stored_paper++
+	else if(istype(W, /obj/item/weapon/paper_bundle))
+		var/obj/item/weapon/paper_bundle/B = W
+		var/num_of_pages_added = 0
+		if(stored_paper >= max_paper)
+			to_chat(user, "You try to add \the [W] into \the [src], but its paper bin is full.")
+			return
+		for(var/obj/item/weapon/bundleitem in B) //loop through items in bundle
+			if(istype(bundleitem, /obj/item/weapon/paper)) //if item is paper (and not photo), add into the bin
+				B.pages.Remove(bundleitem)
+				qdel(bundleitem)
+				num_of_pages_added++
+				stored_paper++
+			if(stored_paper >= max_paper) //check if the printer is full yet
+				to_chat(user, "The printer has been filled to full capacity.")
+				break
+		if(B.pages.len == 0) //if all its papers have been put into the printer, delete bundle
+			qdel(W)
+		else if(B.pages.len == 1) //if only one item left, extract item and delete the one-item bundle
+			user.drop_from_inventory(B)
+			user.put_in_hands(B[1])
+			qdel(B)
+		else //if at least two items remain, just update the bundle icon
+			B.update_icon()
+		to_chat(user, "You add [num_of_pages_added] papers from \the [W] into \the [src].")
+	return
+
+/obj/item/weapon/computer_hardware/nano_printer/Destroy()
+	if(holder2 && (holder2.nano_printer == src))
+		holder2.nano_printer = null
+	holder2 = null
+	return ..()

code/modules/modular_computers/hardware/network_card.dm

@@ -0,0 +1,100 @@
+var/global/ntnet_card_uid = 1
+
+/obj/item/weapon/computer_hardware/network_card/
+	name = "basic NTNet network card"
+	desc = "A basic network card for usage with standard NTNet frequencies."
+	power_usage = 50
+	origin_tech = list(TECH_DATA = 2, TECH_ENGINEERING = 1)
+	critical = 0
+	icon_state = "netcard_basic"
+	hardware_size = 1
+	var/identification_id = null	// Identification ID. Technically MAC address of this device. Can't be changed by user.
+	var/identification_string = "" 	// Identification string, technically nickname seen in the network. Can be set by user.
+	var/long_range = 0
+	var/ethernet = 0 // Hard-wired, therefore always on, ignores NTNet wireless checks.
+	malfunction_probability = 1
+
+/obj/item/weapon/computer_hardware/network_card/diagnostics(var/mob/user)
+	..()
+	to_chat(user, "NIX Unique ID: [identification_id]")
+	to_chat(user, "NIX User Tag: [identification_string]")
+	to_chat(user, "Supported protocols:")
+	to_chat(user, "511.m SFS (Subspace) - Standard Frequency Spread")
+	if(long_range)
+		to_chat(user, "511.n WFS/HB (Subspace) - Wide Frequency Spread/High Bandiwdth")
+	if(ethernet)
+		to_chat(user, "OpenEth (Physical Connection) - Physical network connection port")
+
+/obj/item/weapon/computer_hardware/network_card/New(var/l)
+	..(l)
+	identification_id = ntnet_card_uid
+	ntnet_card_uid++
+
+/obj/item/weapon/computer_hardware/network_card/advanced
+	name = "advanced NTNet network card"
+	desc = "An advanced network card for usage with standard NTNet frequencies. It's transmitter is strong enough to connect even when far away."
+	long_range = 1
+	origin_tech = list(TECH_DATA = 4, TECH_ENGINEERING = 2)
+	power_usage = 100 // Better range but higher power usage.
+	icon_state = "netcard_advanced"
+	hardware_size = 1
+
+/obj/item/weapon/computer_hardware/network_card/wired
+	name = "wired NTNet network card"
+	desc = "An advanced network card for usage with standard NTNet frequencies. This one also supports wired connection."
+	ethernet = 1
+	origin_tech = list(TECH_DATA = 5, TECH_ENGINEERING = 3)
+	power_usage = 100 // Better range but higher power usage.
+	icon_state = "netcard_ethernet"
+	hardware_size = 3
+
+/obj/item/weapon/computer_hardware/network_card/Destroy()
+	if(holder2 && (holder2.network_card == src))
+		holder2.network_card = null
+	holder2 = null
+	return ..()
+
+// Returns a string identifier of this network card
+/obj/item/weapon/computer_hardware/network_card/proc/get_network_tag()
+	return "[identification_string] (NID [identification_id])"
+
+/obj/item/weapon/computer_hardware/network_card/proc/is_banned()
+	return ntnet_global.check_banned(identification_id)
+
+// 0 - No signal, 1 - Low signal, 2 - High signal. 3 - Wired Connection
+/obj/item/weapon/computer_hardware/network_card/proc/get_signal(var/specific_action = 0)
+	if(!holder2) // Hardware is not installed in anything. No signal. How did this even get called?
+		return 0
+
+	if(!enabled)
+		return 0
+
+	if(!check_functionality() || !ntnet_global || is_banned())
+		return 0
+
+	if(ethernet) // Computer is connected via wired connection.
+		return 3
+
+	if(!ntnet_global.check_function(specific_action)) // NTNet is down and we are not connected via wired connection. No signal.
+		return 0
+
+	if(holder2)
+		var/turf/T = get_turf(holder2)
+		if(!istype(T)) //no reception in nullspace
+			return 0
+		if(T.z in using_map.station_levels)
+			// Computer is on station. Low/High signal depending on what type of network card you have
+			if(long_range)
+				return 2
+			else
+				return 1
+		if(T.z in using_map.contact_levels) //not on station, but close enough for radio signal to travel
+			if(long_range) // Computer is not on station, but it has upgraded network card. Low signal.
+				return 1
+
+	return 0 // Computer is not on station and does not have upgraded network card. No signal.
+
+/obj/item/weapon/computer_hardware/network_card/Destroy()
+	if(holder2 && (holder2.network_card == src))
+		holder2.network_card = null
+	..()

code/modules/modular_computers/hardware/portable_hard_drive.dm

@@ -0,0 +1,37 @@
+// These are basically USB data sticks and may be used to transfer files between devices
+/obj/item/weapon/computer_hardware/hard_drive/portable/
+	name = "basic data crystal"
+	desc = "Small crystal with imprinted photonic circuits that can be used to store data. Its capacity is 16 GQ."
+	power_usage = 10
+	icon_state = "flashdrive_basic"
+	hardware_size = 1
+	max_capacity = 16
+	origin_tech = list(TECH_DATA = 1)
+
+/obj/item/weapon/computer_hardware/hard_drive/portable/advanced
+	name = "advanced data crystal"
+	desc = "Small crystal with imprinted high-density photonic circuits that can be used to store data. Its capacity is 64 GQ."
+	power_usage = 20
+	icon_state = "flashdrive_advanced"
+	hardware_size = 1
+	max_capacity = 64
+	origin_tech = list(TECH_DATA = 2)
+
+/obj/item/weapon/computer_hardware/hard_drive/portable/super
+	name = "super data crystal"
+	desc = "Small crystal with imprinted ultra-density photonic circuits that can be used to store data. Its capacity is 256 GQ."
+	power_usage = 40
+	icon_state = "flashdrive_super"
+	hardware_size = 1
+	max_capacity = 256
+	origin_tech = list(TECH_DATA = 4)
+
+/obj/item/weapon/computer_hardware/hard_drive/portable/New()
+	..()
+	stored_files = list()
+	recalculate_size()
+
+/obj/item/weapon/computer_hardware/hard_drive/portable/Destroy()
+	if(holder2 && (holder2.portable_drive == src))
+		holder2.portable_drive = null
+	return ..()

code/modules/modular_computers/hardware/processor_unit.dm

@@ -0,0 +1,46 @@
+// CPU that allows the computer to run programs.
+// Better CPUs are obtainable via research and can run more programs on background.
+
+/obj/item/weapon/computer_hardware/processor_unit
+	name = "standard processor"
+	desc = "A standard CPU used in most computers. It can run up to three programs simultaneously."
+	icon_state = "cpu_normal"
+	hardware_size = 2
+	power_usage = 50
+	critical = 1
+	malfunction_probability = 1
+	origin_tech = list(TECH_DATA = 3, TECH_ENGINEERING = 2)
+
+	var/max_idle_programs = 2 // 2 idle, + 1 active = 3 as said in description.
+
+/obj/item/weapon/computer_hardware/processor_unit/small
+	name = "standard microprocessor"
+	desc = "A standard miniaturised CPU used in portable devices. It can run up to two programs simultaneously."
+	icon_state = "cpu_small"
+	hardware_size = 1
+	power_usage = 25
+	max_idle_programs = 1
+	origin_tech = list(TECH_DATA = 2, TECH_ENGINEERING = 2)
+
+/obj/item/weapon/computer_hardware/processor_unit/photonic
+	name = "photonic processor"
+	desc = "An advanced experimental CPU that uses photonic core instead of regular circuitry. It can run up to five programs simultaneously, but uses a lot of power."
+	icon_state = "cpu_normal_photonic"
+	hardware_size = 2
+	power_usage = 250
+	max_idle_programs = 4
+	origin_tech = list(TECH_DATA = 5, TECH_ENGINEERING = 4)
+
+/obj/item/weapon/computer_hardware/processor_unit/photonic/small
+	name = "photonic microprocessor"
+	desc = "An advanced miniaturised CPU for use in portable devices. It uses photonic core instead of regular circuitry. It can run up to three programs simultaneously."
+	icon_state = "cpu_small_photonic"
+	hardware_size = 1
+	power_usage = 75
+	max_idle_programs = 2
+	origin_tech = list(TECH_DATA = 4, TECH_ENGINEERING = 3)
+
+/obj/item/weapon/computer_hardware/processor_unit/Destroy()
+	if(holder2 && (holder2.processor_unit == src))
+		holder2.processor_unit = null
+	return ..()

code/modules/modular_computers/hardware/tesla_link.dm

@@ -0,0 +1,14 @@
+/obj/item/weapon/computer_hardware/tesla_link
+	name = "tesla link"
+	desc = "An advanced tesla link that wirelessly recharges connected device from nearby area power controller."
+	critical = 0
+	enabled = 1
+	icon_state = "teslalink"
+	hardware_size = 1
+	origin_tech = list(TECH_DATA = 2, TECH_POWER = 3, TECH_ENGINEERING = 2)
+	var/passive_charging_rate = 250			// W
+
+/obj/item/weapon/computer_hardware/tesla_link/Destroy()
+	if(holder2 && (holder2.tesla_link == src))
+		holder2.tesla_link = null
+	return ..()

code/modules/modular_computers/laptop_vendor.dm

@@ -0,0 +1,308 @@
+// A vendor machine for modular computer portable devices - Laptops and Tablets
+
+/obj/machinery/lapvend
+	name = "computer vendor"
+	desc = "A vending machine with a built-in microfabricator, capable of dispensing various NT-branded computers."
+	icon = 'icons/obj/vending.dmi'
+	icon_state = "robotics"
+	layer = OBJ_LAYER - 0.1
+	anchored = 1
+	density = 1
+
+	// The actual laptop/tablet
+	var/obj/item/modular_computer/laptop/fabricated_laptop = null
+	var/obj/item/modular_computer/tablet/fabricated_tablet = null
+
+	// Utility vars
+	var/state = 0 							// 0: Select device type, 1: Select loadout, 2: Payment, 3: Thankyou screen
+	var/devtype = 0 						// 0: None(unselected), 1: Laptop, 2: Tablet
+	var/total_price = 0						// Price of currently vended device.
+
+	// Device loadout
+	var/dev_cpu = 1							// 1: Default, 2: Upgraded
+	var/dev_battery = 1						// 1: Default, 2: Upgraded, 3: Advanced
+	var/dev_disk = 1						// 1: Default, 2: Upgraded, 3: Advanced
+	var/dev_netcard = 0						// 0: None, 1: Basic, 2: Long-Range
+	var/dev_tesla = 0						// 0: None, 1: Standard
+	var/dev_nanoprint = 0					// 0: None, 1: Standard
+	var/dev_card = 0						// 0: None, 1: Standard
+
+// Removes all traces of old order and allows you to begin configuration from scratch.
+/obj/machinery/lapvend/proc/reset_order()
+	state = 0
+	devtype = 0
+	if(fabricated_laptop)
+		qdel(fabricated_laptop)
+		fabricated_laptop = null
+	if(fabricated_tablet)
+		qdel(fabricated_tablet)
+		fabricated_tablet = null
+	dev_cpu = 1
+	dev_battery = 1
+	dev_disk = 1
+	dev_netcard = 0
+	dev_tesla = 0
+	dev_nanoprint = 0
+	dev_card = 0
+
+// Recalculates the price and optionally even fabricates the device.
+/obj/machinery/lapvend/proc/fabricate_and_recalc_price(var/fabricate = 0)
+	total_price = 0
+	if(devtype == 1) 		// Laptop, generally cheaper to make it accessible for most station roles
+		if(fabricate)
+			fabricated_laptop = new(src)
+		total_price = 99
+		switch(dev_cpu)
+			if(1)
+				if(fabricate)
+					fabricated_laptop.processor_unit = new/obj/item/weapon/computer_hardware/processor_unit/small(fabricated_laptop)
+			if(2)
+				if(fabricate)
+					fabricated_laptop.processor_unit = new/obj/item/weapon/computer_hardware/processor_unit(fabricated_laptop)
+				total_price += 299
+		switch(dev_battery)
+			if(1) // Basic(750C)
+				if(fabricate)
+					fabricated_laptop.battery_module = new/obj/item/weapon/computer_hardware/battery_module(fabricated_laptop)
+			if(2) // Upgraded(1100C)
+				if(fabricate)
+					fabricated_laptop.battery_module = new/obj/item/weapon/computer_hardware/battery_module/advanced(fabricated_laptop)
+				total_price += 199
+			if(3) // Advanced(1500C)
+				if(fabricate)
+					fabricated_laptop.battery_module = new/obj/item/weapon/computer_hardware/battery_module/super(fabricated_laptop)
+				total_price += 499
+		switch(dev_disk)
+			if(1) // Basic(128GQ)
+				if(fabricate)
+					fabricated_laptop.hard_drive = new/obj/item/weapon/computer_hardware/hard_drive(fabricated_laptop)
+			if(2) // Upgraded(256GQ)
+				if(fabricate)
+					fabricated_laptop.hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/advanced(fabricated_laptop)
+				total_price += 99
+			if(3) // Advanced(512GQ)
+				if(fabricate)
+					fabricated_laptop.hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/super(fabricated_laptop)
+				total_price += 299
+		switch(dev_netcard)
+			if(1) // Basic(Short-Range)
+				if(fabricate)
+					fabricated_laptop.network_card = new/obj/item/weapon/computer_hardware/network_card(fabricated_laptop)
+				total_price += 99
+			if(2) // Advanced (Long Range)
+				if(fabricate)
+					fabricated_laptop.network_card = new/obj/item/weapon/computer_hardware/network_card/advanced(fabricated_laptop)
+				total_price += 299
+		if(dev_tesla)
+			total_price += 399
+			if(fabricate)
+				fabricated_laptop.tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(fabricated_laptop)
+		if(dev_nanoprint)
+			total_price += 99
+			if(fabricate)
+				fabricated_laptop.nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(fabricated_laptop)
+		if(dev_card)
+			total_price += 199
+			if(fabricate)
+				fabricated_laptop.card_slot = new/obj/item/weapon/computer_hardware/card_slot(fabricated_laptop)
+
+		return total_price
+	else if(devtype == 2) 	// Tablet, more expensive, not everyone could probably afford this.
+		if(fabricate)
+			fabricated_tablet = new(src)
+			fabricated_tablet.processor_unit = new/obj/item/weapon/computer_hardware/processor_unit/small(fabricated_tablet)
+		total_price = 199
+		switch(dev_battery)
+			if(1) // Basic(300C)
+				if(fabricate)
+					fabricated_tablet.battery_module = new/obj/item/weapon/computer_hardware/battery_module/nano(fabricated_tablet)
+			if(2) // Upgraded(500C)
+				if(fabricate)
+					fabricated_tablet.battery_module = new/obj/item/weapon/computer_hardware/battery_module/micro(fabricated_tablet)
+				total_price += 199
+			if(3) // Advanced(750C)
+				if(fabricate)
+					fabricated_tablet.battery_module = new/obj/item/weapon/computer_hardware/battery_module(fabricated_tablet)
+				total_price += 499
+		switch(dev_disk)
+			if(1) // Basic(32GQ)
+				if(fabricate)
+					fabricated_tablet.hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/micro(fabricated_tablet)
+			if(2) // Upgraded(64GQ)
+				if(fabricate)
+					fabricated_tablet.hard_drive = new/obj/item/weapon/computer_hardware/hard_drive/small(fabricated_tablet)
+				total_price += 99
+			if(3) // Advanced(128GQ)
+				if(fabricate)
+					fabricated_tablet.hard_drive = new/obj/item/weapon/computer_hardware/hard_drive(fabricated_tablet)
+				total_price += 299
+		switch(dev_netcard)
+			if(1) // Basic(Short-Range)
+				if(fabricate)
+					fabricated_tablet.network_card = new/obj/item/weapon/computer_hardware/network_card(fabricated_tablet)
+				total_price += 99
+			if(2) // Advanced (Long Range)
+				if(fabricate)
+					fabricated_tablet.network_card = new/obj/item/weapon/computer_hardware/network_card/advanced(fabricated_tablet)
+				total_price += 299
+		if(dev_nanoprint)
+			total_price += 99
+			if(fabricate)
+				fabricated_tablet.nano_printer = new/obj/item/weapon/computer_hardware/nano_printer(fabricated_tablet)
+		if(dev_card)
+			total_price += 199
+			if(fabricate)
+				fabricated_tablet.card_slot = new/obj/item/weapon/computer_hardware/card_slot(fabricated_tablet)
+		if(dev_tesla)
+			total_price += 399
+			if(fabricate)
+				fabricated_tablet.tesla_link = new/obj/item/weapon/computer_hardware/tesla_link(fabricated_tablet)
+		return total_price
+	return 0
+
+
+
+
+
+/obj/machinery/lapvend/Topic(href, href_list)
+	if(..())
+		return 1
+
+	if(href_list["pick_device"])
+		if(state) // We've already picked a device type
+			return 0
+		devtype = text2num(href_list["pick_device"])
+		state = 1
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["clean_order"])
+		reset_order()
+		return 1
+	if((state != 1) && devtype) // Following IFs should only be usable when in the Select Loadout mode
+		return 0
+	if(href_list["confirm_order"])
+		state = 2 // Wait for ID swipe for payment processing
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_cpu"])
+		dev_cpu = text2num(href_list["hw_cpu"])
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_battery"])
+		dev_battery = text2num(href_list["hw_battery"])
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_disk"])
+		dev_disk = text2num(href_list["hw_disk"])
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_netcard"])
+		dev_netcard = text2num(href_list["hw_netcard"])
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_tesla"])
+		dev_tesla = text2num(href_list["hw_tesla"])
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_nanoprint"])
+		dev_nanoprint = text2num(href_list["hw_nanoprint"])
+		fabricate_and_recalc_price(0)
+		return 1
+	if(href_list["hw_card"])
+		dev_card = text2num(href_list["hw_card"])
+		fabricate_and_recalc_price(0)
+		return 1
+	return 0
+
+/obj/machinery/lapvend/attack_hand(var/mob/user)
+	ui_interact(user)
+
+/obj/machinery/lapvend/ui_interact(mob/user, ui_key = "main", var/datum/nanoui/ui = null, var/force_open = 1)
+	if(stat & (BROKEN | NOPOWER | MAINT))
+		if(ui)
+			ui.close()
+		return 0
+
+	var/list/data[0]
+	data["state"] = state
+	if(state == 1)
+		data["devtype"] = devtype
+		data["hw_battery"] = dev_battery
+		data["hw_disk"] = dev_disk
+		data["hw_netcard"] = dev_netcard
+		data["hw_tesla"] = dev_tesla
+		data["hw_nanoprint"] = dev_nanoprint
+		data["hw_card"] = dev_card
+		data["hw_cpu"] = dev_cpu
+	if(state == 1 || state == 2)
+		data["totalprice"] = total_price
+
+	ui = SSnanoui.try_update_ui(user, src, ui_key, ui, data, force_open)
+	if (!ui)
+		ui = new(user, src, ui_key, "computer_fabricator.tmpl", "Personal Computer Vendor", 500, 400)
+		ui.set_initial_data(data)
+		ui.open()
+		ui.set_auto_update(1)
+
+
+obj/machinery/lapvend/attackby(obj/item/weapon/W as obj, mob/user as mob)
+	var/obj/item/weapon/card/id/I = W.GetID()
+	// Awaiting payment state
+	if(state == 2)
+		if(process_payment(I,W))
+			fabricate_and_recalc_price(1)
+			if((devtype == 1) && fabricated_laptop)
+				if(fabricated_laptop.battery_module)
+					fabricated_laptop.battery_module.charge_to_full()
+				fabricated_laptop.forceMove(src.loc)
+				fabricated_laptop.screen_on = 0
+				fabricated_laptop.anchored = 0
+				fabricated_laptop.update_icon()
+				fabricated_laptop.update_verbs()
+				fabricated_laptop = null
+			else if((devtype == 2) && fabricated_tablet)
+				if(fabricated_tablet.battery_module)
+					fabricated_tablet.battery_module.charge_to_full()
+				fabricated_tablet.forceMove(src.loc)
+				fabricated_tablet.update_verbs()
+				fabricated_tablet = null
+			ping("Enjoy your new product!")
+			state = 3
+			return 1
+		return 0
+	return ..()
+
+
+// Simplified payment processing, returns 1 on success.
+/obj/machinery/lapvend/proc/process_payment(var/obj/item/weapon/card/id/I, var/obj/item/ID_container)
+	if(I==ID_container || ID_container == null)
+		visible_message("<span class='info'>\The [usr] swipes \the [I] through \the [src].</span>")
+	else
+		visible_message("<span class='info'>\The [usr] swipes \the [ID_container] through \the [src].</span>")
+	var/datum/money_account/customer_account = get_account(I.associated_account_number)
+	if (!customer_account || customer_account.suspended)
+		ping("Connection error. Unable to connect to account.")
+		return 0
+
+	if(customer_account.security_level != 0) //If card requires pin authentication (ie seclevel 1 or 2)
+		var/attempt_pin = input("Enter pin code", "Vendor transaction") as num
+		customer_account = attempt_account_access(I.associated_account_number, attempt_pin, 2)
+
+		if(!customer_account)
+			ping("Unable to access account: incorrect credentials.")
+			return 0
+
+	if(total_price > customer_account.money)
+		ping("Insufficient funds in account.")
+		return 0
+	else
+		customer_account.money -= total_price
+		var/datum/transaction/T = new()
+		T.target_name = "Computer Manufacturer (via [src.name])"
+		T.purpose = "Purchase of [(devtype == 1) ? "laptop computer" : "tablet microcomputer"]."
+		T.amount = total_price
+		T.source_terminal = src.name
+		T.date = current_date_string
+		T.time = stationtime2text()
+		customer_account.transaction_log.Add(T)
+		return 1