-Ported/continued AI Freelook. AIs can now look around like a ghost with the exception that they cannot see what cameras cannot see. Meaning if you're in maintenance, and there's no cameras near you, the AI will not know what you are doing. This also means there's no X-Ray vision cameras anymore. I've added documentation to freelook.dm which explains how the system works, if anyone is interested in adding anything. More information here: http://nanotrasen.com/phpBB3/viewtopic.php?f=7&t=9675

-I've added some cameras to rooms that should have cameras but were previously depending on other camera's using their X-Ray vision in order to see into a room.

-AIs have a multitool in their contents that they can use to interact with the telecommunication machines.

-Added "Follow" for observers. Works the same as AI tracking without checking if they can track.

-Added a range to how far Cyborgs can interact with machines. This is to stop Cyborgs from interacting with machines through cameras, which could be used to easily disable the AI.

git-svn-id: http://tgstation13.googlecode.com/svn/trunk@4531 316c924e-a436-60f5-8080-3fe189b3f50e

code/modules/admin/verbs/mapping.dm

@@ -58,7 +58,7 @@ var/intercom_range_display_status = 0
 		del(C)
 
 	if(camera_range_display_status)
-		for(var/obj/machinery/camera/C in Cameras)
+		for(var/obj/machinery/camera/C in cameranet.cameras)
 			new/obj/effect/debugging/camera_range(C.loc)
 	feedback_add_details("admin_verb","mCRD") //If you are copy-pasting this, ensure the 2nd parameter is unique to the new proc!
 
@@ -74,7 +74,7 @@ var/intercom_range_display_status = 0
 
 	var/list/obj/machinery/camera/CL = list()
 
-	for(var/obj/machinery/camera/C in Cameras)
+	for(var/obj/machinery/camera/C in cameranet.cameras)
 		CL += C
 
 	var/output = {"<B>CAMERA ANNOMALITIES REPORT</B><HR>

code/modules/mob/dead/observer/observer.dm

@@ -174,6 +174,21 @@ This is the proc mobs get to turn into a ghost. Forked from ghostize due to comp
 		L+=T
 	usr.loc = pick(L)
 
+/mob/dead/observer/verb/follow()
+	set category = "Ghost"
+	set name = "Follow" // "Haunt"
+	set desc = "Follow and haunt a mob."
+
+	if(istype(usr, /mob/dead/observer))
+		var/mob/target = input("Please, select a player!", "Jump to Mob", null, null) as null|anything in sortAtom(mob_list)
+		if(target)
+			spawn(0)
+				var/turf/pos = get_turf(src)
+				while(src.loc == pos)
+					src.loc = get_turf(target)
+					pos = src.loc
+					sleep(15)
+
 
 /mob/dead/observer/verb/jumptomob() //Moves the ghost instead of just changing the ghosts's eye -Nodrak
 	set category = "Ghost"

code/modules/mob/living/silicon/ai/ai.dm

@@ -17,6 +17,7 @@
 	var/ioncheck[1]
 	var/icon/holo_icon//Default is assigned when AI is created.
 	var/obj/item/device/pda/ai/aiPDA = null
+	var/obj/item/device/multitool/aiMulti = null
 
 	//MALFUNCTION
 	var/datum/AI_Module/module_picker/malf_picker
@@ -69,6 +70,8 @@
 	aiPDA.ownjob = "AI"
 	aiPDA.name = name + " (" + aiPDA.ownjob + ")"
 
+	aiMulti = new(src)
+
 	if (istype(loc, /turf))
 		verbs.Add(/mob/living/silicon/ai/proc/ai_call_shuttle,/mob/living/silicon/ai/proc/ai_camera_track, \
 		/mob/living/silicon/ai/proc/ai_camera_list, /mob/living/silicon/ai/proc/ai_network_change, \
@@ -101,7 +104,7 @@
 
 /mob/living/silicon/ai/verb/pick_icon()
 	set category = "AI Commands"
-	set name = "Change AI Core Display"
+	set name = "Set AI Core Display"
 	if(stat || aiRestorePowerRoutine)
 		return
 
@@ -292,7 +295,7 @@
 		machine = null
 		src << browse(null, t1)
 	if (href_list["switchcamera"])
-		switchCamera(locate(href_list["switchcamera"]))
+		switchCamera(locate(href_list["switchcamera"])) in cameranet.cameras
 	if (href_list["showalerts"])
 		ai_alerts()
 
@@ -325,15 +328,15 @@
 		statelaws()
 
 	if (href_list["track"])
-		var/mob/target = locate(href_list["track"])
-		var/mob/living/silicon/ai/A = locate(href_list["track2"])
+		var/mob/target = locate(href_list["track"]) in mob_list
+		var/mob/living/silicon/ai/A = locate(href_list["track2"]) in mob_list
 		if(A && target)
 			A.ai_actual_track(target)
 		return
 
 	else if (href_list["faketrack"])
-		var/mob/target = locate(href_list["track"])
-		var/mob/living/silicon/ai/A = locate(href_list["track2"])
+		var/mob/target = locate(href_list["track"]) in mob_list
+		var/mob/living/silicon/ai/A = locate(href_list["track2"]) in mob_list
 		if(A && target)
 
 			A.cameraFollow = target
@@ -437,14 +440,15 @@
 /mob/living/silicon/ai/proc/switchCamera(var/obj/machinery/camera/C)
 
 	src.cameraFollow = null
-	if (!C || stat == 2 || !C.status || C.network != network)
-		machine = null
-		reset_view(null)
+	if (!C || stat == 2 || !C.can_use())
+		//machine = null
+		//reset_view(null)
 		return 0
 
 	// ok, we're alive, camera is good and in our network...
+	eyeobj.setLoc(get_turf(C))
 	machine = src
-	reset_view(C)
+
 	return 1
 
 /mob/living/silicon/ai/triggerAlarm(var/class, area/A, var/O, var/alarmsource)
@@ -468,7 +472,7 @@
 		C = O
 	L[A.name] = list(A, (C) ? C : O, list(alarmsource))
 	if (O)
-		if (C && C.status)
+		if (C && C.can_use())
 			src << "--- [class] alarm detected in [A.name]! (<A HREF=?src=\ref[src];switchcamera=\ref[C]>[C.c_tag]</A>)"
 		else if (CL && CL.len)
 			var/foo = 0
@@ -504,17 +508,17 @@
 /mob/living/silicon/ai/cancel_camera()
 	set category = "AI Commands"
 	set name = "Cancel Camera View"
-	reset_view(null)
-	machine = null
+	//reset_view(null)
+	//machine = null
 	src.cameraFollow = null
 
+
 //Replaces /mob/living/silicon/ai/verb/change_network() in ai.dm & camera.dm
 //Adds in /mob/living/silicon/ai/proc/ai_network_change() instead
 //Addition by Mord_Sith to define AI's network change ability
 /mob/living/silicon/ai/proc/ai_network_change()
 	set category = "AI Commands"
-	set name = "Change Camera Network"
-	reset_view(null)
+	set name = "Jump To Network"
 	machine = null
 	src.cameraFollow = null
 	var/cameralist[0]
@@ -523,8 +527,10 @@
 		usr << "You can't change your camera network because you are dead!"
 		return
 
-	for (var/obj/machinery/camera/C in Cameras)
-		if(!C.status)
+	var/mob/living/silicon/ai/U = usr
+
+	for (var/obj/machinery/camera/C in cameranet.cameras)
+		if(!C.can_use())
 			continue
 		if(C.network == "AI Satellite")
 			if (ticker.mode.name == "AI malfunction")
@@ -535,10 +541,17 @@
 		else
 			if(C.network != "CREED" && C.network != "thunder" && C.network != "RD" && C.network != "toxins" && C.network != "Prison")
 				cameralist[C.network] = C.network
-
-	network = input(usr, "Which network would you like to view?") as null|anything in cameralist
+	var/old_network = network
+	network = input(U, "Which network would you like to view?") as null|anything in cameralist
 	if(isnull(network))
-		network = initial(network) // If nothing is selected, default to SS13 (or the initial network)
+		network = old_network // If nothing is selected
+	else
+		for(var/obj/machinery/camera/C in cameranet.cameras)
+			if(!C.can_use())
+				continue
+			if(C.network == network)
+				U.eyeobj.setLoc(get_turf(C))
+				break
 	src << "\blue Switched to [network] camera network."
 //End of code by Mord_Sith
 
@@ -620,15 +633,39 @@
 
 //Toggles the luminosity and applies it by re-entereing the camera.
 /mob/living/silicon/ai/proc/toggle_camera_light()
-	set name = "Toggle camera light"
+	set name = "Toggle Camera Light"
 	set desc = "Toggles the light on the camera the AI is looking through."
 	set category = "AI Commands"
 
-	if(!current)
-		usr << "\red You are not looking through a camera right now."
-		return
 	camera_light_on = !camera_light_on
-	reset_view(current)
+	src << "Camera lights [camera_light_on ? "activated" : "deactivated"]."
+	if(!camera_light_on)
+		if(src.current)
+			src.current.sd_SetLuminosity(0)
+	else
+		src.lightNearbyCamera()
+
+
+
+// Handled camera lighting, when toggled.
+// It will get the nearest camera via range, it wouldn't matter
+
+/mob/living/silicon/ai/proc/lightNearbyCamera(var/lum)
+	if(camera_light_on && camera_light_on < world.timeofday)
+		if(src.current)
+			// I have to use range instead of view or the darkness gets in the way.
+			var/camera = near_range_camera(src.eyeobj)
+			if(camera && src.current != camera)
+				src.current.sd_SetLuminosity(0)
+				src.current = camera
+				src.current.sd_SetLuminosity(lum)
+			else if(isnull(camera))
+				src.current.sd_SetLuminosity(0)
+				src.current = null
+			camera_light_on = world.timeofday + 1 * 10 // Update the light every 2 seconds.
+		else
+			src.current = near_range_camera(src.eyeobj)
+			if(src.current) src.current.sd_SetLuminosity(lum)
 
 
 #undef AI_CAMERA_LUMINOSITY

code/modules/mob/living/silicon/ai/death.dm

@@ -4,6 +4,7 @@
 	icon_state = "ai-crash"
 
 	update_canmove()
+	src.eyeobj.setLoc(get_turf(src))
 	if(blind)	blind.layer = 0
 	sight |= SEE_TURFS|SEE_MOBS|SEE_OBJS
 	see_in_dark = 8

code/modules/mob/living/silicon/ai/freelook/cameranet.dm

@@ -0,0 +1,134 @@
+// CAMERA NET
+//
+// The datum containing all the chunks.
+
+var/datum/cameranet/cameranet = new()
+
+/datum/cameranet
+	// The cameras on the map, no matter if they work or not. Updated in obj/machinery/camera.dm by New() and Del().
+	var/list/cameras = list()
+	// The chunks of the map, mapping the areas that the cameras can see.
+	var/list/chunks = list()
+	var/ready = 0
+
+// Checks if a chunk has been Generated in x, y, z.
+/datum/cameranet/proc/chunkGenerated(x, y, z)
+	x &= ~0xf
+	y &= ~0xf
+	var/key = "[x],[y],[z]"
+	return key in chunks
+
+// Returns the chunk in the x, y, z.
+// If there is no chunk, it creates a new chunk and returns that.
+/datum/cameranet/proc/getCameraChunk(x, y, z)
+	x &= ~0xf
+	y &= ~0xf
+	var/key = "[x],[y],[z]"
+	if(!(key in chunks))
+		chunks[key] = new /datum/camerachunk(null, x, y, z)
+
+	return chunks[key]
+
+// Updates what the aiEye can see. It is recommended you use this when the aiEye moves or it's location is set.
+
+/datum/cameranet/proc/visibility(mob/aiEye/ai)
+	// 0xf = 15
+	var/x1 = max(0, ai.x - 16) & ~0xf
+	var/y1 = max(0, ai.y - 16) & ~0xf
+	var/x2 = min(world.maxx, ai.x + 16) & ~0xf
+	var/y2 = min(world.maxy, ai.y + 16) & ~0xf
+
+	var/list/visibleChunks = list()
+
+	for(var/x = x1; x <= x2; x += 16)
+		for(var/y = y1; y <= y2; y += 16)
+			visibleChunks += getCameraChunk(x, y, ai.z)
+
+	var/list/remove = ai.visibleCameraChunks - visibleChunks
+	var/list/add = visibleChunks - ai.visibleCameraChunks
+
+	for(var/datum/camerachunk/c in remove)
+		c.remove(ai)
+
+	for(var/datum/camerachunk/c in add)
+		c.add(ai)
+
+// Updates the chunks that the turf is located in. Use this when obstacles are destroyed or	when doors open.
+
+/datum/cameranet/proc/updateVisibility(atom/A, var/opacity_check = 1)
+
+	if(!ticker || (opacity_check && !A.opacity))
+		return
+	majorChunkChange(A, 2)
+
+/datum/cameranet/proc/updateChunk(x, y, z)
+	// 0xf = 15
+	if(!chunkGenerated(x, y, z))
+		return
+	var/datum/camerachunk/chunk = getCameraChunk(x, y, z)
+	chunk.hasChanged()
+
+// Removes a camera from a chunk.
+
+/datum/cameranet/proc/removeCamera(obj/machinery/camera/c)
+	majorChunkChange(c, 0)
+
+// Add a camera to a chunk.
+
+/datum/cameranet/proc/addCamera(obj/machinery/camera/c)
+	if(c.can_use())
+		majorChunkChange(c, 1)
+
+// Used for Cyborg cameras. It is the same as "add" but named differently for easier readability
+// and to allow the user know what it is for. Since portable cameras can be in ANY chunk, we have to
+// all it to be added to all chunks. If the camera is disabled, it will instead remove.
+
+/datum/cameranet/proc/updatePortableCamera(obj/machinery/camera/c)
+	if(c.can_use())
+		majorChunkChange(c, 1)
+	else
+		majorChunkChange(c, 0)
+
+// Never access this proc directly!!!!
+// This will update the chunk and all the surrounding chunks.
+// It will also add the atom to the cameras list if you set the choice to 1.
+// Setting the choice to 0 will remove the camera from the chunks.
+// If you want to update the chunks around an object, without adding/removing a camera, use choice 2.
+
+/datum/cameranet/proc/majorChunkChange(atom/c, var/choice)
+	// 0xf = 15
+	if(!c)
+		return
+
+	var/turf/T = get_turf(c)
+	if(T)
+		var/x1 = max(0, T.x - 16) & ~0xf
+		var/y1 = max(0, T.y - 16) & ~0xf
+		var/x2 = min(world.maxx, T.x + 16) & ~0xf
+		var/y2 = min(world.maxy, T.y + 16) & ~0xf
+
+		for(var/x = x1; x <= x2; x += 16)
+			for(var/y = y1; y <= y2; y += 16)
+				if(chunkGenerated(x, y, T.z))
+					var/datum/camerachunk/chunk = getCameraChunk(x, y, T.z)
+					if(choice == 0)
+						// Remove the camera.
+						chunk.cameras -= c
+					else if(choice == 1)
+						// You can't have the same camera in the list twice.
+						chunk.cameras |= c
+					chunk.hasChanged()
+
+// Will check if a mob is on a viewable turf. Returns 1 if it is, otherwise returns 0.
+
+/datum/cameranet/proc/checkCameraVis(mob/living/target as mob)
+
+	// 0xf = 15
+	var/turf/position = get_turf(target)
+	var/datum/camerachunk/chunk = getCameraChunk(position.x, position.y, position.z)
+	if(chunk)
+		if(chunk.changed)
+			chunk.hasChanged(1) // Update now, no matter if it's visible or not.
+		if(position in chunk.visibleTurfs)
+			return 1
+	return 0

code/modules/mob/living/silicon/ai/freelook/chunk.dm

@@ -0,0 +1,135 @@
+#define UPDATE_BUFFER 15
+
+// CAMERA CHUNK
+//
+// A 16x16 grid of the map with a list of turfs that can be seen, are visible and are dimmed.
+// Allows the AI Eye to stream these chunks and know what it can and cannot see.
+
+/datum/camerachunk
+	var/list/obscuredTurfs = list()
+	var/list/visibleTurfs = list()
+	var/list/obscured = list()
+	var/list/cameras = list()
+	var/list/turfs = list()
+	var/list/seenby = list()
+	var/visible = 0
+	var/changed = 0
+	var/updating = 0
+
+// Add an AI eye to the chunk, then update if changed.
+
+/datum/camerachunk/proc/add(mob/aiEye/ai)
+	ai.visibleCameraChunks += src
+	if(ai.ai.client)
+		ai.ai.client.images += obscured
+	visible++
+	seenby += ai
+	if(changed && !updating)
+		update()
+
+// Remove an AI eye from the chunk, then update if changed.
+
+/datum/camerachunk/proc/remove(mob/aiEye/ai)
+	ai.visibleCameraChunks -= src
+	if(ai.ai.client)
+		ai.ai.client.images -= obscured
+	seenby -= ai
+	if(visible > 0)
+		visible--
+
+// Called when a chunk has changed. I.E: A wall was deleted.
+
+/datum/camerachunk/proc/visibilityChanged(turf/loc)
+	if(!(loc in visibleTurfs))
+		return
+
+	hasChanged()
+
+// Updates the chunk, makes sure that it doesn't update too much. If the chunk isn't being watched it will
+// instead be flagged to update the next time an AI Eye moves near it.
+
+/datum/camerachunk/proc/hasChanged(var/update_now = 0)
+	if(visible || update_now)
+		if(!updating)
+			updating = 1
+			spawn(UPDATE_BUFFER) // Batch large changes, such as many doors opening or closing at once
+				update()
+				updating = 0
+	else
+		changed = 1
+
+// The actual updating. It gathers the visible turfs from cameras and puts them into the appropiate lists.
+
+/datum/camerachunk/proc/update()
+
+	var/list/newVisibleTurfs = list()
+
+	for(var/obj/machinery/camera/c in cameras)
+		if(!c.can_use())
+			continue
+		var/turf/pos = get_turf(c)
+		if(pos)
+			for(var/turf/t in hear(7, pos))
+				if(t in turfs)
+					newVisibleTurfs += t
+
+	var/list/visAdded = newVisibleTurfs - visibleTurfs
+	var/list/visRemoved = visibleTurfs - newVisibleTurfs
+
+	visibleTurfs = newVisibleTurfs
+	obscuredTurfs = turfs - newVisibleTurfs
+
+
+	for(var/turf/t in visAdded)
+		if(t.obscured)
+			obscured -= t.obscured
+			for(var/mob/aiEye/m in seenby)
+				if(m.ai.client)
+					m.ai.client.images -= t.obscured
+
+	for(var/turf/t in visRemoved)
+		if(t in obscuredTurfs)
+			if(!t.obscured)
+				t.obscured = image('effects/cameravis.dmi', t, "black", 15)
+
+			obscured += t.obscured
+			for(var/mob/aiEye/m in seenby)
+				if(!m)
+					seenby -= m
+				if(m.ai.client)
+					m.ai.client.images += t.obscured
+
+// Create a new camera chunk, since the chunks are made as they are needed.
+
+/datum/camerachunk/New(loc, x, y, z)
+
+	// 0xf = 15
+	x &= ~0xf
+	y &= ~0xf
+
+	for(var/obj/machinery/camera/c in range(16, locate(x + 8, y + 8, z)))
+		if(c.can_use())
+			cameras += c
+
+	for(var/turf/t in range(10, locate(x + 8, y + 8, z)))
+
+		if(t.x >= x && t.y >= y && t.x < x + 16 && t.y < y + 16)
+			turfs += t
+
+	for(var/obj/machinery/camera/c in cameras)
+		if(!c.can_use())
+			continue
+		var/turf/pos = get_turf(c)
+		if(pos)
+			for(var/turf/t in hear(7, pos))
+				if(t in turfs)
+					visibleTurfs += t
+
+	obscuredTurfs = turfs - visibleTurfs
+
+	for(var/turf/t in obscuredTurfs)
+		if(!t.obscured)
+			t.obscured = image('effects/cameravis.dmi', t, "black", 15)
+		obscured += t.obscured
+
+#undef UPDATE_BUFFER

code/modules/mob/living/silicon/ai/freelook/eye.dm

@@ -0,0 +1,70 @@
+// AI EYE
+//
+// An invisible (no icon) mob that the AI controls to look around the station with.
+// It streams chunks as it moves around, which will show it what the AI can and cannot see.
+
+/mob/aiEye
+	name = "Inactive AI Eye"
+	var/list/visibleCameraChunks = list()
+	var/mob/living/silicon/ai/ai = null
+	density = 0
+	nodamage = 1 // You can't damage it.
+
+// Movement code. Returns 0 to stop air movement from moving it.
+/mob/aiEye/Move()
+	return 0
+
+// Use this when setting the aiEye's location.
+// It will also stream the chunk that the new loc is in.
+
+/mob/aiEye/proc/setLoc(var/T)
+	T = get_turf(T)
+	loc = T
+	cameranet.visibility(src)
+
+// AI MOVEMENT
+
+// The AI's "eye". Described on the top of the page.
+
+/mob/living/silicon/ai/var/mob/aiEye/eyeobj = new()
+
+// Intiliaze the eye by assigning it's "ai" variable to us. Then set it's loc to us.
+
+/mob/living/silicon/ai/New()
+	..()
+	eyeobj.ai = src
+	spawn(5)
+		eyeobj.loc = src.loc
+		eyeobj.name = "[src.name] (AI Eye)" // Give it a name
+
+/mob/living/silicon/ai/Del()
+	eyeobj.ai = null
+	del(eyeobj) // No AI, no Eye
+	..()
+
+// This will move the AIEye. It will also cause lights near the eye to light up, if toggled.
+// This is handled in the proc below this one.
+
+/client/AIMove(n, direct, var/mob/living/silicon/ai/user)
+
+	user.eyeobj.setLoc(get_turf(get_step(user.eyeobj, direct)))
+	user.cameraFollow = null
+	src.eye = user.eyeobj
+	//user.machine = null //Uncomment this if it causes problems.
+	user.lightNearbyCamera()
+
+
+// Return to the Core.
+
+/mob/living/silicon/ai/verb/core()
+	set category = "AI Commands"
+	set name = "AI Core"
+	current = null
+	cameraFollow = null
+	machine = null
+	src.eyeobj.loc = src.loc
+	if(client && client.eye)
+		client.eye = src
+	for(var/datum/camerachunk/c in eyeobj.visibleCameraChunks)
+		c.remove(eyeobj)
+

code/modules/mob/living/silicon/ai/freelook/read_me.dm

@@ -0,0 +1,51 @@
+// CREDITS
+/*
+ Initial code credit for this goes to Uristqwerty.
+ Debugging, functionality, all comments and porting by Giacom.
+
+ Everything about freelook (or what we can put in here) will be stored here.
+
+
+ WHAT IS THIS?
+
+ This is a replacement for the current camera movement system, of the AI. Before this, the AI had to move between cameras and could
+ only see what the cameras could see. Not only this but the cameras could see through walls, which created problems.
+ With this, the AI controls an "AI Eye" mob, which moves just like a ghost; such as moving through walls and being invisible to players.
+ The AI's eye is set to this mob and then we use a system (explained below) to determine what the cameras around the AI Eye can and
+ cannot see. If the camera cannot see a turf, it will black it out, otherwise it won't and the AI will be able to see it.
+ This creates several features, such as.. no more see-through-wall cameras, easier to control camera movement, easier tracking,
+ the AI only being able to track mobs which are visible to a camera, only trackable mobs appearing on the mob list and many more.
+
+
+ HOW IT WORKS
+
+ It works by first creating a camera network datum. Inside of this camera network are "chunks" (which will be
+ explained later) and "cameras". The cameras list is kept up to date by obj/machinery/camera/New() and Del().
+
+ Next the camera network has chunks. These chunks are a 16x16 tile block of turfs and cameras contained inside the chunk.
+ These turfs are then sorted out based on what the cameras can and cannot see. If none of the cameras can see the turf, inside
+ the 16x16 block, it is listed as an "obscured" turf. Meaning the AI won't be able to see it.
+
+
+ HOW IT UPDATES
+
+ The camera network uses a streaming method in order to effeciently update chunks. Since the server will have doors opening, doors closing,
+ turf being destroyed and other lag inducing stuff, we want to update it under certain conditions and not every tick.
+
+ The chunks are not created straight away, only when an AI eye moves into it's area is when it gets created.
+ One a chunk is created, when a non glass door opens/closes or an opacity turf is destroyed, we check to see if an AI Eye is looking in the area.
+ We do this with the "seenby" list, which updates everytime an AI is near a chunk. If there is an AI eye inside the area, we update the chunk
+ that the changed atom is inside and all surrounding chunks, since a camera's vision could leak onto another chunk. If there is no AI Eye, we instead
+ flag the chunk to update whenever it is loaded by an AI Eye. This is basically how the chunks update and keep it in sync. We then add some lag reducing
+ measures, such as an UPDATE_BUFFER which stops a chunk from updating too many times in a certain time-frame, only updating if the changed atom was blocking
+ sight; for example, we don't update glass airlocks or floors.
+
+
+ WHERE IS EVERYTHING?
+
+ cameranet.dm	=	Everything about the cameranet datum.
+ chunk.dm		=	Everything about the chunk datum.
+ eye.dm			=	Everything about the AI and the AIEye.
+ updating.dm	=	Everything about triggers that will update chunks.
+
+*/

code/modules/mob/living/silicon/ai/freelook/update_triggers.dm

@@ -0,0 +1,76 @@
+//UPDATE TRIGGERS, when the chunk (and the surrounding chunks) should update.
+
+// TURFS
+
+/turf
+	var/image/obscured
+
+/turf/proc/visibilityChanged()
+	cameranet.updateVisibility(src)
+
+/atom/proc/move_camera_by_click()
+	if(istype(usr, /mob/living/silicon/ai))
+		var/mob/living/silicon/ai/AI = usr
+		if(AI.client.eye == AI.eyeobj)
+			AI.eyeobj.setLoc(src)
+
+/turf/simulated/Del()
+	visibilityChanged()
+	..()
+
+/turf/simulated/New()
+	..()
+	visibilityChanged()
+
+// STRUCTURES
+
+/obj/structure/Del()
+	cameranet.updateVisibility(src)
+	..()
+
+/obj/structure/New()
+	..()
+	cameranet.updateVisibility(src)
+
+// DOORS
+
+// Simply updates the visibility of the area when it opens/closes/destroyed.
+/obj/machinery/door/update_nearby_tiles(need_rebuild)
+	. = ..(need_rebuild)
+	// Glass door glass = 1
+	// don't check then?
+	if(!glass)
+		cameranet.updateVisibility(src, 0)
+
+// ROBOT MOVEMENT
+
+// Update the portable camera everytime the Robot moves.
+// This might be laggy, comment it out if there are problems.
+
+/mob/living/silicon/robot/Move()
+	. = ..()
+	if(.)
+		if(src.camera)
+			cameranet.updatePortableCamera(src.camera)
+
+// CAMERA
+
+// An addition to deactivate which removes/adds the camera from the chunk list based on if it works or not.
+
+/obj/machinery/camera/deactivate(user as mob, var/choice = 1)
+	..(user, choice)
+	if(src.can_use())
+		cameranet.addCamera(src)
+	else
+		src.sd_SetLuminosity(0)
+		cameranet.removeCamera(src)
+
+/obj/machinery/camera/New()
+	..()
+	cameranet.cameras += src
+	cameranet.addCamera(src)
+
+/obj/machinery/camera/Del()
+	cameranet.cameras -= src
+	cameranet.removeCamera(src)
+	..()

code/modules/mob/living/silicon/ai/login.dm

@@ -22,4 +22,5 @@
 			if(O)
 				O.mode = 1
 				O.emotion = "Neutral"
+	src.core()
 	return

code/modules/mob/living/silicon/ai/logout.dm

@@ -6,4 +6,5 @@
 		if (client)
 			client.eye = loc
 			client.perspective = EYE_PERSPECTIVE
+	src.core()
 	return

code/modules/mob/living/silicon/ai/move.dm

@@ -13,20 +13,6 @@
 	var/obj/machinery/camera/closest = null
 	var/atom/old = (user.current?user.current : user.loc)
 
-	if(istype(user.loc, /obj/item/clothing/suit/space/space_ninja))//To make ninja suit AI holograms work.
-		var/obj/item/clothing/suit/space/space_ninja/S = user.loc//Ease of use.
-		if(S.hologram)//If there is a hologram.
-			S.hologram.loc = get_step(S.hologram, direct)
-			S.hologram.dir = direct
-		return//Whatever the case, return since you can't move anyway.
-
-	if(user.client)//To make AI holograms work. They will relay directions as long as they are centered on the object.
-		var/obj/machinery/hologram/holopad/T = user.client.eye//Client eye centers on an object.
-		if(istype(T)&&T.hologram&&T.master==user)//If there is a hologram and its master is the user.
-			T.hologram.loc = get_step(T.hologram, direct)
-			T.hologram.dir = direct
-			return//Relay move and then return if that's the case.
-
 	if(!old)	return
 
 	var/dx = 0
@@ -43,7 +29,7 @@
 	var/area/A = get_area(old)
 	var/list/old_types = dd_text2list("[A.type]", "/")
 
-	for(var/obj/machinery/camera/current in Cameras)
+	for(var/obj/machinery/camera/current in cameranet.cameras)
 		if(user.network != current.network)	continue
 		if(!current.status)	continue	//	ignore disabled cameras
 

code/modules/mob/living/silicon/robot/login.dm

@@ -29,7 +29,7 @@
 			modtype = "Synd"
 
 		radio = new /obj/item/device/radio/borg(src)
-		if(!scrambledcodes)
+		if(!scrambledcodes && !camera)
 			camera = new /obj/machinery/camera(src)
 			camera.c_tag = real_name
 			camera.network = "SS13"

code/modules/mob/living/silicon/robot/wires.dm

@@ -63,6 +63,7 @@
 		if(BORG_WIRE_CAMERA)
 			if (!isnull(src.camera) && !scrambledcodes)
 				src.camera.status = 1
+				src.camera.deactivate(usr, 0) // Will kick anyone who is watching the Cyborg's camera.
 
 	src.interact(usr)
 

code/modules/mob/living/silicon/say.dm

@@ -26,9 +26,10 @@
 			robot_talk(message)
 		else if ((copytext(message, 1, 3) == ":h") || (copytext(message, 1, 3) == ":H"))
 			if(isAI(src)&&client)//For patching directly into AI holopads.
+				var/mob/living/silicon/ai/U = src
 				message = copytext(message, 3)
 				message = trim(copytext(sanitize(message), 1, MAX_MESSAGE_LEN))
-				holopad_talk(message)
+				U.holopad_talk(message)
 			else//Will not allow anyone by an active AI to use this function.
 				src << "This function is not available to you."
 				return
@@ -38,7 +39,7 @@
 		return ..(message)
 
 //For holopads only. Usable by AI.
-/mob/living/proc/holopad_talk(var/message)
+/mob/living/silicon/ai/proc/holopad_talk(var/message)
 
 	log_say("[key_name(src)] : [message]")
 
@@ -47,8 +48,8 @@
 	if (!message)
 		return
 
-	var/obj/machinery/hologram/holopad/T = client.eye//Client eye centers on an object.
-	if(istype(T)&&T.hologram&&T.master==src)//If there is a hologram and its master is the user.
+	var/obj/machinery/hologram/holopad/T = locate(/obj/machinery/hologram/holopad) in src.eyeobj.loc
+	if(istype(T) && T.hologram && T.master==src)//If there is a hologram and its master is the user.
 		var/message_a = say_quote(message)
 
 		//Human-like, sorta, heard by those who understand humans.

code/modules/power/apc.dm

@@ -744,6 +744,8 @@
 	if (user.stat)
 		user << "\red You must be conscious to use this [src]!"
 		return 0
+	if(!user.client)
+		return 0
 	if ( ! (istype(user, /mob/living/carbon/human) || \
 			istype(user, /mob/living/silicon) || \
 			istype(user, /mob/living/carbon/monkey) /*&& ticker && ticker.mode.name == "monkey"*/) )