Pixel Projectiles

code/_helpers/vector.dm

@@ -1,141 +0,0 @@
-/* 
-plot_vector is a helper datum for plotting a path in a straight line towards a target turf.
-This datum converts from world space (turf.x and turf.y) to pixel space, which the datum keeps track of itself. This
-should work with any size turfs (i.e. 32x32, 64x64) as it references world.icon_size (note: not actually tested with
-anything other than 32x32 turfs).
-
-setup()
-	This should be called after creating a new instance of a plot_vector datum.
-	This does the initial setup and calculations. Since we are travelling in a straight line we only need to calculate 
-	the	vector and x/y steps once. x/y steps are capped to 1 full turf, whichever is further. If we are travelling along
-	the y axis each step will be +/- 1 y, and the x movement reduced based on the angle (tangent calculation). After
-	this every subsequent step will be incremented based on these calculations.
-	Inputs:
-		source - the turf the object is starting from
-		target - the target turf the object is travelling towards
-		xo - starting pixel_x offset, typically won't be needed, but included in case someone has a need for it later
-		yo - same as xo, but for the y_pixel offset
-
-increment()
-	Adds the offset to the current location - incrementing it by one step along the vector.
-
-return_angle()
-	Returns the direction (angle in degrees) the object is travelling in.
-
-             (N)
-             90°
-              ^
-              |
-  (W) 180° <--+--> 0° (E)
-              |
-              v
-             -90°
-             (S)
-
-return_hypotenuse()
-	Returns the distance of travel for each step of the vector, relative to each full step of movement. 1 is a full turf 
-	length. Currently used as a multiplier for scaling effects that should be contiguous, like laser beams.
-
-return_location()
-	Returns a vector_loc datum containing the current location data of the object (see /datum/vector_loc). This includes 
-	the turf it currently should be at, as well as the pixel offset from the centre of that turf. Typically increment() 
-	would be called before this if you are going to move an object based on it's vector data.
-*/
-
-/datum/plot_vector
-	var/turf/source
-	var/turf/target
-	var/angle = 0	// direction of travel in degrees
-	var/loc_x = 0	// in pixels from the left edge of the map
-	var/loc_y = 0	// in pixels from the bottom edge of the map
-	var/loc_z = 0	// loc z is in world space coordinates (i.e. z level) - we don't care about measuring pixels for this
-	var/offset_x = 0	// distance to increment each step
-	var/offset_y = 0
-
-/datum/plot_vector/proc/setup(var/turf/S, var/turf/T, var/xo = 0, var/yo = 0, var/angle_offset=0)
-	source = S
-	target = T
-	
-	if(!istype(source))
-		source = get_turf(source)
-	if(!istype(target))
-		target = get_turf(target)	
-
-	if(!istype(source) || !istype(target))
-		return
-
-	// convert coordinates to pixel space (default is 32px/turf, 8160px across for a size 255 map)
-	loc_x = source.x * world.icon_size + xo
-	loc_y = source.y * world.icon_size + yo
-	loc_z = source.z
-	
-	// calculate initial x and y difference
-	var/dx = target.x - source.x
-	var/dy = target.y - source.y
-
-	// if we aren't moving anywhere; quit now
-	if(dx == 0 && dy == 0)
-		return
-
-	// calculate the angle
-	angle = Atan2(dx, dy) + angle_offset
-
-	// and some rounding to stop the increments jumping whole turfs - because byond favours certain angles
-	if(angle > -135 && angle < 45)
-		angle = Ceiling(angle)
-	else
-		angle = Floor(angle)
-
-	// calculate the offset per increment step
-	if(abs(angle) in list(0, 45, 90, 135, 180))		// check if the angle is a cardinal
-		if(abs(angle) in list(0, 45, 135, 180))		// if so we can skip the trigonometry and set these to absolutes as
-			offset_x = sign(dx)						// they will always be a full step in one or more directions
-		if(abs(angle) in list(45, 90, 135))
-			offset_y = sign(dy)
-	else if(abs(dy) > abs(dx))
-		offset_x = Cot(abs(angle))					// otherwise set the offsets
-		offset_y = sign(dy)
-	else
-		offset_x = sign(dx)
-		offset_y = Tan(angle)
-		if(dx < 0)
-			offset_y = -offset_y
-
-	// multiply the offset by the turf pixel size
-	offset_x *= world.icon_size
-	offset_y *= world.icon_size
-
-/datum/plot_vector/proc/increment()
-	loc_x += offset_x
-	loc_y += offset_y
-
-/datum/plot_vector/proc/return_angle()
-	return angle
-
-/datum/plot_vector/proc/return_hypotenuse()
-	return sqrt(((offset_x / 32) ** 2) + ((offset_y / 32) ** 2))
-
-/datum/plot_vector/proc/return_location(var/datum/vector_loc/data)
-	if(!data)
-		data = new()
-	data.loc = locate(round(loc_x / world.icon_size, 1), round(loc_y / world.icon_size, 1), loc_z)
-	if(!data.loc)
-		return
-	data.pixel_x = loc_x - (data.loc.x * world.icon_size)
-	data.pixel_y = loc_y - (data.loc.y * world.icon_size)
-	return data
-
-/* 
-vector_loc is a helper datum for returning precise location data from plot_vector. It includes the turf the object is in
-as well as the pixel offsets.
-
-return_turf()
-	Returns the turf the object should be currently located in.
-*/
-/datum/vector_loc
-	var/turf/loc
-	var/pixel_x
-	var/pixel_y
-
-/datum/vector_loc/proc/return_turf()
-	return loc

code/_helpers/view.dm

@@ -0,0 +1,12 @@
+/proc/getviewsize(view)
+	var/viewX
+	var/viewY
+	if(isnum(view))
+		var/totalviewrange = 1 + 2 * view
+		viewX = totalviewrange
+		viewY = totalviewrange
+	else
+		var/list/viewrangelist = splittext(view,"x")
+		viewX = text2num(viewrangelist[1])
+		viewY = text2num(viewrangelist[2])
+	return list(viewX, viewY)

code/controllers/subsystems/processing/processing.dm

@@ -0,0 +1,35 @@
+//Used to process objects. Fires once every second.
+
+SUBSYSTEM_DEF(processing)
+	name = "Processing"
+	priority = FIRE_PRIORITY_PROCESS
+	flags = SS_BACKGROUND|SS_POST_FIRE_TIMING|SS_NO_INIT
+	wait = 10
+
+	var/stat_tag = "P" //Used for logging
+	var/list/processing = list()
+	var/list/currentrun = list()
+
+/datum/controller/subsystem/processing/stat_entry()
+	..("[stat_tag]:[processing.len]")
+
+/datum/controller/subsystem/processing/fire(resumed = 0)
+	if (!resumed)
+		currentrun = processing.Copy()
+	//cache for sanic speed (lists are references anyways)
+	var/list/current_run = currentrun
+
+	while(current_run.len)
+		var/datum/thing = current_run[current_run.len]
+		current_run.len--
+		if(QDELETED(thing))
+			processing -= thing
+		else if(thing.process(wait) == PROCESS_KILL)
+			// fully stop so that a future START_PROCESSING will work
+			STOP_PROCESSING(src, thing)
+		if (MC_TICK_CHECK)
+			return
+
+/datum/proc/process()
+	set waitfor = 0
+	return PROCESS_KILL

code/controllers/subsystems/processing/projectiles.dm

@@ -0,0 +1,23 @@
+PROCESSING_SUBSYSTEM_DEF(projectiles)
+	name = "Projectiles"
+	wait = 1
+	stat_tag = "PP"
+	flags = SS_NO_INIT|SS_TICKER
+	var/global_max_tick_moves = 10
+	var/global_pixel_speed = 2
+	var/global_iterations_per_move = 16
+
+/datum/controller/subsystem/processing/projectiles/proc/set_pixel_speed(new_speed)
+	global_pixel_speed = new_speed
+	for(var/i in processing)
+		var/obj/item/projectile/P = i
+		if(istype(P))			//there's non projectiles on this too.
+			P.set_pixel_speed(new_speed)
+
+/datum/controller/subsystem/processing/projectiles/vv_edit_var(var_name, var_value)
+	switch(var_name)
+		if(NAMEOF(src, global_pixel_speed))
+			set_pixel_speed(var_value)
+			return TRUE
+		else
+			return ..()

code/datums/position_point_vector.dm

@@ -0,0 +1,227 @@
+//Designed for things that need precision trajectories like projectiles.
+//Don't use this for anything that you don't absolutely have to use this with (like projectiles!) because it isn't worth using a datum unless you need accuracy down to decimal places in pixels.
+
+//You might see places where it does - 16 - 1. This is intentionally 17 instead of 16, because of how byond's tiles work and how not doing it will result in rounding errors like things getting put on the wrong turf.
+
+#define RETURN_PRECISE_POSITION(A) new /datum/position(A)
+#define RETURN_PRECISE_POINT(A) new /datum/point(A)
+
+#define RETURN_POINT_VECTOR(ATOM, ANGLE, SPEED) {new /datum/point/vector(ATOM, null, null, null, null, ANGLE, SPEED)}
+#define RETURN_POINT_VECTOR_INCREMENT(ATOM, ANGLE, SPEED, AMT) {new /datum/point/vector(ATOM, null, null, null, null, ANGLE, SPEED, AMT)}
+
+/datum/position			//For positions with map x/y/z and pixel x/y so you don't have to return lists. Could use addition/subtraction in the future I guess.
+	var/x = 0
+	var/y = 0
+	var/z = 0
+	var/pixel_x = 0
+	var/pixel_y = 0
+
+/datum/position/proc/valid()
+	return x && y && z && !isnull(pixel_x) && !isnull(pixel_y)
+
+/datum/position/New(_x = 0, _y = 0, _z = 0, _pixel_x = 0, _pixel_y = 0)	//first argument can also be a /datum/point.
+	if(istype(_x, /datum/point))
+		var/datum/point/P = _x
+		var/turf/T = P.return_turf()
+		_x = T.x
+		_y = T.y
+		_z = T.z
+		_pixel_x = P.return_px()
+		_pixel_y = P.return_py()
+	else if(istype(_x, /atom))
+		var/atom/A = _x
+		_x = A.x
+		_y = A.y
+		_z = A.z
+		_pixel_x = A.pixel_x
+		_pixel_y = A.pixel_y
+	x = _x
+	y = _y
+	z = _z
+	pixel_x = _pixel_x
+	pixel_y = _pixel_y
+
+/datum/position/proc/return_turf()
+	return locate(x, y, z)
+
+/datum/position/proc/return_px()
+	return pixel_x
+
+/datum/position/proc/return_py()
+	return pixel_y
+
+/datum/position/proc/return_point()
+	return new /datum/point(src)
+
+/proc/point_midpoint_points(datum/point/a, datum/point/b)	//Obviously will not support multiZ calculations! Same for the two below.
+	var/datum/point/P = new
+	P.x = a.x + (b.x - a.x) / 2
+	P.y = a.y + (b.y - a.y) / 2
+	P.z = a.z
+	return P
+
+/proc/pixel_length_between_points(datum/point/a, datum/point/b)
+	return sqrt(((b.x - a.x) ** 2) + ((b.y - a.y) ** 2))
+
+/proc/angle_between_points(datum/point/a, datum/point/b)
+	return Atan2((b.y - a.y), (b.x - a.x))
+
+/datum/point		//A precise point on the map in absolute pixel locations based on world.icon_size. Pixels are FROM THE EDGE OF THE MAP!
+	var/x = 0
+	var/y = 0
+	var/z = 0
+
+/datum/point/proc/valid()
+	return x && y && z
+
+/datum/point/proc/copy_to(datum/point/p = new)
+	p.x = x
+	p.y = y
+	p.z = z
+	return p
+
+/datum/point/New(_x, _y, _z, _pixel_x = 0, _pixel_y = 0)	//first argument can also be a /datum/position or /atom.
+	if(istype(_x, /datum/position))
+		var/datum/position/P = _x
+		_x = P.x
+		_y = P.y
+		_z = P.z
+		_pixel_x = P.pixel_x
+		_pixel_y = P.pixel_y
+	else if(istype(_x, /atom))
+		var/atom/A = _x
+		_x = A.x
+		_y = A.y
+		_z = A.z
+		_pixel_x = A.pixel_x
+		_pixel_y = A.pixel_y
+	initialize_location(_x, _y, _z, _pixel_x, _pixel_y)
+
+/datum/point/proc/initialize_location(tile_x, tile_y, tile_z, p_x = 0, p_y = 0)
+	if(!isnull(tile_x))
+		x = ((tile_x - 1) * world.icon_size) + world.icon_size / 2 + p_x + 1
+	if(!isnull(tile_y))
+		y = ((tile_y - 1) * world.icon_size) + world.icon_size / 2 + p_y + 1
+	if(!isnull(tile_z))
+		z = tile_z
+
+/datum/point/proc/debug_out()
+	var/turf/T = return_turf()
+	return "\ref[src] aX [x] aY [y] aZ [z] pX [return_px()] pY [return_py()] mX [T.x] mY [T.y] mZ [T.z]"
+
+/datum/point/proc/move_atom_to_src(atom/movable/AM)
+	AM.forceMove(return_turf())
+	AM.pixel_x = return_px()
+	AM.pixel_y = return_py()
+
+/datum/point/proc/return_turf()
+	return locate(Ceiling(x / world.icon_size, 1), Ceiling(y / world.icon_size, 1), z)
+
+/datum/point/proc/return_coordinates()		//[turf_x, turf_y, z]
+	return list(Ceiling(x / world.icon_size, 1), Ceiling(y / world.icon_size, 1), z)
+
+/datum/point/proc/return_position()
+	return new /datum/position(src)
+
+/datum/point/proc/return_px()
+	return Modulus(x, world.icon_size) - 16 - 1
+
+/datum/point/proc/return_py()
+	return Modulus(y, world.icon_size) - 16 - 1
+
+
+/datum/point/vector
+	var/speed = 32				//pixels per iteration
+	var/iteration = 0
+	var/angle = 0
+	var/mpx = 0					//calculated x/y movement amounts to prevent having to do trig every step.
+	var/mpy = 0
+	var/starting_x = 0			//just like before, pixels from EDGE of map! This is set in initialize_location().
+	var/starting_y = 0
+	var/starting_z = 0
+
+/datum/point/vector/New(_x, _y, _z, _pixel_x = 0, _pixel_y = 0, _angle, _speed, initial_increment = 0)
+	..()
+	initialize_trajectory(_speed, _angle)
+	if(initial_increment)
+		increment(initial_increment)
+
+/datum/point/vector/initialize_location(tile_x, tile_y, tile_z, p_x = 0, p_y = 0)
+	. = ..()
+	starting_x = x
+	starting_y = y
+	starting_z = z
+
+/datum/point/vector/copy_to(datum/point/vector/v = new)
+	..(v)
+	v.speed = speed
+	v.iteration = iteration
+	v.angle = angle
+	v.mpx = mpx
+	v.mpy = mpy
+	v.starting_x = starting_x
+	v.starting_y = starting_y
+	v.starting_z = starting_z
+	return v
+
+/datum/point/vector/proc/initialize_trajectory(pixel_speed, new_angle)
+	if(!isnull(pixel_speed))
+		speed = pixel_speed
+	set_angle(new_angle)
+
+/datum/point/vector/proc/set_angle(new_angle)		//calculations use "byond angle" where north is 0 instead of 90, and south is 180 instead of 270.
+	if(isnull(angle))
+		return
+	angle = new_angle
+	update_offsets()
+
+/datum/point/vector/proc/update_offsets()
+	mpx = sin(angle) * speed
+	mpy = cos(angle) * speed
+
+/datum/point/vector/proc/set_speed(new_speed)
+	if(isnull(new_speed) || speed == new_speed)
+		return
+	speed = new_speed
+	update_offsets()
+
+/datum/point/vector/proc/increment(multiplier = 1)
+	iteration++
+	x += mpx * multiplier
+	y += mpy * multiplier
+
+/datum/point/vector/proc/return_vector_after_increments(amount = 7, multiplier = 1, force_simulate = FALSE)
+	var/datum/point/vector/v = copy_to()
+	if(force_simulate)
+		for(var/i in 1 to amount)
+			v.increment(multiplier)
+	else
+		v.increment(multiplier * amount)
+	return v
+
+/datum/point/vector/proc/on_z_change()
+	return
+
+/datum/point/vector/processed		//pixel_speed is per decisecond.
+	var/last_process = 0
+	var/last_move = 0
+	var/paused = FALSE
+
+/datum/point/vector/processed/Destroy()
+	STOP_PROCESSING(SSprojectiles, src)
+	return ..()
+
+/datum/point/vector/processed/proc/start()
+	last_process = world.time
+	last_move = world.time
+	START_PROCESSING(SSprojectiles, src)
+
+/datum/point/vector/processed/process()
+	if(paused)
+		last_move += world.time - last_process
+		last_process = world.time
+		return
+	var/needed_time = world.time - last_move
+	last_process = world.time
+	last_move = world.time
+	increment(needed_time / SSprojectiles.wait)

code/game/objects/effects/temporary_visuals/projectiles/impact.dm

@@ -0,0 +1,38 @@
+/obj/effect/projectile/impact
+	name = "beam impact"
+	icon = 'icons/obj/projectiles_impact.dmi'
+
+/obj/effect/projectile/impact/laser
+	name = "laser impact"
+	icon_state = "impact_laser"
+
+/obj/effect/projectile/impact/laser/blue
+	name = "laser impact"
+	icon_state = "impact_blue"
+
+/obj/effect/projectile/impact/disabler
+	name = "disabler impact"
+	icon_state = "impact_omni"
+
+/obj/effect/projectile/impact/xray
+	name = "\improper X-ray impact"
+	icon_state = "impact_xray"
+
+/obj/effect/projectile/impact/pulse
+	name = "pulse impact"
+	icon_state = "impact_u_laser"
+
+/obj/effect/projectile/impact/plasma_cutter
+	name = "plasma impact"
+	icon_state = "impact_plasmacutter"
+
+/obj/effect/projectile/impact/stun
+	name = "stun impact"
+	icon_state = "impact_stun"
+
+/obj/effect/projectile/impact/heavy_laser
+	name = "heavy laser impact"
+	icon_state = "impact_beam_heavy"
+
+/obj/effect/projectile/impact/wormhole
+	icon_state = "wormhole_g"

code/game/objects/effects/temporary_visuals/projectiles/muzzle.dm

@@ -0,0 +1,30 @@
+/obj/effect/projectile/muzzle
+	name = "muzzle flash"
+	icon = 'icons/obj/projectiles_muzzle.dmi'
+
+/obj/effect/projectile/muzzle/laser
+	icon_state = "muzzle_laser"
+
+/obj/effect/projectile/muzzle/laser/blue
+	icon_state = "muzzle_laser_blue"
+
+/obj/effect/projectile/muzzle/disabler
+	icon_state = "muzzle_omni"
+
+/obj/effect/projectile/muzzle/xray
+	icon_state = "muzzle_xray"
+
+/obj/effect/projectile/muzzle/pulse
+	icon_state = "muzzle_u_laser"
+
+/obj/effect/projectile/muzzle/plasma_cutter
+	icon_state = "muzzle_plasmacutter"
+
+/obj/effect/projectile/muzzle/stun
+	icon_state = "muzzle_stun"
+
+/obj/effect/projectile/muzzle/heavy_laser
+	icon_state = "muzzle_beam_heavy"
+
+/obj/effect/projectile/muzzle/wormhole
+	icon_state = "wormhole_g"

code/game/objects/effects/temporary_visuals/projectiles/projectile_effects.dm

@@ -0,0 +1,60 @@
+/obj/effect/projectile
+	name = "pew"
+	icon = 'icons/obj/projectiles.dmi'
+	icon_state = "nothing"
+	layer = ABOVE_MOB_LAYER
+	anchored = TRUE
+	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
+	appearance_flags = 0
+
+/obj/effect/projectile/singularity_pull()
+	return
+
+/obj/effect/projectile/singularity_act()
+	return
+
+/obj/effect/projectile/proc/scale_to(nx,ny,override=TRUE)
+	var/matrix/M
+	if(!override)
+		M = transform
+	else
+		M = new
+	M.Scale(nx,ny)
+	transform = M
+
+/obj/effect/projectile/proc/turn_to(angle,override=TRUE)
+	var/matrix/M
+	if(!override)
+		M = transform
+	else
+		M = new
+	M.Turn(angle)
+	transform = M
+
+/obj/effect/projectile/New(angle_override, p_x, p_y, color_override, scaling = 1)
+	if(angle_override && p_x && p_y && color_override && scaling)
+		apply_vars(angle_override, p_x, p_y, color_override, scaling)
+	return ..()
+
+/obj/effect/projectile/proc/apply_vars(angle_override, p_x = 0, p_y = 0, color_override, scaling = 1, new_loc, increment = 0)
+	var/mutable_appearance/look = new(src)
+	look.pixel_x = p_x
+	look.pixel_y = p_y
+	if(color_override)
+		look.color = color_override
+	appearance = look
+	scale_to(1,scaling, FALSE)
+	turn_to(angle_override, FALSE)
+	if(!isnull(new_loc))	//If you want to null it just delete it...
+		forceMove(new_loc)
+	for(var/i in 1 to increment)
+		pixel_x += round((sin(angle_override)+16*sin(angle_override)*2), 1)
+		pixel_y += round((cos(angle_override)+16*cos(angle_override)*2), 1)
+
+/obj/effect/projectile_lighting
+	var/owner
+
+/obj/effect/projectile_lighting/Initialize(mapload, color, range, intensity, owner_key)
+	. = ..()
+	set_light(range, intensity, color)
+	owner = owner_key

code/game/objects/effects/temporary_visuals/projectiles/tracer.dm

@@ -0,0 +1,68 @@
+/proc/generate_tracer_between_points(datum/point/starting, datum/point/ending, beam_type, color, qdel_in = 5, light_range = 2, light_color_override, light_intensity = 1, instance_key)		//Do not pass z-crossing points as that will not be properly (and likely will never be properly until it's absolutely needed) supported!
+	if(!istype(starting) || !istype(ending) || !ispath(beam_type))
+		return
+	var/datum/point/midpoint = point_midpoint_points(starting, ending)
+	var/obj/effect/projectile/tracer/PB = new beam_type
+	if(isnull(light_color_override))
+		light_color_override = color
+	PB.apply_vars(angle_between_points(starting, ending), midpoint.return_px(), midpoint.return_py(), color, pixel_length_between_points(starting, ending) / world.icon_size, midpoint.return_turf(), 0)
+	. = PB
+	if(light_range > 0 && light_intensity > 0)
+		var/list/turf/line = getline(starting.return_turf(), ending.return_turf())
+		tracing_line:
+			for(var/i in line)
+				var/turf/T = i
+				for(var/obj/effect/projectile_lighting/PL in T)
+					if(PL.owner == instance_key)
+						continue tracing_line
+				QDEL_IN(new /obj/effect/projectile_lighting(T, light_color_override, light_range, light_intensity, instance_key), qdel_in > 0? qdel_in : 5)
+		line = null
+	if(qdel_in)
+		QDEL_IN(PB, qdel_in)
+
+/obj/effect/projectile/tracer
+	name = "beam"
+	icon = 'icons/obj/projectiles_tracer.dmi'
+
+/obj/effect/projectile/tracer/laser
+	name = "laser"
+	icon_state = "beam"
+
+/obj/effect/projectile/tracer/laser/blue
+	icon_state = "beam_blue"
+
+/obj/effect/projectile/tracer/disabler
+	name = "disabler"
+	icon_state = "beam_omni"
+
+/obj/effect/projectile/tracer/xray
+	name = "\improper X-ray laser"
+	icon_state = "xray"
+
+/obj/effect/projectile/tracer/pulse
+	name = "pulse laser"
+	icon_state = "u_laser"
+
+/obj/effect/projectile/tracer/plasma_cutter
+	name = "plasma blast"
+	icon_state = "plasmacutter"
+
+/obj/effect/projectile/tracer/stun
+	name = "stun beam"
+	icon_state = "stun"
+
+/obj/effect/projectile/tracer/heavy_laser
+	name = "heavy laser"
+	icon_state = "beam_heavy"
+
+//BEAM RIFLE
+/obj/effect/projectile/tracer/tracer/beam_rifle
+	icon_state = "tracer_beam"
+
+/obj/effect/projectile/tracer/tracer/aiming
+	icon_state = "pixelbeam_greyscale"
+	layer = ABOVE_LIGHTING_LAYER
+	plane = ABOVE_LIGHTING_PLANE
+
+/obj/effect/projectile/tracer/wormhole
+	icon_state = "wormhole_g"

code/game/objects/effects/temporary_visuals/temporary_visual.dm

@@ -0,0 +1,39 @@
+//temporary visual effects
+/obj/effect/temp_visual
+	icon_state = "nothing"
+	anchored = TRUE
+	layer = ABOVE_MOB_LAYER
+	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
+	var/duration = 10 //in deciseconds
+	var/randomdir = TRUE
+	var/timerid
+
+/obj/effect/temp_visual/Initialize()
+	. = ..()
+	if(randomdir)
+		setDir(pick(GLOB.cardinals))
+
+	timerid = QDEL_IN(src, duration)
+
+/obj/effect/temp_visual/Destroy()
+	. = ..()
+	deltimer(timerid)
+
+/obj/effect/temp_visual/singularity_act()
+	return
+
+/obj/effect/temp_visual/singularity_pull()
+	return
+
+/obj/effect/temp_visual/ex_act()
+	return
+
+/obj/effect/temp_visual/dir_setting
+	randomdir = FALSE
+
+/obj/effect/temp_visual/dir_setting/Initialize(mapload, set_dir)
+	if(set_dir)
+		setDir(set_dir)
+	. = ..()
+
+

code/modules/projectiles/projectile.dm

@@ -1,37 +1,84 @@
-/*
-#define BRUTE "brute"
-#define BURN "burn"
-#define TOX "tox"
-#define OXY "oxy"
-#define CLONE "clone"
-
-#define ADD "add"
-#define SET "set"
-*/
+#define MOVES_HITSCAN -1		//Not actually hitscan but close as we get without actual hitscan.
+#define MUZZLE_EFFECT_PIXEL_INCREMENT 17	//How many pixels to move the muzzle flash up so your character doesn't look like they're shitting out lasers.
 
 /obj/item/projectile
 	name = "projectile"
 	icon = 'icons/obj/projectiles.dmi'
 	icon_state = "bullet"
-	density = 1
-	unacidable = 1
-	anchored = 1 //There's a reason this is here, Mport. God fucking damn it -Agouri. Find&Fix by Pete. The reason this is here is to stop the curving of emitter shots.
+	density = FALSE
+	anchored = TRUE
+	unacidable = TRUEs
 	pass_flags = PASSTABLE
-	mouse_opacity = 0
-	var/bumped = 0		//Prevents it from hitting more than one guy at once
+	mouse_opacity = MOUSE_OPACITY_TRANSPARENT
+
+	////TG PROJECTILE SYTSEM
+	//Projectile stuff
+	var/range = 50
+	var/originalRange
+
+	//Fired processing vars
+	var/fired = FALSE	//Have we been fired yet
+	var/paused = FALSE	//for suspending the projectile midair
+	var/last_projectile_move = 0
+	var/last_process = 0
+	var/time_offset = 0
+	var/datum/point/vector/trajectory
+	var/trajectory_ignore_forcemove = FALSE	//instructs forceMove to NOT reset our trajectory to the new location!
+
+	var/speed = 0.8			//Amount of deciseconds it takes for projectile to travel
+	var/Angle = 0
+	var/original_angle = 0		//Angle at firing
+	var/nondirectional_sprite = FALSE //Set TRUE to prevent projectiles from having their sprites rotated based on firing angle
+	var/spread = 0			//amount (in degrees) of projectile spread
+	animate_movement = 0	//Use SLIDE_STEPS in conjunction with legacy
+	var/ricochets = 0
+	var/ricochets_max = 2
+	var/ricochet_chance = 30
+
+	//Hitscan
+	var/hitscan = FALSE		//Whether this is hitscan. If it is, speed is basically ignored.
+	var/list/beam_segments	//assoc list of datum/point or datum/point/vector, start = end. Used for hitscan effect generation.
+	var/datum/point/beam_index
+	var/turf/hitscan_last	//last turf touched during hitscanning.
+	var/_tracer_type
+	var/_muzzle_type
+	var/_impact_type
+
+	//Fancy hitscan lighting effects!
+	var/hitscan_light_intensity = 1.5
+	var/hitscan_light_range = 0.75
+	var/hitscan_light_color_override
+	var/muzzle_flash_intensity = 3
+	var/muzzle_flash_range = 1.5
+	var/muzzle_flash_color_override
+	var/impact_light_intensity = 3
+	var/impact_light_range = 2
+	var/impact_light_color_override
+
+	//Homing
+	var/homing = FALSE
+	var/atom/homing_target
+	var/homing_turn_speed = 10		//Angle per tick.
+	var/homing_inaccuracy_min = 0		//in pixels for these. offsets are set once when setting target.
+	var/homing_inaccuracy_max = 0
+	var/homing_offset_x = 0
+	var/homing_offset_y = 0
+
+	//Targetting
+	var/yo = null
+	var/xo = null
+	var/atom/original = null // the original target clicked
+	var/turf/starting = null // the projectile's starting turf
+	var/list/permutated = list() // we've passed through these atoms, don't try to hit them again
+	var/p_x = 16
+	var/p_y = 16			// the pixel location of the tile that the player clicked. Default is the center
+
+	//Misc/Polaris variables
+
 	var/def_zone = ""	//Aiming at
 	var/mob/firer = null//Who shot it
 	var/silenced = 0	//Attack message
-	var/yo = null
-	var/xo = null
-	var/current = null
 	var/shot_from = "" // name of the object which shot us
-	var/atom/original = null // the target clicked (not necessarily where the projectile is headed). Should probably be renamed to 'target' or something.
-	var/turf/starting = null // the projectile's starting turf
-	var/list/permutated = list() // we've passed through these atoms, don't try to hit them again
-
-	var/p_x = 16
-	var/p_y = 16 // the pixel location of the tile that the player clicked. Default is the center
 
 	var/accuracy = 0
 	var/dispersion = 0.0
@@ -45,7 +92,6 @@
 	var/check_armour = "bullet" //Defines what armor to use when it hits things.  Must be set to bullet, laser, energy,or bomb	//Cael - bio and rad are also valid
 	var/projectile_type = /obj/item/projectile
 	var/penetrating = 0 //If greater than zero, the projectile will pass through dense objects as specified by on_penetrate()
-	var/kill_count = 50 //This will de-increment every process(). When 0, it will delete the projectile.
 		//Effects
 	var/incendiary = 0 //1 for ignite on hit, 2 for trail of fire. 3 maybe later for burst of fire around the impact point. - Mech
 	var/flammability = 0 //Amount of fire stacks to add for the above.
@@ -59,28 +105,442 @@
 	var/drowsy = 0
 	var/agony = 0
 	var/reflected = 0 // This should be set to 1 if reflected by any means, to prevent infinite reflections.
-
 	embed_chance = 0	//Base chance for a projectile to embed
-
-	var/hitscan = 0		// whether the projectile should be hitscan
-	var/step_delay = 1	// the delay between iterations if not a hitscan projectile
-
-	// effect types to be used
-	var/muzzle_type
-	var/tracer_type
-	var/impact_type
-
 	var/fire_sound
-
 	var/vacuum_traversal = 1 //Determines if the projectile can exist in vacuum, if false, the projectile will be deleted if it enters vacuum.
 
-	var/datum/plot_vector/trajectory	// used to plot the path of the projectile
-	var/datum/vector_loc/location		// current location of the projectile in pixel space
-	var/matrix/effect_transform			// matrix to rotate and scale projectile effects - putting it here so it doesn't
-										//  have to be recreated multiple times
+/obj/item/projectile/proc/Range()
+	range--
+	if(range <= 0 && loc)
+		on_range()
+
+/obj/item/projectile/proc/on_range() //if we want there to be effects when they reach the end of their range
+	qdel(src)
+
+/obj/item/projectile/proc/return_predicted_turf_after_moves(moves, forced_angle)		//I say predicted because there's no telling that the projectile won't change direction/location in flight.
+	if(!trajectory && isnull(forced_angle) && isnull(Angle))
+		return FALSE
+	var/datum/point/vector/current = trajectory
+	if(!current)
+		var/turf/T = get_turf(src)
+		current = new(T.x, T.y, T.z, pixel_x, pixel_y, isnull(forced_angle)? Angle : forced_angle, SSprojectiles.global_pixel_speed)
+	var/datum/point/vector/v = current.return_vector_after_increments(moves * SSprojectiles.global_iterations_per_move)
+	return v.return_turf()
+
+/obj/item/projectile/proc/return_pathing_turfs_in_moves(moves, forced_angle)
+	var/turf/current = get_turf(src)
+	var/turf/ending = return_predicted_turf_after_moves(moves, forced_angle)
+	return getline(current, ending)
+
+/obj/item/projectile/proc/set_pixel_speed(new_speed)
+	if(trajectory)
+		trajectory.set_speed(new_speed)
+		return TRUE
+	return FALSE
+
+/obj/item/projectile/proc/record_hitscan_start(datum/point/pcache)
+	if(pcache)
+		beam_segments = list()
+		beam_index = pcache
+		beam_segments[beam_index] = null	//record start.
+
+/obj/item/projectile/proc/process_hitscan()
+	var/safety = range * 3
+	record_hitscan_start(RETURN_POINT_VECTOR_INCREMENT(src, Angle, MUZZLE_EFFECT_PIXEL_INCREMENT, 1))
+	while(loc && !QDELETED(src))
+		if(paused)
+			stoplag(1)
+			continue
+		if(safety-- <= 0)
+			if(loc)
+				Bump(loc)
+			if(!QDELETED(src))
+				qdel(src)
+			return	//Kill!
+		pixel_move(1, TRUE)
+
+/obj/item/projectile/proc/pixel_move(trajectory_multiplier, hitscanning = FALSE)
+	if(!loc || !trajectory)
+		return
+	last_projectile_move = world.time
+	if(!nondirectional_sprite && !hitscanning)
+		var/matrix/M = new
+		M.Turn(Angle)
+		transform = M
+	if(homing)
+		process_homing()
+	var/forcemoved = FALSE
+	for(var/i in 1 to SSprojectiles.global_iterations_per_move)
+		if(QDELETED(src))
+			return
+		trajectory.increment(trajectory_multiplier)
+		var/turf/T = trajectory.return_turf()
+		if(!istype(T))
+			qdel(src)
+			return
+		if(T.z != loc.z)
+			var/old = loc
+			before_z_change(loc, T)
+			trajectory_ignore_forcemove = TRUE
+			forceMove(T)
+			trajectory_ignore_forcemove = FALSE
+			after_z_change(old, loc)
+			if(!hitscanning)
+				pixel_x = trajectory.return_px()
+				pixel_y = trajectory.return_py()
+			forcemoved = TRUE
+			hitscan_last = loc
+		else if(T != loc)
+			before_move()
+			step_towards(src, T)
+			hitscan_last = loc
+			after_move()
+		if(can_hit_target(original, permutated))
+			Bump(original)
+	if(!hitscanning && !forcemoved)
+		pixel_x = trajectory.return_px() - trajectory.mpx * trajectory_multiplier * SSprojectiles.global_iterations_per_move
+		pixel_y = trajectory.return_py() - trajectory.mpy * trajectory_multiplier * SSprojectiles.global_iterations_per_move
+		animate(src, pixel_x = trajectory.return_px(), pixel_y = trajectory.return_py(), time = 1, flags = ANIMATION_END_NOW)
+	Range()
+
+/obj/item/projectile/Crossed(atom/movable/AM) //A mob moving on a tile with a projectile is hit by it.
+	..()
+	if(isliving(AM) && (AM.density || AM == original) && !(src.pass_flags & PASSMOB))
+		Bump(AM)
+
+/obj/item/projectile/proc/process_homing()			//may need speeding up in the future performance wise.
+	if(!homing_target)
+		return FALSE
+	var/datum/point/PT = RETURN_PRECISE_POINT(homing_target)
+	PT.x += CLAMP(homing_offset_x, 1, world.maxx)
+	PT.y += CLAMP(homing_offset_y, 1, world.maxy)
+	var/angle = closer_angle_difference(Angle, angle_between_points(RETURN_PRECISE_POINT(src), PT))
+	setAngle(Angle + CLAMP(angle, -homing_turn_speed, homing_turn_speed))
+
+/obj/item/projectile/proc/set_homing_target(atom/A)
+	if(!A || (!isturf(A) && !isturf(A.loc)))
+		return FALSE
+	homing = TRUE
+	homing_target = A
+	homing_offset_x = rand(homing_inaccuracy_min, homing_inaccuracy_max)
+	homing_offset_y = rand(homing_inaccuracy_min, homing_inaccuracy_max)
+	if(prob(50))
+		homing_offset_x = -homing_offset_x
+	if(prob(50))
+		homing_offset_y = -homing_offset_y
+
+/obj/item/projectile/process()
+	last_process = world.time
+	if(!loc || !fired || !trajectory)
+		fired = FALSE
+		return PROCESS_KILL
+	if(paused || !isturf(loc))
+		last_projectile_move += world.time - last_process		//Compensates for pausing, so it doesn't become a hitscan projectile when unpaused from charged up ticks.
+		return
+	var/elapsed_time_deciseconds = (world.time - last_projectile_move) + time_offset
+	time_offset = 0
+	var/required_moves = speed > 0? FLOOR(elapsed_time_deciseconds / speed, 1) : MOVES_HITSCAN			//Would be better if a 0 speed made hitscan but everyone hates those so I can't make it a universal system :<
+	if(required_moves == MOVES_HITSCAN)
+		required_moves = SSprojectiles.global_max_tick_moves
+	else
+		if(required_moves > SSprojectiles.global_max_tick_moves)
+			var/overrun = required_moves - SSprojectiles.global_max_tick_moves
+			required_moves = SSprojectiles.global_max_tick_moves
+			time_offset += overrun * speed
+		time_offset += MODULUS(elapsed_time_deciseconds, speed)
+
+	for(var/i in 1 to required_moves)
+		pixel_move(1, FALSE)
+
+/obj/item/projectile/proc/setAngle(new_angle)	//wrapper for overrides.
+	Angle = new_angle
+	if(!nondirectional_sprite)
+		var/matrix/M = new
+		M.Turn(Angle)
+		transform = M
+	if(trajectory)
+		trajectory.set_angle(new_angle)
+	return TRUE
+
+/obj/item/projectile/forceMove(atom/target)
+	if(!isloc(target) || !isloc(loc) || !z)
+		return ..()
+	var/zc = target.z != z
+	var/old = loc
+	if(zc)
+		before_z_change(old, target)
+	. = ..()
+	if(trajectory && !trajectory_ignore_forcemove && isturf(target))
+		if(hitscan)
+			finalize_hitscan_and_generate_tracers(FALSE)
+		trajectory.initialize_location(target.x, target.y, target.z, 0, 0)
+		if(hitscan)
+			record_hitscan_start(RETURN_PRECISE_POINT(src))
+	if(zc)
+		after_z_change(old, target)
+
+/obj/item/projectile/proc/fire(angle, atom/direct_target)
+	//If no angle needs to resolve it from xo/yo!
+	if(!log_override && firer && original)
+		log_combat(firer, original, "fired at", src, "from [get_area_name(src, TRUE)]")
+	if(direct_target)
+		if(prehit(direct_target))
+			direct_target.bullet_act(src, def_zone)
+			qdel(src)
+			return
+	if(isnum(angle))
+		setAngle(angle)
+	var/turf/starting = get_turf(src)
+	if(isnull(Angle))	//Try to resolve through offsets if there's no angle set.
+		if(isnull(xo) || isnull(yo))
+			stack_trace("WARNING: Projectile [type] deleted due to being unable to resolve a target after angle was null!")
+			qdel(src)
+			return
+		var/turf/target = locate(CLAMP(starting + xo, 1, world.maxx), CLAMP(starting + yo, 1, world.maxy), starting.z)
+		setAngle(Get_Angle(src, target))
+	if(dispersion)
+		setAngle(Angle + rand(-dispersion, dispersion))
+	original_angle = Angle
+	if(!nondirectional_sprite)
+		var/matrix/M = new
+		M.Turn(Angle)
+		transform = M
+	trajectory_ignore_forcemove = TRUE
+	forceMove(starting)
+	trajectory_ignore_forcemove = FALSE
+	trajectory = new(starting.x, starting.y, starting.z, pixel_x, pixel_y, Angle, SSprojectiles.global_pixel_speed)
+	last_projectile_move = world.time
+	permutated = list()
+	originalRange = range
+	fired = TRUE
+	if(hitscan)
+		process_hitscan()
+	if(!(datum_flags & DF_ISPROCESSING))
+		START_PROCESSING(SSprojectiles, src)
+	pixel_move(1, FALSE)	//move it now!
+
+/obj/item/projectile/proc/after_z_change(atom/olcloc, atom/newloc)
+
+/obj/item/projectile/proc/before_z_change(atom/oldloc, atom/newloc)
+
+
+/obj/item/projectile/proc/before_move()
+	return
+
+/obj/item/projectile/proc/after_move()
+	return
+
+/obj/item/projectile/proc/store_hitscan_collision(datum/point/pcache)
+	beam_segments[beam_index] = pcache
+	beam_index = pcache
+	beam_segments[beam_index] = null
+
+//Spread is FORCED!
+/obj/item/projectile/proc/preparePixelProjectile(atom/target, atom/source, params, spread = 0)
+	var/turf/curloc = get_turf(source)
+	var/turf/targloc = get_turf(target)
+	trajectory_ignore_forcemove = TRUE
+	forceMove(get_turf(source))
+	trajectory_ignore_forcemove = FALSE
+	starting = get_turf(source)
+	original = target
+	if(targloc || !params)
+		yo = targloc.y - curloc.y
+		xo = targloc.x - curloc.x
+		setAngle(Get_Angle(src, targloc) + spread)
+
+	if(isliving(source) && params)
+		var/list/calculated = calculate_projectile_angle_and_pixel_offsets(source, params)
+		p_x = calculated[2]
+		p_y = calculated[3]
+
+		setAngle(calculated[1] + spread)
+	else if(targloc)
+		yo = targloc.y - curloc.y
+		xo = targloc.x - curloc.x
+		setAngle(Get_Angle(src, targloc) + spread)
+	else
+		stack_trace("WARNING: Projectile [type] fired without either mouse parameters, or a target atom to aim at!")
+		qdel(src)
+
+/proc/calculate_projectile_angle_and_pixel_offsets(mob/user, params)
+	var/list/mouse_control = params2list(params)
+	var/p_x = 0
+	var/p_y = 0
+	var/angle = 0
+	if(mouse_control["icon-x"])
+		p_x = text2num(mouse_control["icon-x"])
+	if(mouse_control["icon-y"])
+		p_y = text2num(mouse_control["icon-y"])
+	if(mouse_control["screen-loc"])
+		//Split screen-loc up into X+Pixel_X and Y+Pixel_Y
+		var/list/screen_loc_params = splittext(mouse_control["screen-loc"], ",")
+
+		//Split X+Pixel_X up into list(X, Pixel_X)
+		var/list/screen_loc_X = splittext(screen_loc_params[1],":")
+
+		//Split Y+Pixel_Y up into list(Y, Pixel_Y)
+		var/list/screen_loc_Y = splittext(screen_loc_params[2],":")
+		var/x = text2num(screen_loc_X[1]) * 32 + text2num(screen_loc_X[2]) - 32
+		var/y = text2num(screen_loc_Y[1]) * 32 + text2num(screen_loc_Y[2]) - 32
+
+		//Calculate the "resolution" of screen based on client's view and world's icon size. This will work if the user can view more tiles than average.
+		var/list/screenview = getviewsize(user.client.view)
+		var/screenviewX = screenview[1] * world.icon_size
+		var/screenviewY = screenview[2] * world.icon_size
+
+		var/ox = round(screenviewX/2) - user.client.pixel_x //"origin" x
+		var/oy = round(screenviewY/2) - user.client.pixel_y //"origin" y
+		angle = ATAN2(y - oy, x - ox)
+	return list(angle, p_x, p_y)
+
+/obj/item/projectile/proc/old_style_target(atom/target, atom/source)
+	if(!source)
+		source = get_turf(src)
+	setAngle(Get_Angle(source, target))
+
+/obj/item/projectile/Destroy()
+	if(hitscan)
+		finalize_hitscan_and_generate_tracers()
+	STOP_PROCESSING(SSprojectiles, src)
+	cleanup_beam_segments()
+	qdel(trajectory)
+	return ..()
+
+/obj/item/projectile/proc/cleanup_beam_segments()
+	QDEL_LIST_ASSOC(beam_segments)
+	beam_segments = list()
+	qdel(beam_index)
+
+/obj/item/projectile/proc/vol_by_damage()
+	if(damage)
+		return Clamp((damage) * 0.67, 30, 100)// Multiply projectile damage by 0.67, then CLAMP the value between 30 and 100
+	else
+		return 50 //if the projectile doesn't do damage, play its hitsound at 50% volume.
+
+/obj/item/projectile/proc/finalize_hitscan_and_generate_tracers(impacting = TRUE)
+	if(trajectory && beam_index)
+		var/datum/point/pcache = trajectory.copy_to()
+		beam_segments[beam_index] = pcache
+	generate_hitscan_tracers(null, null, impacting)
+
+/obj/item/projectile/proc/generate_hitscan_tracers(cleanup = TRUE, duration = 3, impacting = TRUE)
+	if(!length(beam_segments))
+		return
+	if(tracer_type)
+		var/tempref = REF(src)
+		for(var/datum/point/p in beam_segments)
+			generate_tracer_between_points(p, beam_segments[p], tracer_type, color, duration, hitscan_light_range, hitscan_light_color_override, hitscan_light_intensity, tempref)
+	if(muzzle_type && duration > 0)
+		var/datum/point/p = beam_segments[1]
+		var/atom/movable/thing = new muzzle_type
+		p.move_atom_to_src(thing)
+		var/matrix/M = new
+		M.Turn(original_angle)
+		thing.transform = M
+		thing.color = color
+		thing.set_light(muzzle_flash_range, muzzle_flash_intensity, muzzle_flash_color_override? muzzle_flash_color_override : color)
+		QDEL_IN(thing, duration)
+	if(impacting && impact_type && duration > 0)
+		var/datum/point/p = beam_segments[beam_segments[beam_segments.len]]
+		var/atom/movable/thing = new impact_type
+		p.move_atom_to_src(thing)
+		var/matrix/M = new
+		M.Turn(Angle)
+		thing.transform = M
+		thing.color = color
+		thing.set_light(impact_light_range, impact_light_intensity, impact_light_color_override? impact_light_color_override : color)
+		QDEL_IN(thing, duration)
+	if(cleanup)
+		cleanup_beam_segments()
+
+//Returns true if the target atom is on our current turf and above the right layer
+/obj/item/projectile/proc/can_hit_target(atom/target, var/list/passthrough)
+	return (target && ((target.layer >= PROJECTILE_HIT_THRESHHOLD_LAYER) || ismob(target)) && (loc == get_turf(target)) && (!(target in passthrough)))
+
+/obj/item/projectile/Bump(atom/A)
+	var/datum/point/pcache = trajectory.copy_to()
+	if(A in permutated)
+		return FALSE
+	if(check_ricochet(A) && check_ricochet_flag(A) && ricochets < ricochets_max)
+		ricochets++
+		if(A.handle_ricochet(src))
+			on_ricochet(A)
+			ignore_source_check = TRUE
+			range = initial(range)
+			if(hitscan)
+				store_hitscan_collision(pcache)
+			return TRUE
+	if(firer && !ignore_source_check)
+		if(A == firer || (A == firer.loc && ismecha(A))) //cannot shoot yourself or your mech
+			trajectory_ignore_forcemove = TRUE
+			forceMove(get_turf(A))
+			trajectory_ignore_forcemove = FALSE
+			return FALSE
+
+	var/distance = get_dist(get_turf(A), starting) // Get the distance between the turf shot from and the mob we hit and use that for the calculations.
+	def_zone = ran_zone(def_zone, max(100-(7*distance), 5)) //Lower accurancy/longer range tradeoff. 7 is a balanced number to use.
+
+	if(isturf(A) && hitsound_wall)
+		var/volume = CLAMP(vol_by_damage() + 20, 0, 100)
+		if(suppressed)
+			volume = 5
+		playsound(loc, hitsound_wall, volume, 1, -1)
+
+	var/turf/target_turf = get_turf(A)
+	var/passthrough = FALSE
+
+	if(ismob(A))
+		var/mob/M = A
+		if(istype(A, /mob/living))
+			//if they have a neck grab on someone, that person gets hit instead
+			var/obj/item/weapon/grab/G = locate() in M
+			if(G && G.state >= GRAB_NECK)
+				if(G.affecting.stat == DEAD)
+					var/shield_chance = min(80, (30 * (M.mob_size / 10)))	//Small mobs have a harder time keeping a dead body as a shield than a human-sized one. Unathi would have an easier job, if they are made to be SIZE_LARGE in the future. -Mech
+					if(prob(shield_chance))
+						visible_message("<span class='danger'>\The [M] uses [G.affecting] as a shield!</span>")
+						if(Bump(G.affecting))
+							return
+					else
+						visible_message("<span class='danger'>\The [M] tries to use [G.affecting] as a shield, but fails!</span>")
+				else
+					visible_message("<span class='danger'>\The [M] uses [G.affecting] as a shield!</span>")
+					if(Bump(G.affecting))
+						return //If Bump() returns 0 (keep going) then we continue on to attack M.
+
+			passthrough = !attack_mob(M, distance)
+		else
+			passthrough = 1 //so ghosts don't stop bullets
+	else
+		passthrough = (A.bullet_act(src, def_zone) == PROJECTILE_CONTINUE) //backwards compatibility
+		if(isturf(A))
+			for(var/obj/O in A)
+				O.bullet_act(src)
+			for(var/mob/living/M in A)
+				attack_mob(M, distance)
+
+
+	//penetrating projectiles can pass through things that otherwise would not let them
+	if(!passthrough && penetrating > 0)
+		if(check_penetrate(A))
+			passthrough = TRUE
+		penetrating--
+
+	if(passthrough)
+		trajectory_ignore_forcemove = TRUE
+		forceMove(target_turf)
+		permutated.Add(A)
+		trajectory_ignore_forcemove = FALSE
+		return FALSE
+
+	if(A)
+		on_impact(A)
+	qdel(src)
+	return TRUE
 
 //TODO: make it so this is called more reliably, instead of sometimes by bullet_act() and sometimes not
-/obj/item/projectile/proc/on_hit(var/atom/target, var/blocked = 0, var/def_zone = null)
+/obj/item/projectile/proc/on_hit(atom/target, blocked = 0, def_zone)
 	if(blocked >= 100)		return 0//Full block
 	if(!isliving(target))	return 0
 //	if(isanimal(target))	return 0
@@ -88,14 +548,13 @@
 	L.apply_effects(stun, weaken, paralyze, irradiate, stutter, eyeblur, drowsy, agony, blocked, incendiary, flammability) // add in AGONY!
 	return 1
 
-//called when the projectile stops flying because it collided with something
-/obj/item/projectile/proc/on_impact(var/atom/A)
+//called when the projectile stops flying because it Bump'd with something
+/obj/item/projectile/proc/on_impact(atom/A)
 	impact_effect(effect_transform)		// generate impact effect
 	if(damage && damage_type == BURN)
 		var/turf/T = get_turf(A)
 		if(T)
 			T.hotspot_expose(700, 5)
-	return
 
 //Checks if the projectile is eligible for embedding. Not that it necessarily will.
 /obj/item/projectile/proc/can_embed()
@@ -110,25 +569,53 @@
 	return 0
 
 //return 1 if the projectile should be allowed to pass through after all, 0 if not.
-/obj/item/projectile/proc/check_penetrate(var/atom/A)
+/obj/item/projectile/proc/check_penetrate(atom/A)
 	return 1
 
-/obj/item/projectile/proc/check_fire(atom/target as mob, var/mob/living/user as mob)  //Checks if you can hit them or not.
+/obj/item/projectile/proc/check_fire(atom/target as mob, mob/living/user as mob)  //Checks if you can hit them or not.
 	check_trajectory(target, user, pass_flags, flags)
 
-//sets the click point of the projectile using mouse input params
-/obj/item/projectile/proc/set_clickpoint(var/params)
-	var/list/mouse_control = params2list(params)
-	if(mouse_control["icon-x"])
-		p_x = text2num(mouse_control["icon-x"])
-	if(mouse_control["icon-y"])
-		p_y = text2num(mouse_control["icon-y"])
+/obj/item/projectile/CanPass()
+	return TRUE
+
+//Called when the projectile intercepts a mob. Returns 1 if the projectile hit the mob, 0 if it missed and should keep flying.
+/obj/item/projectile/proc/attack_mob(mob/living/target_mob, distance, miss_modifier = 0)
+	if(!istype(target_mob))
+		return
+
+	//roll to-hit
+	miss_modifier = max(15*(distance-2) - accuracy + miss_modifier + target_mob.get_evasion(), 0)
+	var/hit_zone = get_zone_with_miss_chance(def_zone, target_mob, miss_modifier, ranged_attack=(distance > 1 || original != target_mob)) //if the projectile hits a target we weren't originally aiming at then retain the chance to miss
+
+	var/result = PROJECTILE_FORCE_MISS
+	if(hit_zone)
+		def_zone = hit_zone //set def_zone, so if the projectile ends up hitting someone else later (to be implemented), it is more likely to hit the same part
+		result = target_mob.bullet_act(src, def_zone)
+
+	if(result == PROJECTILE_FORCE_MISS)
+		if(!silenced)
+			visible_message("<span class='notice'>\The [src] misses [target_mob] narrowly!</span>")
+		return FALSE
+
+	//hit messages
+	if(silenced)
+		to_chat(target_mob, "<span class='danger'>You've been hit in the [parse_zone(def_zone)] by \the [src]!</span>")
+	else
+		visible_message("<span class='danger'>\The [target_mob] is hit by \the [src] in the [parse_zone(def_zone)]!</span>")//X has fired Y is now given by the guns so you cant tell who shot you if you could not see the shooter
+
+	//admin logs
+	if(!no_attack_log)
+		if(istype(firer, /mob) && istype(target_mob))
+			add_attack_logs(firer,target_mob,"Shot with \a [src.type] projectile")
+
+	//sometimes bullet_act() will want the projectile to continue flying
+	if (result == PROJECTILE_CONTINUE)
+		return FALSE
+
+	return TRUE
+
+//ABOVE UNIFIED BELOW POLARIS
 
-	//randomize clickpoint a bit based on dispersion
-	if(dispersion)
-		var/radius = round((dispersion*0.443)*world.icon_size*0.8) //0.443 = sqrt(pi)/4 = 2a, where a is the side length of a square that shares the same area as a circle with diameter = dispersion
-		p_x = between(0, p_x + rand(-radius, radius), world.icon_size)
-		p_y = between(0, p_y + rand(-radius, radius), world.icon_size)
 
 //called to launch a projectile
 /obj/item/projectile/proc/launch(atom/target, var/target_zone, var/x_offset=0, var/y_offset=0, var/angle_offset=0)
@@ -181,313 +668,32 @@
 
 	setup_trajectory(starting_loc, new_target)
 
-//Called when the projectile intercepts a mob. Returns 1 if the projectile hit the mob, 0 if it missed and should keep flying.
-/obj/item/projectile/proc/attack_mob(var/mob/living/target_mob, var/distance, var/miss_modifier=0)
-	if(!istype(target_mob))
-		return
 
-	//roll to-hit
-	miss_modifier = max(15*(distance-2) - accuracy + miss_modifier + target_mob.get_evasion(), 0)
-	var/hit_zone = get_zone_with_miss_chance(def_zone, target_mob, miss_modifier, ranged_attack=(distance > 1 || original != target_mob)) //if the projectile hits a target we weren't originally aiming at then retain the chance to miss
+//ABOVE POLARIS
 
-	var/result = PROJECTILE_FORCE_MISS
-	if(hit_zone)
-		def_zone = hit_zone //set def_zone, so if the projectile ends up hitting someone else later (to be implemented), it is more likely to hit the same part
-		result = target_mob.bullet_act(src, def_zone)
 
-	if(result == PROJECTILE_FORCE_MISS)
-		if(!silenced)
-			visible_message("<span class='notice'>\The [src] misses [target_mob] narrowly!</span>")
-		return 0
 
-	//hit messages
-	if(silenced)
-		to_chat(target_mob, "<span class='danger'>You've been hit in the [parse_zone(def_zone)] by \the [src]!</span>")
-	else
-		visible_message("<span class='danger'>\The [target_mob] is hit by \the [src] in the [parse_zone(def_zone)]!</span>")//X has fired Y is now given by the guns so you cant tell who shot you if you could not see the shooter
+//BELOW AURORA
 
-	//admin logs
-	if(!no_attack_log)
-		if(istype(firer, /mob) && istype(target_mob))
-			add_attack_logs(firer,target_mob,"Shot with \a [src.type] projectile")
 
-	//sometimes bullet_act() will want the projectile to continue flying
-	if (result == PROJECTILE_CONTINUE)
-		return 0
 
-	return 1
-
-/obj/item/projectile/Bump(atom/A as mob|obj|turf|area, forced=0)
-	if(A == src)
-		return 0 //no
-
-	if(A == firer)
-		loc = A.loc
-		return 0 //cannot shoot yourself
-
-	if((bumped && !forced) || (A in permutated))
-		return 0
-
-	var/passthrough = 0 //if the projectile should continue flying
-	var/distance = get_dist(starting,loc)
-
-	bumped = 1
-	if(ismob(A))
-		var/mob/M = A
-		if(istype(A, /mob/living))
-			//if they have a neck grab on someone, that person gets hit instead
-			var/obj/item/weapon/grab/G = locate() in M
-			if(G && G.state >= GRAB_NECK)
-				if(G.affecting.stat == DEAD)
-					var/shield_chance = min(80, (30 * (M.mob_size / 10)))	//Small mobs have a harder time keeping a dead body as a shield than a human-sized one. Unathi would have an easier job, if they are made to be SIZE_LARGE in the future. -Mech
-					if(prob(shield_chance))
-						visible_message("<span class='danger'>\The [M] uses [G.affecting] as a shield!</span>")
-						if(Bump(G.affecting, forced=1))
-							return
-					else
-						visible_message("<span class='danger'>\The [M] tries to use [G.affecting] as a shield, but fails!</span>")
-				else
-					visible_message("<span class='danger'>\The [M] uses [G.affecting] as a shield!</span>")
-					if(Bump(G.affecting, forced=1))
-						return //If Bump() returns 0 (keep going) then we continue on to attack M.
-
-			passthrough = !attack_mob(M, distance)
-		else
-			passthrough = 1 //so ghosts don't stop bullets
-	else
-		passthrough = (A.bullet_act(src, def_zone) == PROJECTILE_CONTINUE) //backwards compatibility
-		if(isturf(A))
-			for(var/obj/O in A)
-				O.bullet_act(src)
-			for(var/mob/living/M in A)
-				attack_mob(M, distance)
-
-	//penetrating projectiles can pass through things that otherwise would not let them
-	if(!passthrough && penetrating > 0)
-		if(check_penetrate(A))
-			passthrough = 1
-		penetrating--
-
-	//the bullet passes through a dense object!
-	if(passthrough)
-		//move ourselves onto A so we can continue on our way.
-		if(A)
-			if(istype(A, /turf))
-				loc = A
-			else
-				loc = A.loc
-			permutated.Add(A)
-		bumped = 0 //reset bumped variable!
-		return 0
-
-	//stop flying
-	on_impact(A)
-
-	density = 0
-	invisibility = 101
-
-	qdel(src)
-	return 1
-
-/obj/item/projectile/ex_act()
-	return //explosions probably shouldn't delete projectiles
-
-/obj/item/projectile/CanPass(atom/movable/mover, turf/target, height=0, air_group=0)
-	return 1
-
-/obj/item/projectile/process()
-	var/first_step = 1
-
-	spawn while(src && src.loc)
-		if(kill_count-- < 1)
-			on_impact(src.loc) //for any final impact behaviours
-			qdel(src)
-			return
-		if((!( current ) || loc == current))
-			current = locate(min(max(x + xo, 1), world.maxx), min(max(y + yo, 1), world.maxy), z)
-		if((x == 1 || x == world.maxx || y == 1 || y == world.maxy))
-			qdel(src)
-			return
-
-		trajectory.increment()	// increment the current location
-		location = trajectory.return_location(location)		// update the locally stored location data
-		update_light() //energy projectiles will look glowy and fun
-
-		if(!location)
-			qdel(src)	// if it's left the world... kill it
-			return
-
-		if (is_below_sound_pressure(get_turf(src)) && !vacuum_traversal) //Deletes projectiles that aren't supposed to bein vacuum if they leave pressurised areas
-			qdel(src)
-			return
-
-		before_move()
-		Move(location.return_turf())
-		after_move()
-
-		if(!bumped && !isturf(original))
-			if(loc == get_turf(original))
-				if(!(original in permutated))
-					if(Bump(original))
-						return
-
-		if(first_step)
-			muzzle_effect(effect_transform)
-			first_step = 0
-		else if(!bumped)
-			tracer_effect(effect_transform)
-
-		if(incendiary >= 2) //This should cover the bases of 'Why is there fuel here?' in a much cleaner way than previous.
-			if(src && src.loc) //Safety.
-				if(!src.loc.density)
-					var/trail_volume = (flammability * 0.20)
-					new /obj/effect/decal/cleanable/liquid_fuel/flamethrower_fuel(src.loc, trail_volume, src.dir)
-
-		if(!hitscan)
-			sleep(step_delay)	//add delay between movement iterations if it's not a hitscan weapon
-
-/obj/item/projectile/proc/before_move()
-	return
-
-/obj/item/projectile/proc/after_move()
-	return
-
-/obj/item/projectile/proc/setup_trajectory(turf/startloc, turf/targloc, var/x_offset = 0, var/y_offset = 0)
-	// setup projectile state
-	starting = startloc
-	current = startloc
-	yo = targloc.y - startloc.y + y_offset
-	xo = targloc.x - startloc.x + x_offset
-
-	// trajectory dispersion
-	var/offset = 0
-	if(dispersion)
-		var/radius = round(dispersion*9, 1)
-		offset = rand(-radius, radius)
-
-	// plot the initial trajectory
-	trajectory = new()
-	trajectory.setup(starting, original, pixel_x, pixel_y, angle_offset=offset)
-
-	// generate this now since all visual effects the projectile makes can use it
-	effect_transform = new()
-	effect_transform.Scale(trajectory.return_hypotenuse(), 1)
-	effect_transform.Turn(-trajectory.return_angle())		//no idea why this has to be inverted, but it works
-
-	transform = turn(transform, -(trajectory.return_angle() + 90)) //no idea why 90 needs to be added, but it works
-
-/obj/item/projectile/proc/muzzle_effect(var/matrix/T)
-	if(silenced)
-		return
-
-	if(ispath(muzzle_type))
-		var/obj/effect/projectile/M = new muzzle_type(get_turf(src))
-
-		if(istype(M))
-			M.set_transform(T)
-			M.pixel_x = location.pixel_x
-			M.pixel_y = location.pixel_y
-			M.update_light()
-			M.activate()
-
-/obj/item/projectile/proc/tracer_effect(var/matrix/M)
-	if(ispath(tracer_type))
-		var/obj/effect/projectile/P = new tracer_type(location.loc)
-
-		if(istype(P))
-			P.set_transform(M)
-			P.pixel_x = location.pixel_x
-			P.pixel_y = location.pixel_y
-			P.update_light()
-			if(!hitscan)
-				P.activate(step_delay)	//if not a hitscan projectile, remove after a single delay
-			else
-				P.activate()
-
-/obj/item/projectile/proc/impact_effect(var/matrix/M)
-	if(ispath(tracer_type) && location)
-		var/obj/effect/projectile/P = new impact_type(location.loc)
-
-		if(istype(P))
-			P.set_transform(M)
-			P.pixel_x = location.pixel_x
-			P.pixel_y = location.pixel_y
-			P.update_light()
-			P.activate()
-
-//"Tracing" projectile
-/obj/item/projectile/test //Used to see if you can hit them.
-	invisibility = 101 //Nope!  Can't see me!
-	yo = null
-	xo = null
-	var/result = 0 //To pass the message back to the gun.
-
-/obj/item/projectile/test/Bump(atom/A as mob|obj|turf|area)
-	if(A == firer)
-		loc = A.loc
-		return //cannot shoot yourself
-	if(istype(A, /obj/item/projectile))
-		return
-	if(istype(A, /obj/structure/foamedmetal)) //Turrets can detect through foamed metal, but will have to blast through it. Similar to windows, if someone runs behind it, a person should probably just not shoot.
-		return
-	if(istype(A, /obj/structure/girder)) //They see you there.
-		return
-	if(istype(A, /obj/structure/door_assembly)) //And through there.
-		return
-	if(istype(A, /obj/structure)) //Unanchored things you can shove around will still keep the turret or other firing at your position. Aim intent still functions.
-		var/obj/structure/S = A
-		if(!S.anchored)
-			return
-	if(istype(A, /mob/living) || istype(A, /obj/mecha) || istype(A, /obj/vehicle))
-		result = 2 //We hit someone, return 1!
-		return
-	result = 1
-	return
-
-/obj/item/projectile/test/launch(atom/target)
-	var/turf/curloc = get_turf(src)
-	var/turf/targloc = get_turf(target)
-	if(!curloc || !targloc)
-		return 0
 
+/obj/item/projectile/proc/launch_projectile(atom/target, target_zone, mob/user, params, angle_override, forced_spread = 0)
 	original = target
+	def_zone = check_zone(target_zone)
+	firer = user
+	var/direct_target
+	if(get_turf(target) == get_turf(src))
+		direct_target = target
 
-	//plot the initial trajectory
-	setup_trajectory(curloc, targloc)
-	return process(targloc)
+	preparePixelProjectile(target, user? user : get_turf(src), params, forced_spread)
+	return fire(angle_override, direct_target)
 
-/obj/item/projectile/test/process(var/turf/targloc)
-	while(src) //Loop on through!
-		if(result)
-			return (result - 1)
-		if((!( targloc ) || loc == targloc))
-			targloc = locate(min(max(x + xo, 1), world.maxx), min(max(y + yo, 1), world.maxy), z) //Finding the target turf at map edge
+//called to launch a projectile from a gun
+/obj/item/projectile/proc/launch_from_gun(atom/target, target_zone, mob/user, params, angle_override, forced_spread, obj/item/weapon/gun/launcher)
 
-		trajectory.increment()	// increment the current location
-		location = trajectory.return_location(location)		// update the locally stored location data
+	shot_from = launcher.name
+	silenced = launcher.silenced
 
-		Move(location.return_turf())
+	return launch_projectile(target, target_zone, user, params, angle_override, forced_spread)
 
-		var/mob/living/M = locate() in get_turf(src)
-		if(istype(M)) //If there is someting living...
-			return 1 //Return 1
-		else
-			M = locate() in get_step(src,targloc)
-			if(istype(M))
-				return 1
-
-//Helper proc to check if you can hit them or not.
-/proc/check_trajectory(atom/target as mob|obj, atom/firer as mob|obj, var/pass_flags=PASSTABLE|PASSGLASS|PASSGRILLE, flags=null)
-	if(!istype(target) || !istype(firer))
-		return 0
-
-	var/obj/item/projectile/test/trace = new /obj/item/projectile/test(get_turf(firer)) //Making the test....
-
-	//Set the flags and pass flags to that of the real projectile...
-	if(!isnull(flags))
-		trace.flags = flags
-	trace.pass_flags = pass_flags
-
-	var/output = trace.launch(target) //Test it!
-	qdel(trace) //No need for it anymore
-	return output //Send it back to the gun!

code/modules/projectiles/projectile/trace.dm

@@ -0,0 +1,38 @@
+//Helper proc to check if you can hit them or not.
+/proc/check_trajectory(atom/target as mob|obj, atom/firer as mob|obj, var/pass_flags=PASSTABLE|PASSGLASS|PASSGRILLE, flags=null)
+	if(!istype(target) || !istype(firer))
+		return 0
+
+	var/obj/item/projectile/test/trace = new /obj/item/projectile/test(get_turf(firer)) //Making the test....
+
+	//Set the flags and pass flags to that of the real projectile...
+	if(!isnull(flags))
+		trace.flags = flags
+	trace.pass_flags = pass_flags
+
+	return trace.launch_projectile(target) //Test it!
+
+/obj/item/projectile/proc/_check_fire(atom/target as mob, var/mob/living/user as mob)  //Checks if you can hit them or not.
+	check_trajectory(target, user, pass_flags, flags)
+
+//"Tracing" projectile
+/obj/item/projectile/test //Used to see if you can hit them.
+	invisibility = 101 //Nope!  Can't see me!
+	hitscan = TRUE
+	nodamage = TRUE
+	damage = 0
+	var/list/hit = list()
+
+/obj/item/projectile/test/process_hitscan()
+	. = ..()
+	if(!QDELING(src))
+		qdel(src)
+	return hit
+
+/obj/item/projectile/test/Collide(atom/A)
+	if(A != src)
+		hit |= A
+	return ..()
+
+/obj/item/projectile/test/attack_mob()
+	return

polaris.dme

@@ -85,7 +85,7 @@
 #include "code\_helpers\turfs.dm"
 #include "code\_helpers\type2type.dm"
 #include "code\_helpers\unsorted.dm"
-#include "code\_helpers\vector.dm"
+#include "code\_helpers\view.dm"
 #include "code\_helpers\sorts\__main.dm"
 #include "code\_helpers\sorts\comparators.dm"
 #include "code\_helpers\sorts\TimSort.dm"
@@ -218,6 +218,7 @@
 #include "code\datums\mutable_appearance.dm"
 #include "code\datums\orbit.dm"
 #include "code\datums\organs.dm"
+#include "code\datums\position_point_vector.dm"
 #include "code\datums\progressbar.dm"
 #include "code\datums\recipe.dm"
 #include "code\datums\riding.dm"
@@ -841,6 +842,11 @@
 #include "code\game\objects\effects\decals\posters\polarisposters.dm"
 #include "code\game\objects\effects\spawners\bombspawner.dm"
 #include "code\game\objects\effects\spawners\gibspawner.dm"
+#include "code\game\objects\effects\temporary_visuals\temporary_visual.dm"
+#include "code\game\objects\effects\temporary_visuals\projectiles\impact.dm"
+#include "code\game\objects\effects\temporary_visuals\projectiles\muzzle.dm"
+#include "code\game\objects\effects\temporary_visuals\projectiles\projectile_effects.dm"
+#include "code\game\objects\effects\temporary_visuals\projectiles\tracer.dm"
 #include "code\game\objects\items\antag_spawners.dm"
 #include "code\game\objects\items\apc_frame.dm"
 #include "code\game\objects\items\blueprints.dm"
@@ -2179,6 +2185,7 @@
 #include "code\modules\projectiles\projectile\magnetic.dm"
 #include "code\modules\projectiles\projectile\pellets.dm"
 #include "code\modules\projectiles\projectile\special.dm"
+#include "code\modules\projectiles\projectile\trace.dm"
 #include "code\modules\projectiles\targeting\targeting_client.dm"
 #include "code\modules\projectiles\targeting\targeting_gun.dm"
 #include "code\modules\projectiles\targeting\targeting_mob.dm"