Revert "PLASE"

This reverts commit 8af225e6e3.

code/_onclick/adjacent.dm

@@ -0,0 +1,105 @@
+/*
+	Adjacency proc for determining touch range
+
+	This is mostly to determine if a user can enter a square for the purposes of touching something.
+	Examples include reaching a square diagonally or reaching something on the other side of a glass window.
+
+	This is calculated by looking for border items, or in the case of clicking diagonally from yourself, dense items.
+	This proc will NOT notice if you are trying to attack a window on the other side of a dense object in its turf.  There is a window helper for that.
+
+	Note that in all cases the neighbor is handled simply; this is usually the user's mob, in which case it is up to you
+	to check that the mob is not inside of something
+*/
+/atom/proc/Adjacent(atom/neighbor) // basic inheritance, unused
+	return 0
+
+// Not a sane use of the function and (for now) indicative of an error elsewhere
+/area/Adjacent(var/atom/neighbor)
+	CRASH("Call to /area/Adjacent(), unimplemented proc")
+
+
+/*
+	Adjacency (to turf):
+	* If you are in the same turf, always true
+	* If you are vertically/horizontally adjacent, ensure there are no border objects
+	* If you are diagonally adjacent, ensure you can pass through at least one of the mutually adjacent square.
+		* Passing through in this case ignores anything with the LETPASSTHROW pass flag, such as tables, racks, and morgue trays.
+*/
+/turf/Adjacent(atom/neighbor, atom/target = null, atom/movable/mover = null)
+	var/turf/T0 = get_turf(neighbor)
+
+	if(T0 == src) //same turf
+		return TRUE
+
+	if(get_dist(src, T0) > 1 || z != T0.z) //too far
+		return FALSE
+
+	// Non diagonal case
+	if(T0.x == x || T0.y == y)
+		// Check for border blockages
+		return T0.ClickCross(get_dir(T0,src), border_only = 1, target_atom = target, mover = mover) && src.ClickCross(get_dir(src,T0), border_only = 1, target_atom = target, mover = mover)
+
+	// Diagonal case
+	var/in_dir = get_dir(T0,src) // eg. northwest (1+8) = 9 (00001001)
+	var/d1 = in_dir&3		     // eg. north	  (1+8)&3 (0000 0011) = 1 (0000 0001)
+	var/d2 = in_dir&12			 // eg. west	  (1+8)&12 (0000 1100) = 8 (0000 1000)
+
+	for(var/d in list(d1,d2))
+		if(!T0.ClickCross(d, border_only = 1, target_atom = target, mover = mover))
+			continue // could not leave T0 in that direction
+
+		var/turf/T1 = get_step(T0,d)
+		if(!T1 || T1.density)
+			continue
+		if(!T1.ClickCross(get_dir(T1,src), border_only = 0, target_atom = target, mover = mover) || !T1.ClickCross(get_dir(T1,T0), border_only = 0, target_atom = target, mover = mover))
+			continue // couldn't enter or couldn't leave T1
+
+		if(!src.ClickCross(get_dir(src,T1), border_only = 1, target_atom = target, mover = mover))
+			continue // could not enter src
+
+		return 1 // we don't care about our own density
+
+	return 0
+
+/*
+	Adjacency (to anything else):
+	* Must be on a turf
+*/
+/atom/movable/Adjacent(var/atom/neighbor)
+	if(neighbor == loc)
+		return TRUE
+	var/turf/T = loc
+	if(!istype(T))
+		return FALSE
+	if(T.Adjacent(neighbor, neighbor, src))
+		return TRUE
+	return FALSE
+
+// This is necessary for storage items not on your person.
+/obj/item/Adjacent(var/atom/neighbor, var/recurse = 1)
+	if(neighbor == loc)
+		return 1
+	if(isitem(loc))
+		if(recurse > 0)
+			return loc.Adjacent(neighbor,recurse - 1)
+		return 0
+	return ..()
+
+/*
+	This checks if you there is uninterrupted airspace between that turf and this one.
+	This is defined as any dense ON_BORDER_1 object, or any dense object without LETPASSTHROW.
+	The border_only flag allows you to not objects (for source and destination squares)
+*/
+/turf/proc/ClickCross(target_dir, border_only, target_atom = null, atom/movable/mover = null)
+	for(var/obj/O in src)
+		if((mover && O.CanPass(mover,get_step(src,target_dir))) || (!mover && !O.density))
+			continue
+		if(O == target_atom || O == mover || (O.pass_flags & LETPASSTHROW)) //check if there's a dense object present on the turf
+			continue // LETPASSTHROW is used for anything you can click through (or the firedoor special case, see above)
+
+		if( O.flags_1&ON_BORDER_1) // windows are on border, check them first
+			if( O.dir & target_dir || O.dir & (O.dir-1) ) // full tile windows are just diagonals mechanically
+				return 0								  //O.dir&(O.dir-1) is false for any cardinal direction, but true for diagonal ones
+		else if( !border_only ) // dense, not on border, cannot pass over
+			return 0
+	return 1

code/_onclick/click.dm

@@ -0,0 +1,522 @@
+/*
+	Click code cleanup
+	~Sayu
+*/
+
+// 1 decisecond click delay (above and beyond mob/next_move)
+//This is mainly modified by click code, to modify click delays elsewhere, use next_move and changeNext_move()
+/mob/var/next_click	= 0
+
+// THESE DO NOT EFFECT THE BASE 1 DECISECOND DELAY OF NEXT_CLICK
+/mob/var/next_move_adjust = 0 //Amount to adjust action/click delays by, + or -
+/mob/var/next_move_modifier = 1 //Value to multiply action/click delays by
+
+
+//Delays the mob's next click/action by num deciseconds
+// eg: 10-3 = 7 deciseconds of delay
+// eg: 10*0.5 = 5 deciseconds of delay
+// DOES NOT EFFECT THE BASE 1 DECISECOND DELAY OF NEXT_CLICK
+
+/mob/proc/changeNext_move(num)
+	next_move = world.time + ((num+next_move_adjust)*next_move_modifier)
+
+/mob/living/changeNext_move(num)
+	var/mod = next_move_modifier
+	var/adj = next_move_adjust
+	for(var/i in status_effects)
+		var/datum/status_effect/S = i
+		mod *= S.nextmove_modifier()
+		adj += S.nextmove_adjust()
+	next_move = world.time + ((num + adj)*mod)
+
+/*
+	Before anything else, defer these calls to a per-mobtype handler.  This allows us to
+	remove istype() spaghetti code, but requires the addition of other handler procs to simplify it.
+
+	Alternately, you could hardcode every mob's variation in a flat ClickOn() proc; however,
+	that's a lot of code duplication and is hard to maintain.
+
+	Note that this proc can be overridden, and is in the case of screen objects.
+*/
+/atom/Click(location,control,params)
+	if(flags_1 & INITIALIZED_1)
+		SEND_SIGNAL(src, COMSIG_CLICK, location, control, params, usr)
+		usr.ClickOn(src, params)
+
+/atom/DblClick(location,control,params)
+	if(flags_1 & INITIALIZED_1)
+		usr.DblClickOn(src,params)
+
+/atom/MouseWheel(delta_x,delta_y,location,control,params)
+	if(flags_1 & INITIALIZED_1)
+		usr.MouseWheelOn(src, delta_x, delta_y, params)
+
+/*
+	Standard mob ClickOn()
+	Handles exceptions: Buildmode, middle click, modified clicks, mech actions
+
+	After that, mostly just check your state, check whether you're holding an item,
+	check whether you're adjacent to the target, then pass off the click to whoever
+	is receiving it.
+	The most common are:
+	* mob/UnarmedAttack(atom,adjacent) - used here only when adjacent, with no item in hand; in the case of humans, checks gloves
+	* atom/attackby(item,user) - used only when adjacent
+	* item/afterattack(atom,user,adjacent,params) - used both ranged and adjacent
+	* mob/RangedAttack(atom,params) - used only ranged, only used for tk and laser eyes but could be changed
+*/
+/mob/proc/ClickOn( atom/A, params )
+	if(world.time <= next_click)
+		return
+	next_click = world.time + world.tick_lag
+
+	if(check_click_intercept(params,A))
+		return
+
+	if(notransform)
+		return
+
+	var/list/modifiers = params2list(params)
+	if(modifiers["shift"] && modifiers["middle"])
+		ShiftMiddleClickOn(A)
+		return
+	if(modifiers["shift"] && modifiers["ctrl"])
+		CtrlShiftClickOn(A)
+		return
+	if(modifiers["middle"])
+		MiddleClickOn(A)
+		return
+	if(modifiers["shift"] && (client && client.show_popup_menus || modifiers["right"])) //CIT CHANGE - makes shift-click examine use right click instead of left click in combat mode
+		ShiftClickOn(A)
+		return
+	if(modifiers["alt"]) // alt and alt-gr (rightalt)
+		AltClickOn(A)
+		return
+	if(modifiers["ctrl"])
+		CtrlClickOn(A)
+		return
+
+	if(modifiers["right"]) //CIT CHANGE - allows right clicking to perform actions
+		RightClickOn(A,params) //CIT CHANGE - ditto
+		return //CIT CHANGE - ditto
+
+	if(incapacitated(ignore_restraints = 1))
+		return
+
+	face_atom(A)
+
+	if(next_move > world.time) // in the year 2000...
+		return
+
+	if(!modifiers["catcher"] && A.IsObscured())
+		return
+
+	if(ismecha(loc))
+		var/obj/mecha/M = loc
+		return M.click_action(A,src,params)
+
+	if(restrained())
+		changeNext_move(CLICK_CD_HANDCUFFED)   //Doing shit in cuffs shall be vey slow
+		RestrainedClickOn(A)
+		return
+
+	if(in_throw_mode)
+		throw_item(A)
+		return
+
+	var/obj/item/W = get_active_held_item()
+
+	if(W == A)
+		W.attack_self(src)
+		update_inv_hands()
+		return
+
+	//These are always reachable.
+	//User itself, current loc, and user inventory
+	if(A in DirectAccess())
+		if(W)
+			W.melee_attack_chain(src, A, params)
+		else
+			if(ismob(A))
+				changeNext_move(CLICK_CD_MELEE)
+			UnarmedAttack(A)
+		return
+
+	//Can't reach anything else in lockers or other weirdness
+	if(!loc.AllowClick())
+		return
+
+	//Standard reach turf to turf or reaching inside storage
+	if(CanReach(A,W))
+		if(W)
+			W.melee_attack_chain(src, A, params)
+		else
+			if(ismob(A))
+				changeNext_move(CLICK_CD_MELEE)
+			UnarmedAttack(A,1)
+	else
+		if(W)
+			W.afterattack(A,src,0,params)
+		else
+			RangedAttack(A,params)
+
+//Is the atom obscured by a PREVENT_CLICK_UNDER_1 object above it
+/atom/proc/IsObscured()
+	if(!isturf(loc)) //This only makes sense for things directly on turfs for now
+		return FALSE
+	var/turf/T = get_turf_pixel(src)
+	if(!T)
+		return FALSE
+	for(var/atom/movable/AM in T)
+		if(AM.flags_1 & PREVENT_CLICK_UNDER_1 && AM.density && AM.layer > layer)
+			return TRUE
+	return FALSE
+
+/turf/IsObscured()
+	for(var/atom/movable/AM in src)
+		if(AM.flags_1 & PREVENT_CLICK_UNDER_1 && AM.density)
+			return TRUE
+	return FALSE
+
+/atom/movable/proc/CanReach(atom/ultimate_target, obj/item/tool, view_only = FALSE)
+	// A backwards depth-limited breadth-first-search to see if the target is
+	// logically "in" anything adjacent to us.
+	var/list/direct_access = DirectAccess()
+	var/depth = 1 + (view_only ? STORAGE_VIEW_DEPTH : INVENTORY_DEPTH)
+
+	var/list/closed = list()
+	var/list/checking = list(ultimate_target)
+	while (checking.len && depth > 0)
+		var/list/next = list()
+		--depth
+
+		for(var/atom/target in checking)  // will filter out nulls
+			if(closed[target] || isarea(target))  // avoid infinity situations
+				continue
+			closed[target] = TRUE
+			if(isturf(target) || isturf(target.loc) || (target in direct_access)) //Directly accessible atoms
+				if(Adjacent(target) || (tool && CheckToolReach(src, target, tool.reach))) //Adjacent or reaching attacks
+					return TRUE
+
+			if (!target.loc)
+				continue
+
+			if(!(SEND_SIGNAL(target.loc, COMSIG_ATOM_CANREACH, next) & COMPONENT_BLOCK_REACH) && target.loc.canReachInto(src, ultimate_target, next, view_only, tool))
+				next += target.loc
+
+		checking = next
+	return FALSE
+
+/atom/movable/proc/DirectAccess()
+	return list(src, loc)
+
+/mob/DirectAccess(atom/target)
+	return ..() + contents
+
+/mob/living/DirectAccess(atom/target)
+	return ..() + GetAllContents()
+
+//This is called reach into but it's called on the deepest things first so uh, make sure to account for that!
+/atom/proc/canReachInto(atom/user, atom/target, list/next, view_only, obj/item/tool)
+	return TRUE
+
+/atom/proc/AllowClick()
+	return FALSE
+
+/turf/AllowClick()
+	return TRUE
+
+/proc/CheckToolReach(atom/movable/here, atom/movable/there, reach)
+	if(!here || !there)
+		return
+	switch(reach)
+		if(0)
+			return FALSE
+		if(1)
+			return FALSE //here.Adjacent(there)
+		if(2 to INFINITY)
+			var/obj/dummy = new(get_turf(here))
+			dummy.pass_flags |= PASSTABLE
+			dummy.invisibility = INVISIBILITY_ABSTRACT
+			for(var/i in 1 to reach) //Limit it to that many tries
+				var/turf/T = get_step(dummy, get_dir(dummy, there))
+				if(dummy.CanReach(there))
+					qdel(dummy)
+					return TRUE
+				if(!dummy.Move(T)) //we're blocked!
+					qdel(dummy)
+					return
+			qdel(dummy)
+
+// Default behavior: ignore double clicks (the second click that makes the doubleclick call already calls for a normal click)
+/mob/proc/DblClickOn(atom/A, params)
+	return
+
+
+/*
+	Translates into attack_hand, etc.
+
+	Note: proximity_flag here is used to distinguish between normal usage (flag=1),
+	and usage when clicking on things telekinetically (flag=0).  This proc will
+	not be called at ranged except with telekinesis.
+
+	proximity_flag is not currently passed to attack_hand, and is instead used
+	in human click code to allow glove touches only at melee range.
+*/
+/mob/proc/UnarmedAttack(atom/A, proximity_flag)
+	if(ismob(A))
+		changeNext_move(CLICK_CD_MELEE)
+	return
+
+/*
+	Ranged unarmed attack:
+
+	This currently is just a default for all mobs, involving
+	laser eyes and telekinesis.  You could easily add exceptions
+	for things like ranged glove touches, spitting alien acid/neurotoxin,
+	animals lunging, etc.
+*/
+/mob/proc/RangedAttack(atom/A, params)
+	SEND_SIGNAL(src, COMSIG_MOB_ATTACK_RANGED, A, params)
+/*
+	Restrained ClickOn
+
+	Used when you are handcuffed and click things.
+	Not currently used by anything but could easily be.
+*/
+/mob/proc/RestrainedClickOn(atom/A)
+	return
+
+/*
+	Middle click
+	Only used for swapping hands
+*/
+/mob/proc/MiddleClickOn(atom/A)
+	return
+
+/mob/living/carbon/MiddleClickOn(atom/A)
+	if(!stat && mind && iscarbon(A) && A != src)
+		var/datum/antagonist/changeling/C = mind.has_antag_datum(/datum/antagonist/changeling)
+		if(C && C.chosen_sting)
+			C.chosen_sting.try_to_sting(src,A)
+			next_click = world.time + 5
+			return
+	swap_hand()
+
+/mob/living/simple_animal/drone/MiddleClickOn(atom/A)
+	swap_hand()
+
+// In case of use break glass
+/*
+/atom/proc/MiddleClick(mob/M as mob)
+	return
+*/
+
+/*
+	Shift click
+	For most mobs, examine.
+	This is overridden in ai.dm
+*/
+/mob/proc/ShiftClickOn(atom/A)
+	A.ShiftClick(src)
+	return
+/atom/proc/ShiftClick(mob/user)
+	SEND_SIGNAL(src, COMSIG_CLICK_SHIFT, user)
+	user.examinate(src)
+	return
+
+/*
+	Ctrl click
+	For most objects, pull
+*/
+
+/mob/proc/CtrlClickOn(atom/A)
+	A.CtrlClick(src)
+	return
+
+/atom/proc/CtrlClick(mob/user)
+	SEND_SIGNAL(src, COMSIG_CLICK_CTRL, user)
+	var/mob/living/ML = user
+	if(istype(ML))
+		ML.pulled(src)
+
+/mob/living/carbon/human/CtrlClick(mob/user)
+	if(ishuman(user) && Adjacent(user) && !user.incapacitated())
+		if(world.time < user.next_move)
+			return FALSE
+		var/mob/living/carbon/human/H = user
+		H.dna.species.grab(H, src, H.mind.martial_art)
+		H.changeNext_move(CLICK_CD_MELEE)
+	else
+		..()
+/*
+	Alt click
+	Unused except for AI
+*/
+/mob/proc/AltClickOn(atom/A)
+	A.AltClick(src)
+	return
+
+/mob/living/carbon/AltClickOn(atom/A)
+	if(!stat && mind && iscarbon(A) && A != src)
+		var/datum/antagonist/changeling/C = mind.has_antag_datum(/datum/antagonist/changeling)
+		if(C && C.chosen_sting)
+			C.chosen_sting.try_to_sting(src,A)
+			next_click = world.time + 5
+			return
+	..()
+
+/atom/proc/AltClick(mob/user)
+	SEND_SIGNAL(src, COMSIG_CLICK_ALT, user)
+	var/turf/T = get_turf(src)
+	if(T && user.TurfAdjacent(T))
+		user.listed_turf = T
+		user.client.statpanel = T.name
+
+// Use this instead of /mob/proc/AltClickOn(atom/A) where you only want turf content listing without additional atom alt-click interaction
+/atom/proc/AltClickNoInteract(mob/user, atom/A)
+	var/turf/T = get_turf(A)
+	if(T && user.TurfAdjacent(T))
+		user.listed_turf = T
+		user.client.statpanel = T.name
+
+/mob/proc/TurfAdjacent(turf/T)
+	return T.Adjacent(src)
+
+/*
+	Control+Shift click
+	Unused except for AI
+*/
+/mob/proc/CtrlShiftClickOn(atom/A)
+	A.CtrlShiftClick(src)
+	return
+
+/mob/proc/ShiftMiddleClickOn(atom/A)
+	src.pointed(A)
+	return
+
+/atom/proc/CtrlShiftClick(mob/user)
+	SEND_SIGNAL(src, COMSIG_CLICK_CTRL_SHIFT)
+	return
+
+/*
+	Misc helpers
+
+	Laser Eyes: as the name implies, handles this since nothing else does currently
+	face_atom: turns the mob towards what you clicked on
+*/
+/mob/proc/LaserEyes(atom/A, params)
+	return
+
+/mob/living/LaserEyes(atom/A, params)
+	changeNext_move(CLICK_CD_RANGE)
+
+	var/obj/item/projectile/beam/LE = new /obj/item/projectile/beam( loc )
+	LE.icon = 'icons/effects/genetics.dmi'
+	LE.icon_state = "eyelasers"
+	playsound(usr.loc, 'sound/weapons/taser2.ogg', 75, 1)
+
+	LE.firer = src
+	LE.def_zone = get_organ_target()
+	LE.preparePixelProjectile(A, src, params)
+	LE.fire()
+
+// Simple helper to face what you clicked on, in case it should be needed in more than one place
+/mob/proc/face_atom(atom/A)
+	if( buckled || stat != CONSCIOUS || !A || !x || !y || !A.x || !A.y )
+		return
+	var/dx = A.x - x
+	var/dy = A.y - y
+	if(!dx && !dy) // Wall items are graphically shifted but on the floor
+		if(A.pixel_y > 16)
+			setDir(NORTH)
+		else if(A.pixel_y < -16)
+			setDir(SOUTH)
+		else if(A.pixel_x > 16)
+			setDir(EAST)
+		else if(A.pixel_x < -16)
+			setDir(WEST)
+		return
+
+	if(abs(dx) < abs(dy))
+		if(dy > 0)
+			setDir(NORTH)
+		else
+			setDir(SOUTH)
+	else
+		if(dx > 0)
+			setDir(EAST)
+		else
+			setDir(WEST)
+
+//debug
+/obj/screen/proc/scale_to(x1,y1)
+	if(!y1)
+		y1 = x1
+	var/matrix/M = new
+	M.Scale(x1,y1)
+	transform = M
+
+/obj/screen/click_catcher
+	icon = 'icons/mob/screen_gen.dmi'
+	icon_state = "catcher"
+	plane = CLICKCATCHER_PLANE
+	mouse_opacity = MOUSE_OPACITY_OPAQUE
+	screen_loc = "CENTER"
+
+#define MAX_SAFE_BYOND_ICON_SCALE_TILES (MAX_SAFE_BYOND_ICON_SCALE_PX / world.icon_size)
+#define MAX_SAFE_BYOND_ICON_SCALE_PX (33 * 32)			//Not using world.icon_size on purpose.
+
+/obj/screen/click_catcher/proc/UpdateGreed(view_size_x = 15, view_size_y = 15)
+	var/icon/newicon = icon('icons/mob/screen_gen.dmi', "catcher")
+	var/ox = min(MAX_SAFE_BYOND_ICON_SCALE_TILES, view_size_x)
+	var/oy = min(MAX_SAFE_BYOND_ICON_SCALE_TILES, view_size_y)
+	var/px = view_size_x * world.icon_size
+	var/py = view_size_y * world.icon_size
+	var/sx = min(MAX_SAFE_BYOND_ICON_SCALE_PX, px)
+	var/sy = min(MAX_SAFE_BYOND_ICON_SCALE_PX, py)
+	newicon.Scale(sx, sy)
+	icon = newicon
+	screen_loc = "CENTER-[(ox-1)*0.5],CENTER-[(oy-1)*0.5]"
+	var/matrix/M = new
+	M.Scale(px/sx, py/sy)
+	transform = M
+
+/obj/screen/click_catcher/Click(location, control, params)
+	var/list/modifiers = params2list(params)
+	if(modifiers["middle"] && iscarbon(usr))
+		var/mob/living/carbon/C = usr
+		C.swap_hand()
+	else
+		var/turf/T = params2turf(modifiers["screen-loc"], get_turf(usr.client ? usr.client.eye : usr), usr.client)
+		params += "&catcher=1"
+		if(T)
+			T.Click(location, control, params)
+	. = 1
+
+/* MouseWheelOn */
+
+/mob/proc/MouseWheelOn(atom/A, delta_x, delta_y, params)
+	return
+
+/mob/dead/observer/MouseWheelOn(atom/A, delta_x, delta_y, params)
+	var/list/modifier = params2list(params)
+	if(modifier["shift"])
+		var/view = 0
+		if(delta_y > 0)
+			view = -1
+		else
+			view = 1
+		add_view_range(view)
+
+/mob/proc/check_click_intercept(params,A)
+	//Client level intercept
+	if(client && client.click_intercept)
+		if(call(client.click_intercept, "InterceptClickOn")(src, params, A))
+			return TRUE
+
+	//Mob level intercept
+	if(click_intercept)
+		if(call(click_intercept, "InterceptClickOn")(src, params, A))
+			return TRUE
+
+	return FALSE

code/_onclick/hud/_defines.dm

@@ -0,0 +1,161 @@
+/*
+	These defines specificy screen locations.  For more information, see the byond documentation on the screen_loc var.
+
+	The short version:
+
+	Everything is encoded as strings because apparently that's how Byond rolls.
+
+	"1,1" is the bottom left square of the user's screen.  This aligns perfectly with the turf grid.
+	"1:2,3:4" is the square (1,3) with pixel offsets (+2, +4); slightly right and slightly above the turf grid.
+	Pixel offsets are used so you don't perfectly hide the turf under them, that would be crappy.
+
+	In addition, the keywords NORTH, SOUTH, EAST, WEST and CENTER can be used to represent their respective
+	screen borders. NORTH-1, for example, is the row just below the upper edge. Useful if you want your
+	UI to scale with screen size.
+
+	The size of the user's screen is defined by client.view (indirectly by world.view), in our case "15x15".
+	Therefore, the top right corner (except during admin shenanigans) is at "15,15"
+*/
+
+//Lower left, persistent menu
+#define ui_inventory "WEST:6,SOUTH:5"
+
+//Middle left indicators
+#define ui_lingchemdisplay "WEST,CENTER-1:15"
+#define ui_lingstingdisplay "WEST:6,CENTER-3:11"
+
+#define ui_devilsouldisplay "WEST:6,CENTER-1:15"
+
+//Lower center, persistent menu
+#define ui_sstore1 "CENTER-5:10,SOUTH:5"
+#define ui_id "CENTER-4:12,SOUTH:5"
+#define ui_belt "CENTER-3:14,SOUTH:5"
+#define ui_back "CENTER-2:14,SOUTH:5"
+
+/proc/ui_hand_position(i) //values based on old hand ui positions (CENTER:-/+16,SOUTH:5)
+	var/x_off = -(!(i % 2))
+	var/y_off = round((i-1) / 2)
+	return"CENTER+[x_off]:16,SOUTH+[y_off]:5"
+
+/proc/ui_equip_position(mob/M)
+	var/y_off = round((M.held_items.len-1) / 2) //values based on old equip ui position (CENTER: +/-16,SOUTH+1:5)
+	return "CENTER:-16,SOUTH+[y_off+1]:5"
+
+/proc/ui_swaphand_position(mob/M, which = 1) //values based on old swaphand ui positions (CENTER: +/-16,SOUTH+1:5)
+	var/x_off = which == 1 ? -1 : 0
+	var/y_off = round((M.held_items.len-1) / 2)
+	return "CENTER+[x_off]:16,SOUTH+[y_off+1]:5"
+
+#define ui_storage1 "CENTER+1:18,SOUTH:5"
+#define ui_storage2 "CENTER+2:20,SOUTH:5"
+
+#define ui_borg_sensor "CENTER-3:15, SOUTH:5"		//borgs
+#define ui_borg_lamp "CENTER-4:15, SOUTH:5"			//borgs
+#define ui_borg_thrusters "CENTER-5:15, SOUTH:5"	//borgs
+#define ui_inv1 "CENTER-2:16,SOUTH:5"				//borgs
+#define ui_inv2 "CENTER-1  :16,SOUTH:5"				//borgs
+#define ui_inv3 "CENTER  :16,SOUTH:5"				//borgs
+#define ui_borg_module "CENTER+1:16,SOUTH:5"		//borgs
+#define ui_borg_store "CENTER+2:16,SOUTH:5"			//borgs
+#define ui_borg_camera "CENTER+3:21,SOUTH:5"		//borgs
+#define ui_borg_album "CENTER+4:21,SOUTH:5"			//borgs
+#define ui_borg_language_menu "EAST-1:27,SOUTH+2:8"	//borgs
+
+#define ui_monkey_head "CENTER-5:13,SOUTH:5"	//monkey
+#define ui_monkey_mask "CENTER-4:14,SOUTH:5"	//monkey
+#define ui_monkey_neck "CENTER-3:15,SOUTH:5"	//monkey
+#define ui_monkey_back "CENTER-2:16,SOUTH:5"	//monkey
+
+//#define ui_alien_storage_l "CENTER-2:14,SOUTH:5"//alien
+#define ui_alien_storage_r "CENTER+1:18,SOUTH:5"//alien
+#define ui_alien_language_menu "EAST-3:26,SOUTH:5" //alien
+
+#define ui_drone_drop "CENTER+1:18,SOUTH:5"     //maintenance drones
+#define ui_drone_pull "CENTER+2:2,SOUTH:5"      //maintenance drones
+#define ui_drone_storage "CENTER-2:14,SOUTH:5"  //maintenance drones
+#define ui_drone_head "CENTER-3:14,SOUTH:5"     //maintenance drones
+
+//Lower right, persistent menu
+#define ui_drop_throw "EAST-1:28,SOUTH+1:7"
+#define ui_pull_resist "EAST-2:26,SOUTH+1:7"
+#define ui_movi "EAST-2:26,SOUTH:5"
+#define ui_sprintbufferloc "EAST-2:26,SOUTH:18"
+#define ui_acti "EAST-3:24,SOUTH:5"
+#define ui_zonesel "EAST-1:28,SOUTH:5"
+#define ui_acti_alt "EAST-1:28,SOUTH:5"	//alternative intent switcher for when the interface is hidden (F12)
+#define ui_crafting	"EAST-5:20,SOUTH:5"//CIT CHANGE - moves this over one tile to accommodate for combat mode toggle
+#define ui_building "EAST-5:20,SOUTH:21"//CIT CHANGE - ditto
+#define ui_language_menu "EAST-5:4,SOUTH:21"//CIT CHANGE - ditto
+#define ui_voremode	"EAST-5:20,SOUTH:5"
+
+#define ui_borg_pull "EAST-2:26,SOUTH+1:7"
+#define ui_borg_radio "EAST-1:28,SOUTH+1:7"
+#define ui_borg_intents "EAST-2:26,SOUTH:5"
+
+
+//Upper-middle right (alerts)
+#define ui_alert1 "EAST-1:28,CENTER+5:27"
+#define ui_alert2 "EAST-1:28,CENTER+4:25"
+#define ui_alert3 "EAST-1:28,CENTER+3:23"
+#define ui_alert4 "EAST-1:28,CENTER+2:21"
+#define ui_alert5 "EAST-1:28,CENTER+1:19"
+
+
+//Middle right (status indicators)
+#define ui_healthdoll "EAST-1:28,CENTER-2:13"
+#define ui_health "EAST-1:28,CENTER-1:15"
+#define ui_internal "EAST-1:28,CENTER+1:19"//CIT CHANGE - moves internal icon up a little bit to accommodate for the stamina meter
+#define ui_mood "EAST-1:28,CENTER-3:10"
+
+//borgs
+#define ui_borg_health "EAST-1:28,CENTER-1:15"		//borgs have the health display where humans have the pressure damage indicator.
+
+//aliens
+#define ui_alien_health "EAST,CENTER-1:15"	//aliens have the health display where humans have the pressure damage indicator.
+#define ui_alienplasmadisplay "EAST,CENTER-2:15"
+#define ui_alien_queen_finder "EAST,CENTER-3:15"
+
+//constructs
+#define ui_construct_pull "EAST,CENTER-2:15"
+#define ui_construct_health "EAST,CENTER:15"  //same as borgs and humans
+
+// AI
+
+#define ui_ai_core "SOUTH:6,WEST"
+#define ui_ai_camera_list "SOUTH:6,WEST+1"
+#define ui_ai_track_with_camera "SOUTH:6,WEST+2"
+#define ui_ai_camera_light "SOUTH:6,WEST+3"
+#define ui_ai_crew_monitor "SOUTH:6,WEST+4"
+#define ui_ai_crew_manifest "SOUTH:6,WEST+5"
+#define ui_ai_alerts "SOUTH:6,WEST+6"
+#define ui_ai_announcement "SOUTH:6,WEST+7"
+#define ui_ai_shuttle "SOUTH:6,WEST+8"
+#define ui_ai_state_laws "SOUTH:6,WEST+9"
+#define ui_ai_pda_send "SOUTH:6,WEST+10"
+#define ui_ai_pda_log "SOUTH:6,WEST+11"
+#define ui_ai_take_picture "SOUTH:6,WEST+12"
+#define ui_ai_view_images "SOUTH:6,WEST+13"
+#define ui_ai_sensor "SOUTH:6,WEST+14"
+#define ui_ai_multicam "SOUTH+1:6,WEST+13"
+#define ui_ai_add_multicam "SOUTH+1:6,WEST+14"
+
+//Pop-up inventory
+#define ui_shoes "WEST+1:8,SOUTH:5"
+
+#define ui_iclothing "WEST:6,SOUTH+1:7"
+#define ui_oclothing "WEST+1:8,SOUTH+1:7"
+#define ui_gloves "WEST+2:10,SOUTH+1:7"
+
+#define ui_glasses "WEST:6,SOUTH+3:11"
+#define ui_mask "WEST+1:8,SOUTH+2:9"
+#define ui_ears "WEST+2:10,SOUTH+2:9"
+#define ui_neck "WEST:6,SOUTH+2:9"
+#define ui_head "WEST+1:8,SOUTH+3:11"
+
+//Ghosts
+
+#define ui_ghost_jumptomob "SOUTH:6,CENTER-2:24"
+#define ui_ghost_orbit "SOUTH:6,CENTER-1:24"
+#define ui_ghost_reenter_corpse "SOUTH:6,CENTER:24"
+#define ui_ghost_teleport "SOUTH:6,CENTER+1:24"
+#define ui_ghost_pai "SOUTH: 6, CENTER+2:24"

code/_onclick/hud/plane_master.dm

@@ -0,0 +1,84 @@
+/obj/screen/plane_master
+	screen_loc = "CENTER"
+	icon_state = "blank"
+	appearance_flags = PLANE_MASTER|NO_CLIENT_COLOR
+	blend_mode = BLEND_OVERLAY
+	var/show_alpha = 255
+	var/hide_alpha = 0
+
+/obj/screen/plane_master/proc/Show(override)
+	alpha = override || show_alpha
+
+/obj/screen/plane_master/proc/Hide(override)
+	alpha = override || hide_alpha
+
+//Why do plane masters need a backdrop sometimes? Read https://secure.byond.com/forum/?post=2141928
+//Trust me, you need one. Period. If you don't think you do, you're doing something extremely wrong.
+/obj/screen/plane_master/proc/backdrop(mob/mymob)
+
+/obj/screen/plane_master/openspace
+	name = "open space plane master"
+	plane = FLOOR_OPENSPACE_PLANE
+	appearance_flags = PLANE_MASTER
+	blend_mode = BLEND_MULTIPLY
+	alpha = 255
+
+/obj/screen/plane_master/openspace/backdrop(mob/mymob)
+	filters = list()
+	filters += filter(type = "drop_shadow", color = "#04080FAA", size = -10)
+	filters += filter(type = "drop_shadow", color = "#04080FAA", size = -15)
+	filters += filter(type = "drop_shadow", color = "#04080FAA", size = -20)
+
+/obj/screen/plane_master/proc/outline(_size, _color)
+	filters += filter(type = "outline", size = _size, color = _color)
+
+/obj/screen/plane_master/proc/shadow(_size, _offset = 0, _x = 0, _y = 0, _color = "#04080FAA")
+	filters += filter(type = "drop_shadow", x = _x, y = _y, color = _color, size = _size, offset = _offset)
+
+/obj/screen/plane_master/proc/clear_filters()
+	filters = list()
+
+/obj/screen/plane_master/floor
+	name = "floor plane master"
+	plane = FLOOR_PLANE
+	appearance_flags = PLANE_MASTER
+	blend_mode = BLEND_OVERLAY
+
+/obj/screen/plane_master/game_world
+	name = "game world plane master"
+	plane = GAME_PLANE
+	appearance_flags = PLANE_MASTER //should use client color
+	blend_mode = BLEND_OVERLAY
+
+/obj/screen/plane_master/game_world/backdrop(mob/mymob)
+	if(istype(mymob) && mymob.client && mymob.client.prefs && mymob.client.prefs.ambientocclusion)
+		add_filter("ambient_occlusion", 0, AMBIENT_OCCLUSION)
+	else
+		remove_filter("ambient_occlusion")
+	update_filters()
+
+/obj/screen/plane_master/lighting
+	name = "lighting plane master"
+	plane = LIGHTING_PLANE
+	blend_mode = BLEND_MULTIPLY
+	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
+
+/obj/screen/plane_master/parallax
+	name = "parallax plane master"
+	plane = PLANE_SPACE_PARALLAX
+	blend_mode = BLEND_MULTIPLY
+	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
+
+/obj/screen/plane_master/parallax_white
+	name = "parallax whitifier plane master"
+	plane = PLANE_SPACE
+
+/obj/screen/plane_master/lighting/backdrop(mob/mymob)
+	mymob.overlay_fullscreen("lighting_backdrop_lit", /obj/screen/fullscreen/lighting_backdrop/lit)
+	mymob.overlay_fullscreen("lighting_backdrop_unlit", /obj/screen/fullscreen/lighting_backdrop/unlit)
+
+/obj/screen/plane_master/camera_static
+	name = "camera static plane master"
+	plane = CAMERA_STATIC_PLANE
+	appearance_flags = PLANE_MASTER
+	blend_mode = BLEND_OVERLAY

code/_onclick/hud/robot.dm

@@ -0,0 +1,292 @@
+/obj/screen/robot
+	icon = 'icons/mob/screen_cyborg.dmi'
+
+/obj/screen/robot/module
+	name = "cyborg module"
+	icon_state = "nomod"
+
+/obj/screen/robot/Click()
+	if(isobserver(usr))
+		return 1
+
+/obj/screen/robot/module/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	if(R.module.type != /obj/item/robot_module)
+		R.hud_used.toggle_show_robot_modules()
+		return 1
+	R.pick_module()
+
+/obj/screen/robot/module1
+	name = "module1"
+	icon_state = "inv1"
+
+/obj/screen/robot/module1/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.toggle_module(1)
+
+/obj/screen/robot/module2
+	name = "module2"
+	icon_state = "inv2"
+
+/obj/screen/robot/module2/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.toggle_module(2)
+
+/obj/screen/robot/module3
+	name = "module3"
+	icon_state = "inv3"
+
+/obj/screen/robot/module3/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.toggle_module(3)
+
+/obj/screen/robot/radio
+	name = "radio"
+	icon_state = "radio"
+
+/obj/screen/robot/radio/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.radio.interact(R)
+
+/obj/screen/robot/store
+	name = "store"
+	icon_state = "store"
+
+/obj/screen/robot/store/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.uneq_active()
+
+/obj/screen/robot/lamp
+	name = "headlamp"
+	icon_state = "lamp0"
+
+/obj/screen/robot/lamp/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.control_headlamp()
+
+/obj/screen/robot/thrusters
+	name = "ion thrusters"
+	icon_state = "ionpulse0"
+
+/obj/screen/robot/thrusters/Click()
+	if(..())
+		return
+	var/mob/living/silicon/robot/R = usr
+	R.toggle_ionpulse()
+
+/obj/screen/robot/sensors
+	name = "Sensor Augmentation"
+	icon_state = "cyborg_sensor"
+
+/obj/screen/robot/sensors/Click()
+	if(..())
+		return
+	var/mob/living/silicon/S = usr
+	S.toggle_sensors()
+
+/obj/screen/robot/language_menu
+	name = "silicon language selection"
+	icon_state = "talk_wheel"
+
+/obj/screen/robot/language_menu/Click()
+	if(..())
+		return
+	var/mob/living/silicon/S = usr
+	S.open_language_menu(usr)
+
+/datum/hud/robot
+	ui_style = 'icons/mob/screen_cyborg.dmi'
+
+/datum/hud/robot/New(mob/owner)
+	..()
+	var/mob/living/silicon/robot/mymobR = mymob
+	var/obj/screen/using
+
+	using = new/obj/screen/robot/language_menu
+	using.screen_loc = ui_borg_language_menu
+	static_inventory += using
+
+//Radio
+	using = new /obj/screen/robot/radio()
+	using.screen_loc = ui_borg_radio
+	static_inventory += using
+
+//Module select
+	using = new /obj/screen/robot/module1()
+	using.screen_loc = ui_inv1
+	static_inventory += using
+	mymobR.inv1 = using
+
+	using = new /obj/screen/robot/module2()
+	using.screen_loc = ui_inv2
+	static_inventory += using
+	mymobR.inv2 = using
+
+	using = new /obj/screen/robot/module3()
+	using.screen_loc = ui_inv3
+	static_inventory += using
+	mymobR.inv3 = using
+
+//End of module select
+
+//Photography stuff
+	using = new /obj/screen/ai/image_take()
+	using.screen_loc = ui_borg_camera
+	static_inventory += using
+
+	using = new /obj/screen/ai/image_view()
+	using.screen_loc = ui_borg_album
+	static_inventory += using
+
+//Sec/Med HUDs
+	using = new /obj/screen/robot/sensors()
+	using.screen_loc = ui_borg_sensor
+	static_inventory += using
+
+//Headlamp control
+	using = new /obj/screen/robot/lamp()
+	using.screen_loc = ui_borg_lamp
+	static_inventory += using
+	mymobR.lamp_button = using
+
+//Thrusters
+	using = new /obj/screen/robot/thrusters()
+	using.screen_loc = ui_borg_thrusters
+	static_inventory += using
+	mymobR.thruster_button = using
+
+//Intent
+	action_intent = new /obj/screen/act_intent/robot()
+	action_intent.icon_state = mymob.a_intent
+	static_inventory += action_intent
+
+//Health
+	healths = new /obj/screen/healths/robot()
+	infodisplay += healths
+
+//Installed Module
+	mymobR.hands = new /obj/screen/robot/module()
+	mymobR.hands.screen_loc = ui_borg_module
+	static_inventory += mymobR.hands
+
+//Store
+	module_store_icon = new /obj/screen/robot/store()
+	module_store_icon.screen_loc = ui_borg_store
+
+	pull_icon = new /obj/screen/pull()
+	pull_icon.icon = 'icons/mob/screen_cyborg.dmi'
+	pull_icon.update_icon(mymob)
+	pull_icon.screen_loc = ui_borg_pull
+	hotkeybuttons += pull_icon
+
+
+	zone_select = new /obj/screen/zone_sel/robot()
+	zone_select.update_icon(mymob)
+	static_inventory += zone_select
+
+
+/datum/hud/proc/toggle_show_robot_modules()
+	if(!iscyborg(mymob))
+		return
+
+	var/mob/living/silicon/robot/R = mymob
+
+	R.shown_robot_modules = !R.shown_robot_modules
+	update_robot_modules_display()
+
+/datum/hud/proc/update_robot_modules_display(mob/viewer)
+	if(!iscyborg(mymob))
+		return
+
+	var/mob/living/silicon/robot/R = mymob
+
+	var/mob/screenmob = viewer || R
+
+	if(!R.module)
+		return
+
+	if(!R.client)
+		return
+
+	if(R.shown_robot_modules && screenmob.hud_used.hud_shown)
+		//Modules display is shown
+		screenmob.client.screen += module_store_icon	//"store" icon
+
+		if(!R.module.modules)
+			to_chat(usr, "<span class='danger'>Selected module has no modules to select</span>")
+			return
+
+		if(!R.robot_modules_background)
+			return
+
+		var/display_rows = CEILING(length(R.module.get_inactive_modules()) / 8, 1)
+		R.robot_modules_background.screen_loc = "CENTER-4:16,SOUTH+1:7 to CENTER+3:16,SOUTH+[display_rows]:7"
+		screenmob.client.screen += R.robot_modules_background
+
+		var/x = -4	//Start at CENTER-4,SOUTH+1
+		var/y = 1
+
+		for(var/atom/movable/A in R.module.get_inactive_modules())
+			//Module is not currently active
+			screenmob.client.screen += A
+			if(x < 0)
+				A.screen_loc = "CENTER[x]:16,SOUTH+[y]:7"
+			else
+				A.screen_loc = "CENTER+[x]:16,SOUTH+[y]:7"
+			A.layer = ABOVE_HUD_LAYER
+			A.plane = ABOVE_HUD_PLANE
+
+			x++
+			if(x == 4)
+				x = -4
+				y++
+
+	else
+		//Modules display is hidden
+		screenmob.client.screen -= module_store_icon	//"store" icon
+
+		for(var/atom/A in R.module.get_inactive_modules())
+			//Module is not currently active
+			screenmob.client.screen -= A
+		R.shown_robot_modules = 0
+		screenmob.client.screen -= R.robot_modules_background
+
+/datum/hud/robot/persistent_inventory_update(mob/viewer)
+	if(!mymob)
+		return
+	var/mob/living/silicon/robot/R = mymob
+
+	var/mob/screenmob = viewer || R
+
+	if(screenmob.hud_used)
+		if(screenmob.hud_used.hud_shown)
+			for(var/i in 1 to R.held_items.len)
+				var/obj/item/I = R.held_items[i]
+				if(I)
+					switch(i)
+						if(1)
+							I.screen_loc = ui_inv1
+						if(2)
+							I.screen_loc = ui_inv2
+						if(3)
+							I.screen_loc = ui_inv3
+						else
+							return
+					screenmob.client.screen += I
+		else
+			for(var/obj/item/I in R.held_items)
+				screenmob.client.screen -= I

code/_onclick/item_attack.dm

@@ -0,0 +1,177 @@
+
+/obj/item/proc/melee_attack_chain(mob/user, atom/target, params)
+	if(!tool_attack_chain(user, target) && pre_attack(target, user, params))
+		// Return 1 in attackby() to prevent afterattack() effects (when safely moving items for example)
+		var/resolved = target.attackby(src, user, params)
+		if(!resolved && target && !QDELETED(src))
+			afterattack(target, user, 1, params) // 1: clicking something Adjacent
+
+
+//Checks if the item can work as a tool, calling the appropriate tool behavior on the target
+/obj/item/proc/tool_attack_chain(mob/user, atom/target)
+	if(!tool_behaviour)
+		return FALSE
+
+	return target.tool_act(user, src, tool_behaviour)
+
+
+// Called when the item is in the active hand, and clicked; alternately, there is an 'activate held object' verb or you can hit pagedown.
+/obj/item/proc/attack_self(mob/user)
+	if(SEND_SIGNAL(src, COMSIG_ITEM_ATTACK_SELF, user) & COMPONENT_NO_INTERACT)
+		return
+	interact(user)
+
+/obj/item/proc/pre_attack(atom/A, mob/living/user, params) //do stuff before attackby!
+	if(SEND_SIGNAL(src, COMSIG_ITEM_PRE_ATTACK, A, user, params) & COMPONENT_NO_ATTACK)
+		return FALSE
+	return TRUE //return FALSE to avoid calling attackby after this proc does stuff
+
+// No comment
+/atom/proc/attackby(obj/item/W, mob/user, params)
+	if(SEND_SIGNAL(src, COMSIG_PARENT_ATTACKBY, W, user, params) & COMPONENT_NO_AFTERATTACK)
+		return TRUE
+	return FALSE
+
+/obj/attackby(obj/item/I, mob/living/user, params)
+	return ..() || ((obj_flags & CAN_BE_HIT) && I.attack_obj(src, user))
+
+/mob/living/attackby(obj/item/I, mob/living/user, params)
+	if(..())
+		return TRUE
+	user.changeNext_move(CLICK_CD_MELEE)
+	if(user.a_intent == INTENT_HARM && stat == DEAD && (butcher_results || guaranteed_butcher_results)) //can we butcher it?
+		var/datum/component/butchering/butchering = I.GetComponent(/datum/component/butchering)
+		if(butchering && butchering.butchering_enabled)
+			to_chat(user, "<span class='notice'>You begin to butcher [src]...</span>")
+			playsound(loc, butchering.butcher_sound, 50, TRUE, -1)
+			if(do_mob(user, src, butchering.speed) && Adjacent(I))
+				butchering.Butcher(user, src)
+			return 1
+		else if(I.get_sharpness() && !butchering) //give sharp objects butchering functionality, for consistency
+			I.AddComponent(/datum/component/butchering, 80 * I.toolspeed)
+			attackby(I, user, params) //call the attackby again to refresh and do the butchering check again
+			return
+	return I.attack(src, user)
+
+
+/obj/item/proc/attack(mob/living/M, mob/living/user)
+	SEND_SIGNAL(src, COMSIG_ITEM_ATTACK, M, user)
+	SEND_SIGNAL(user, COMSIG_MOB_ITEM_ATTACK, M, user)
+	if(item_flags & NOBLUDGEON)
+		return
+
+	if(user.getStaminaLoss() >= STAMINA_SOFTCRIT) // CIT CHANGE - makes it impossible to attack in stamina softcrit
+		to_chat(user, "<span class='warning'>You're too exhausted.</span>") // CIT CHANGE - ditto
+		return // CIT CHANGE - ditto
+
+	if(force && damtype != STAMINA && HAS_TRAIT(user, TRAIT_PACIFISM))
+		to_chat(user, "<span class='warning'>You don't want to harm other living beings!</span>")
+		return
+
+	if(!force)
+		playsound(loc, 'sound/weapons/tap.ogg', get_clamped_volume(), 1, -1)
+	else if(hitsound)
+		playsound(loc, hitsound, get_clamped_volume(), 1, -1)
+
+	M.lastattacker = user.real_name
+	M.lastattackerckey = user.ckey
+
+	user.do_attack_animation(M)
+	M.attacked_by(src, user)
+
+	log_combat(user, M, "attacked", src.name, "(INTENT: [uppertext(user.a_intent)]) (DAMTYPE: [uppertext(damtype)])")
+	add_fingerprint(user)
+
+	user.adjustStaminaLossBuffered(getweight()*0.8)//CIT CHANGE - makes attacking things cause stamina loss
+
+//the equivalent of the standard version of attack() but for object targets.
+/obj/item/proc/attack_obj(obj/O, mob/living/user)
+	if(SEND_SIGNAL(src, COMSIG_ITEM_ATTACK_OBJ, O, user) & COMPONENT_NO_ATTACK_OBJ)
+		return
+	if(item_flags & NOBLUDGEON)
+		return
+	if(user.getStaminaLoss() >= STAMINA_SOFTCRIT) // CIT CHANGE - makes it impossible to attack in stamina softcrit
+		to_chat(user, "<span class='warning'>You're too exhausted.</span>") // CIT CHANGE - ditto
+		return // CIT CHANGE - ditto
+	user.adjustStaminaLossBuffered(getweight()*1.2)//CIT CHANGE - makes attacking things cause stamina loss
+	user.changeNext_move(CLICK_CD_MELEE)
+	user.do_attack_animation(O)
+	O.attacked_by(src, user)
+
+/atom/movable/proc/attacked_by()
+	return
+
+/obj/attacked_by(obj/item/I, mob/living/user)
+	if(I.force)
+		visible_message("<span class='danger'>[user] has hit [src] with [I]!</span>", null, null, COMBAT_MESSAGE_RANGE)
+		//only witnesses close by and the victim see a hit message.
+		log_combat(user, src, "attacked", I)
+	take_damage(I.force, I.damtype, "melee", 1)
+
+/mob/living/attacked_by(obj/item/I, mob/living/user)
+	send_item_attack_message(I, user)
+	if(I.force)
+	//CIT CHANGES START HERE - combatmode and resting checks
+		var/totitemdamage = I.force
+		if(iscarbon(user))
+			var/mob/living/carbon/tempcarb = user
+			if(!tempcarb.combatmode)
+				totitemdamage *= 0.5
+		if(user.resting)
+			totitemdamage *= 0.5
+	//CIT CHANGES END HERE
+		apply_damage(totitemdamage, I.damtype) //CIT CHANGE - replaces I.force with totitemdamage
+		if(I.damtype == BRUTE)
+			if(prob(33))
+				I.add_mob_blood(src)
+				var/turf/location = get_turf(src)
+				if(iscarbon(src))
+					var/mob/living/carbon/C = src
+					C.bleed(totitemdamage)
+				else
+					add_splatter_floor(location)
+				if(totitemdamage >= 10 && get_dist(user, src) <= 1)	//people with TK won't get smeared with blood
+					user.add_mob_blood(src)
+		return TRUE //successful attack
+
+/mob/living/simple_animal/attacked_by(obj/item/I, mob/living/user)
+	if(I.force < force_threshold || I.damtype == STAMINA)
+		playsound(loc, 'sound/weapons/tap.ogg', I.get_clamped_volume(), 1, -1)
+	else
+		return ..()
+
+// Proximity_flag is 1 if this afterattack was called on something adjacent, in your square, or on your person.
+// Click parameters is the params string from byond Click() code, see that documentation.
+/obj/item/proc/afterattack(atom/target, mob/user, proximity_flag, click_parameters)
+	SEND_SIGNAL(src, COMSIG_ITEM_AFTERATTACK, target, user, proximity_flag, click_parameters)
+	SEND_SIGNAL(user, COMSIG_MOB_ITEM_AFTERATTACK, target, user, proximity_flag, click_parameters)
+
+/obj/item/proc/get_clamped_volume()
+	if(w_class)
+		if(force)
+			return CLAMP((force + w_class) * 4, 30, 100)// Add the item's force to its weight class and multiply by 4, then clamp the value between 30 and 100
+		else
+			return CLAMP(w_class * 6, 10, 100) // Multiply the item's weight class by 6, then clamp the value between 10 and 100
+
+/mob/living/proc/send_item_attack_message(obj/item/I, mob/living/user, hit_area)
+	var/message_verb = "attacked"
+	if(I.attack_verb && I.attack_verb.len)
+		message_verb = "[pick(I.attack_verb)]"
+	else if(!I.force)
+		return
+	var/message_hit_area = ""
+	if(hit_area)
+		message_hit_area = " in the [hit_area]"
+	var/attack_message = "[src] has been [message_verb][message_hit_area] with [I]."
+	if(user in viewers(src, null))
+		attack_message = "[user] has [message_verb] [src][message_hit_area] with [I]!"
+	visible_message("<span class='danger'>[attack_message]</span>",\
+		"<span class='userdanger'>[attack_message]</span>", null, COMBAT_MESSAGE_RANGE)
+	if(hit_area == BODY_ZONE_HEAD)
+		if(prob(2))
+			playsound(src, 'sound/weapons/dink.ogg', 30, 1)
+	return 1
+
+/obj/item/proc/getweight()
+	return total_mass || w_class * 1.25
+